1 /* $KAME: pfkey.c,v 1.46 2003/08/26 03:37:06 itojun Exp $ */ 2 3 /* 4 * Copyright (C) 1995, 1996, 1997, 1998, and 1999 WIDE Project. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. Neither the name of the project nor the names of its contributors 16 * may be used to endorse or promote products derived from this software 17 * without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 */ 31 32 #include <sys/cdefs.h> 33 __FBSDID("$FreeBSD$"); 34 35 #include <sys/types.h> 36 #include <sys/param.h> 37 #include <sys/socket.h> 38 #include <net/pfkeyv2.h> 39 #include <netipsec/key_var.h> 40 #include <netinet/in.h> 41 #include <netipsec/ipsec.h> 42 43 #include <stdlib.h> 44 #include <unistd.h> 45 #include <string.h> 46 #include <errno.h> 47 48 #include "ipsec_strerror.h" 49 #include "libpfkey.h" 50 51 #define CALLOC(size, cast) (cast)calloc(1, (size)) 52 53 static int findsupportedmap(int); 54 static int setsupportedmap(struct sadb_supported *); 55 static struct sadb_alg *findsupportedalg(u_int, u_int); 56 static int pfkey_send_x1(int, u_int, u_int, u_int, struct sockaddr *, 57 struct sockaddr *, u_int32_t, u_int32_t, u_int, caddr_t, 58 u_int, u_int, u_int, u_int, u_int, u_int32_t, u_int32_t, 59 u_int32_t, u_int32_t, u_int32_t); 60 static int pfkey_send_x2(int, u_int, u_int, u_int, 61 struct sockaddr *, struct sockaddr *, u_int32_t); 62 static int pfkey_send_x3(int, u_int, u_int); 63 static int pfkey_send_x4(int, u_int, struct sockaddr *, u_int, 64 struct sockaddr *, u_int, u_int, u_int64_t, u_int64_t, 65 char *, int, u_int32_t); 66 static int pfkey_send_x5(int, u_int, u_int32_t); 67 68 static caddr_t pfkey_setsadbmsg(caddr_t, caddr_t, u_int, u_int, 69 u_int, u_int32_t, pid_t); 70 static caddr_t pfkey_setsadbsa(caddr_t, caddr_t, u_int32_t, u_int, 71 u_int, u_int, u_int32_t); 72 static caddr_t pfkey_setsadbaddr(caddr_t, caddr_t, u_int, 73 struct sockaddr *, u_int, u_int); 74 static caddr_t pfkey_setsadbkey(caddr_t, caddr_t, u_int, caddr_t, u_int); 75 static caddr_t pfkey_setsadblifetime(caddr_t, caddr_t, u_int, u_int32_t, 76 u_int32_t, u_int32_t, u_int32_t); 77 static caddr_t pfkey_setsadbxsa2(caddr_t, caddr_t, u_int32_t, u_int32_t); 78 79 /* 80 * make and search supported algorithm structure. 81 */ 82 static struct sadb_supported *ipsec_supported[] = { NULL, NULL, NULL, NULL }; 83 84 static int supported_map[] = { 85 SADB_SATYPE_AH, 86 SADB_SATYPE_ESP, 87 SADB_X_SATYPE_IPCOMP, 88 SADB_X_SATYPE_TCPSIGNATURE 89 }; 90 91 static int 92 findsupportedmap(satype) 93 int satype; 94 { 95 int i; 96 97 for (i = 0; i < sizeof(supported_map)/sizeof(supported_map[0]); i++) 98 if (supported_map[i] == satype) 99 return i; 100 return -1; 101 } 102 103 static struct sadb_alg * 104 findsupportedalg(satype, alg_id) 105 u_int satype, alg_id; 106 { 107 int algno; 108 int tlen; 109 caddr_t p; 110 111 /* validity check */ 112 algno = findsupportedmap(satype); 113 if (algno == -1) { 114 __ipsec_errcode = EIPSEC_INVAL_ARGUMENT; 115 return NULL; 116 } 117 if (ipsec_supported[algno] == NULL) { 118 __ipsec_errcode = EIPSEC_DO_GET_SUPP_LIST; 119 return NULL; 120 } 121 122 tlen = ipsec_supported[algno]->sadb_supported_len 123 - sizeof(struct sadb_supported); 124 p = (caddr_t)(ipsec_supported[algno] + 1); 125 while (tlen > 0) { 126 if (tlen < sizeof(struct sadb_alg)) { 127 /* invalid format */ 128 break; 129 } 130 if (((struct sadb_alg *)p)->sadb_alg_id == alg_id) 131 return (struct sadb_alg *)p; 132 133 tlen -= sizeof(struct sadb_alg); 134 p += sizeof(struct sadb_alg); 135 } 136 137 __ipsec_errcode = EIPSEC_NOT_SUPPORTED; 138 return NULL; 139 } 140 141 static int 142 setsupportedmap(sup) 143 struct sadb_supported *sup; 144 { 145 struct sadb_supported **ipsup; 146 147 switch (sup->sadb_supported_exttype) { 148 case SADB_EXT_SUPPORTED_AUTH: 149 ipsup = &ipsec_supported[findsupportedmap(SADB_SATYPE_AH)]; 150 break; 151 case SADB_EXT_SUPPORTED_ENCRYPT: 152 ipsup = &ipsec_supported[findsupportedmap(SADB_SATYPE_ESP)]; 153 break; 154 default: 155 __ipsec_errcode = EIPSEC_INVAL_SATYPE; 156 return -1; 157 } 158 159 if (*ipsup) 160 free(*ipsup); 161 162 *ipsup = malloc(sup->sadb_supported_len); 163 if (!*ipsup) { 164 __ipsec_set_strerror(strerror(errno)); 165 return -1; 166 } 167 memcpy(*ipsup, sup, sup->sadb_supported_len); 168 169 return 0; 170 } 171 172 /* 173 * check key length against algorithm specified. 174 * This function is called with SADB_EXT_SUPPORTED_{AUTH,ENCRYPT} as the 175 * augument, and only calls to ipsec_check_keylen2(); 176 * keylen is the unit of bit. 177 * OUT: 178 * -1: invalid. 179 * 0: valid. 180 */ 181 int 182 ipsec_check_keylen(supported, alg_id, keylen) 183 u_int supported; 184 u_int alg_id; 185 u_int keylen; 186 { 187 int satype; 188 189 /* validity check */ 190 switch (supported) { 191 case SADB_EXT_SUPPORTED_AUTH: 192 satype = SADB_SATYPE_AH; 193 break; 194 case SADB_EXT_SUPPORTED_ENCRYPT: 195 satype = SADB_SATYPE_ESP; 196 break; 197 default: 198 __ipsec_errcode = EIPSEC_INVAL_ARGUMENT; 199 return -1; 200 } 201 202 return ipsec_check_keylen2(satype, alg_id, keylen); 203 } 204 205 /* 206 * check key length against algorithm specified. 207 * satype is one of satype defined at pfkeyv2.h. 208 * keylen is the unit of bit. 209 * OUT: 210 * -1: invalid. 211 * 0: valid. 212 */ 213 int 214 ipsec_check_keylen2(satype, alg_id, keylen) 215 u_int satype; 216 u_int alg_id; 217 u_int keylen; 218 { 219 struct sadb_alg *alg; 220 221 alg = findsupportedalg(satype, alg_id); 222 if (!alg) 223 return -1; 224 225 if (keylen < alg->sadb_alg_minbits || keylen > alg->sadb_alg_maxbits) { 226 __ipsec_errcode = EIPSEC_INVAL_KEYLEN; 227 return -1; 228 } 229 230 __ipsec_errcode = EIPSEC_NO_ERROR; 231 return 0; 232 } 233 234 /* 235 * get max/min key length against algorithm specified. 236 * satype is one of satype defined at pfkeyv2.h. 237 * keylen is the unit of bit. 238 * OUT: 239 * -1: invalid. 240 * 0: valid. 241 */ 242 int 243 ipsec_get_keylen(supported, alg_id, alg0) 244 u_int supported, alg_id; 245 struct sadb_alg *alg0; 246 { 247 struct sadb_alg *alg; 248 u_int satype; 249 250 /* validity check */ 251 if (!alg0) { 252 __ipsec_errcode = EIPSEC_INVAL_ARGUMENT; 253 return -1; 254 } 255 256 switch (supported) { 257 case SADB_EXT_SUPPORTED_AUTH: 258 satype = SADB_SATYPE_AH; 259 break; 260 case SADB_EXT_SUPPORTED_ENCRYPT: 261 satype = SADB_SATYPE_ESP; 262 break; 263 default: 264 __ipsec_errcode = EIPSEC_INVAL_ARGUMENT; 265 return -1; 266 } 267 268 alg = findsupportedalg(satype, alg_id); 269 if (!alg) 270 return -1; 271 272 memcpy(alg0, alg, sizeof(*alg0)); 273 274 __ipsec_errcode = EIPSEC_NO_ERROR; 275 return 0; 276 } 277 278 /* 279 * set the rate for SOFT lifetime against HARD one. 280 * If rate is more than 100 or equal to zero, then set to 100. 281 */ 282 static u_int soft_lifetime_allocations_rate = PFKEY_SOFT_LIFETIME_RATE; 283 static u_int soft_lifetime_bytes_rate = PFKEY_SOFT_LIFETIME_RATE; 284 static u_int soft_lifetime_addtime_rate = PFKEY_SOFT_LIFETIME_RATE; 285 static u_int soft_lifetime_usetime_rate = PFKEY_SOFT_LIFETIME_RATE; 286 287 u_int 288 pfkey_set_softrate(type, rate) 289 u_int type, rate; 290 { 291 __ipsec_errcode = EIPSEC_NO_ERROR; 292 293 if (rate > 100 || rate == 0) 294 rate = 100; 295 296 switch (type) { 297 case SADB_X_LIFETIME_ALLOCATIONS: 298 soft_lifetime_allocations_rate = rate; 299 return 0; 300 case SADB_X_LIFETIME_BYTES: 301 soft_lifetime_bytes_rate = rate; 302 return 0; 303 case SADB_X_LIFETIME_ADDTIME: 304 soft_lifetime_addtime_rate = rate; 305 return 0; 306 case SADB_X_LIFETIME_USETIME: 307 soft_lifetime_usetime_rate = rate; 308 return 0; 309 } 310 311 __ipsec_errcode = EIPSEC_INVAL_ARGUMENT; 312 return 1; 313 } 314 315 /* 316 * get current rate for SOFT lifetime against HARD one. 317 * ATTENTION: ~0 is returned if invalid type was passed. 318 */ 319 u_int 320 pfkey_get_softrate(type) 321 u_int type; 322 { 323 switch (type) { 324 case SADB_X_LIFETIME_ALLOCATIONS: 325 return soft_lifetime_allocations_rate; 326 case SADB_X_LIFETIME_BYTES: 327 return soft_lifetime_bytes_rate; 328 case SADB_X_LIFETIME_ADDTIME: 329 return soft_lifetime_addtime_rate; 330 case SADB_X_LIFETIME_USETIME: 331 return soft_lifetime_usetime_rate; 332 } 333 334 return ~0; 335 } 336 337 /* 338 * sending SADB_GETSPI message to the kernel. 339 * OUT: 340 * positive: success and return length sent. 341 * -1 : error occured, and set errno. 342 */ 343 int 344 pfkey_send_getspi(so, satype, mode, src, dst, min, max, reqid, seq) 345 int so; 346 u_int satype, mode; 347 struct sockaddr *src, *dst; 348 u_int32_t min, max, reqid, seq; 349 { 350 struct sadb_msg *newmsg; 351 caddr_t ep; 352 int len; 353 int need_spirange = 0; 354 caddr_t p; 355 int plen; 356 357 /* validity check */ 358 if (src == NULL || dst == NULL) { 359 __ipsec_errcode = EIPSEC_INVAL_ARGUMENT; 360 return -1; 361 } 362 if (src->sa_family != dst->sa_family) { 363 __ipsec_errcode = EIPSEC_FAMILY_MISMATCH; 364 return -1; 365 } 366 if (min > max || (min > 0 && min <= 255)) { 367 __ipsec_errcode = EIPSEC_INVAL_SPI; 368 return -1; 369 } 370 switch (src->sa_family) { 371 case AF_INET: 372 plen = sizeof(struct in_addr) << 3; 373 break; 374 case AF_INET6: 375 plen = sizeof(struct in6_addr) << 3; 376 break; 377 default: 378 __ipsec_errcode = EIPSEC_INVAL_FAMILY; 379 return -1; 380 } 381 382 /* create new sadb_msg to send. */ 383 len = sizeof(struct sadb_msg) 384 + sizeof(struct sadb_x_sa2) 385 + sizeof(struct sadb_address) 386 + PFKEY_ALIGN8(src->sa_len) 387 + sizeof(struct sadb_address) 388 + PFKEY_ALIGN8(dst->sa_len); 389 390 if (min > 255 && max < ~0) { 391 need_spirange++; 392 len += sizeof(struct sadb_spirange); 393 } 394 395 if ((newmsg = CALLOC(len, struct sadb_msg *)) == NULL) { 396 __ipsec_set_strerror(strerror(errno)); 397 return -1; 398 } 399 ep = ((caddr_t)newmsg) + len; 400 401 p = pfkey_setsadbmsg((caddr_t)newmsg, ep, SADB_GETSPI, 402 len, satype, seq, getpid()); 403 if (!p) { 404 free(newmsg); 405 return -1; 406 } 407 408 p = pfkey_setsadbxsa2(p, ep, mode, reqid); 409 if (!p) { 410 free(newmsg); 411 return -1; 412 } 413 414 /* set sadb_address for source */ 415 p = pfkey_setsadbaddr(p, ep, SADB_EXT_ADDRESS_SRC, src, plen, 416 IPSEC_ULPROTO_ANY); 417 if (!p) { 418 free(newmsg); 419 return -1; 420 } 421 422 /* set sadb_address for destination */ 423 p = pfkey_setsadbaddr(p, ep, SADB_EXT_ADDRESS_DST, dst, plen, 424 IPSEC_ULPROTO_ANY); 425 if (!p) { 426 free(newmsg); 427 return -1; 428 } 429 430 /* proccessing spi range */ 431 if (need_spirange) { 432 struct sadb_spirange spirange; 433 434 if (p + sizeof(spirange) > ep) { 435 free(newmsg); 436 return -1; 437 } 438 439 memset(&spirange, 0, sizeof(spirange)); 440 spirange.sadb_spirange_len = PFKEY_UNIT64(sizeof(spirange)); 441 spirange.sadb_spirange_exttype = SADB_EXT_SPIRANGE; 442 spirange.sadb_spirange_min = min; 443 spirange.sadb_spirange_max = max; 444 445 memcpy(p, &spirange, sizeof(spirange)); 446 447 p += sizeof(spirange); 448 } 449 if (p != ep) { 450 free(newmsg); 451 return -1; 452 } 453 454 /* send message */ 455 len = pfkey_send(so, newmsg, len); 456 free(newmsg); 457 458 if (len < 0) 459 return -1; 460 461 __ipsec_errcode = EIPSEC_NO_ERROR; 462 return len; 463 } 464 465 /* 466 * sending SADB_UPDATE message to the kernel. 467 * The length of key material is a_keylen + e_keylen. 468 * OUT: 469 * positive: success and return length sent. 470 * -1 : error occured, and set errno. 471 */ 472 int 473 pfkey_send_update(so, satype, mode, src, dst, spi, reqid, wsize, 474 keymat, e_type, e_keylen, a_type, a_keylen, flags, 475 l_alloc, l_bytes, l_addtime, l_usetime, seq) 476 int so; 477 u_int satype, mode, wsize; 478 struct sockaddr *src, *dst; 479 u_int32_t spi, reqid; 480 caddr_t keymat; 481 u_int e_type, e_keylen, a_type, a_keylen, flags; 482 u_int32_t l_alloc; 483 u_int64_t l_bytes, l_addtime, l_usetime; 484 u_int32_t seq; 485 { 486 int len; 487 if ((len = pfkey_send_x1(so, SADB_UPDATE, satype, mode, src, dst, spi, 488 reqid, wsize, 489 keymat, e_type, e_keylen, a_type, a_keylen, flags, 490 l_alloc, l_bytes, l_addtime, l_usetime, seq)) < 0) 491 return -1; 492 493 return len; 494 } 495 496 /* 497 * sending SADB_ADD message to the kernel. 498 * The length of key material is a_keylen + e_keylen. 499 * OUT: 500 * positive: success and return length sent. 501 * -1 : error occured, and set errno. 502 */ 503 int 504 pfkey_send_add(so, satype, mode, src, dst, spi, reqid, wsize, 505 keymat, e_type, e_keylen, a_type, a_keylen, flags, 506 l_alloc, l_bytes, l_addtime, l_usetime, seq) 507 int so; 508 u_int satype, mode, wsize; 509 struct sockaddr *src, *dst; 510 u_int32_t spi, reqid; 511 caddr_t keymat; 512 u_int e_type, e_keylen, a_type, a_keylen, flags; 513 u_int32_t l_alloc; 514 u_int64_t l_bytes, l_addtime, l_usetime; 515 u_int32_t seq; 516 { 517 int len; 518 if ((len = pfkey_send_x1(so, SADB_ADD, satype, mode, src, dst, spi, 519 reqid, wsize, 520 keymat, e_type, e_keylen, a_type, a_keylen, flags, 521 l_alloc, l_bytes, l_addtime, l_usetime, seq)) < 0) 522 return -1; 523 524 return len; 525 } 526 527 /* 528 * sending SADB_DELETE message to the kernel. 529 * OUT: 530 * positive: success and return length sent. 531 * -1 : error occured, and set errno. 532 */ 533 int 534 pfkey_send_delete(so, satype, mode, src, dst, spi) 535 int so; 536 u_int satype, mode; 537 struct sockaddr *src, *dst; 538 u_int32_t spi; 539 { 540 int len; 541 if ((len = pfkey_send_x2(so, SADB_DELETE, satype, mode, src, dst, spi)) < 0) 542 return -1; 543 544 return len; 545 } 546 547 /* 548 * sending SADB_DELETE without spi to the kernel. This is 549 * the "delete all" request (an extension also present in 550 * Solaris). 551 * 552 * OUT: 553 * positive: success and return length sent 554 * -1 : error occured, and set errno 555 */ 556 int 557 pfkey_send_delete_all(so, satype, mode, src, dst) 558 int so; 559 u_int satype, mode; 560 struct sockaddr *src, *dst; 561 { 562 struct sadb_msg *newmsg; 563 int len; 564 caddr_t p; 565 int plen; 566 caddr_t ep; 567 568 /* validity check */ 569 if (src == NULL || dst == NULL) { 570 __ipsec_errcode = EIPSEC_INVAL_ARGUMENT; 571 return -1; 572 } 573 if (src->sa_family != dst->sa_family) { 574 __ipsec_errcode = EIPSEC_FAMILY_MISMATCH; 575 return -1; 576 } 577 switch (src->sa_family) { 578 case AF_INET: 579 plen = sizeof(struct in_addr) << 3; 580 break; 581 case AF_INET6: 582 plen = sizeof(struct in6_addr) << 3; 583 break; 584 default: 585 __ipsec_errcode = EIPSEC_INVAL_FAMILY; 586 return -1; 587 } 588 589 /* create new sadb_msg to reply. */ 590 len = sizeof(struct sadb_msg) 591 + sizeof(struct sadb_address) 592 + PFKEY_ALIGN8(src->sa_len) 593 + sizeof(struct sadb_address) 594 + PFKEY_ALIGN8(dst->sa_len); 595 596 if ((newmsg = CALLOC(len, struct sadb_msg *)) == NULL) { 597 __ipsec_set_strerror(strerror(errno)); 598 return -1; 599 } 600 ep = ((caddr_t)newmsg) + len; 601 602 p = pfkey_setsadbmsg((caddr_t)newmsg, ep, SADB_DELETE, len, satype, 0, 603 getpid()); 604 if (!p) { 605 free(newmsg); 606 return -1; 607 } 608 p = pfkey_setsadbaddr(p, ep, SADB_EXT_ADDRESS_SRC, src, plen, 609 IPSEC_ULPROTO_ANY); 610 if (!p) { 611 free(newmsg); 612 return -1; 613 } 614 p = pfkey_setsadbaddr(p, ep, SADB_EXT_ADDRESS_DST, dst, plen, 615 IPSEC_ULPROTO_ANY); 616 if (!p || p != ep) { 617 free(newmsg); 618 return -1; 619 } 620 621 /* send message */ 622 len = pfkey_send(so, newmsg, len); 623 free(newmsg); 624 625 if (len < 0) 626 return -1; 627 628 __ipsec_errcode = EIPSEC_NO_ERROR; 629 return len; 630 } 631 632 /* 633 * sending SADB_GET message to the kernel. 634 * OUT: 635 * positive: success and return length sent. 636 * -1 : error occured, and set errno. 637 */ 638 int 639 pfkey_send_get(so, satype, mode, src, dst, spi) 640 int so; 641 u_int satype, mode; 642 struct sockaddr *src, *dst; 643 u_int32_t spi; 644 { 645 int len; 646 if ((len = pfkey_send_x2(so, SADB_GET, satype, mode, src, dst, spi)) < 0) 647 return -1; 648 649 return len; 650 } 651 652 /* 653 * sending SADB_REGISTER message to the kernel. 654 * OUT: 655 * positive: success and return length sent. 656 * -1 : error occured, and set errno. 657 */ 658 int 659 pfkey_send_register(so, satype) 660 int so; 661 u_int satype; 662 { 663 int len, algno; 664 665 if (satype == SADB_SATYPE_UNSPEC) { 666 for (algno = 0; 667 algno < sizeof(supported_map)/sizeof(supported_map[0]); 668 algno++) { 669 if (ipsec_supported[algno]) { 670 free(ipsec_supported[algno]); 671 ipsec_supported[algno] = NULL; 672 } 673 } 674 } else { 675 algno = findsupportedmap(satype); 676 if (algno == -1) { 677 __ipsec_errcode = EIPSEC_INVAL_ARGUMENT; 678 return -1; 679 } 680 681 if (ipsec_supported[algno]) { 682 free(ipsec_supported[algno]); 683 ipsec_supported[algno] = NULL; 684 } 685 } 686 687 if ((len = pfkey_send_x3(so, SADB_REGISTER, satype)) < 0) 688 return -1; 689 690 return len; 691 } 692 693 /* 694 * receiving SADB_REGISTER message from the kernel, and copy buffer for 695 * sadb_supported returned into ipsec_supported. 696 * OUT: 697 * 0: success and return length sent. 698 * -1: error occured, and set errno. 699 */ 700 int 701 pfkey_recv_register(so) 702 int so; 703 { 704 pid_t pid = getpid(); 705 struct sadb_msg *newmsg; 706 int error = -1; 707 708 /* receive message */ 709 for (;;) { 710 if ((newmsg = pfkey_recv(so)) == NULL) 711 return -1; 712 if (newmsg->sadb_msg_type == SADB_REGISTER && 713 newmsg->sadb_msg_pid == pid) 714 break; 715 free(newmsg); 716 } 717 718 /* check and fix */ 719 newmsg->sadb_msg_len = PFKEY_UNUNIT64(newmsg->sadb_msg_len); 720 721 error = pfkey_set_supported(newmsg, newmsg->sadb_msg_len); 722 free(newmsg); 723 724 if (error == 0) 725 __ipsec_errcode = EIPSEC_NO_ERROR; 726 727 return error; 728 } 729 730 /* 731 * receiving SADB_REGISTER message from the kernel, and copy buffer for 732 * sadb_supported returned into ipsec_supported. 733 * NOTE: sadb_msg_len must be host order. 734 * IN: 735 * tlen: msg length, it's to makeing sure. 736 * OUT: 737 * 0: success and return length sent. 738 * -1: error occured, and set errno. 739 */ 740 int 741 pfkey_set_supported(msg, tlen) 742 struct sadb_msg *msg; 743 int tlen; 744 { 745 struct sadb_supported *sup; 746 caddr_t p; 747 caddr_t ep; 748 749 /* validity */ 750 if (msg->sadb_msg_len != tlen) { 751 __ipsec_errcode = EIPSEC_INVAL_ARGUMENT; 752 return -1; 753 } 754 755 p = (caddr_t)msg; 756 ep = p + tlen; 757 758 p += sizeof(struct sadb_msg); 759 760 while (p < ep) { 761 sup = (struct sadb_supported *)p; 762 if (ep < p + sizeof(*sup) || 763 PFKEY_EXTLEN(sup) < sizeof(*sup) || 764 ep < p + sup->sadb_supported_len) { 765 /* invalid format */ 766 break; 767 } 768 769 switch (sup->sadb_supported_exttype) { 770 case SADB_EXT_SUPPORTED_AUTH: 771 case SADB_EXT_SUPPORTED_ENCRYPT: 772 break; 773 default: 774 __ipsec_errcode = EIPSEC_INVAL_SATYPE; 775 return -1; 776 } 777 778 /* fixed length */ 779 sup->sadb_supported_len = PFKEY_EXTLEN(sup); 780 781 /* set supported map */ 782 if (setsupportedmap(sup) != 0) 783 return -1; 784 785 p += sup->sadb_supported_len; 786 } 787 788 if (p != ep) { 789 __ipsec_errcode = EIPSEC_INVAL_SATYPE; 790 return -1; 791 } 792 793 __ipsec_errcode = EIPSEC_NO_ERROR; 794 795 return 0; 796 } 797 798 /* 799 * sending SADB_FLUSH message to the kernel. 800 * OUT: 801 * positive: success and return length sent. 802 * -1 : error occured, and set errno. 803 */ 804 int 805 pfkey_send_flush(so, satype) 806 int so; 807 u_int satype; 808 { 809 int len; 810 811 if ((len = pfkey_send_x3(so, SADB_FLUSH, satype)) < 0) 812 return -1; 813 814 return len; 815 } 816 817 /* 818 * sending SADB_DUMP message to the kernel. 819 * OUT: 820 * positive: success and return length sent. 821 * -1 : error occured, and set errno. 822 */ 823 int 824 pfkey_send_dump(so, satype) 825 int so; 826 u_int satype; 827 { 828 int len; 829 830 if ((len = pfkey_send_x3(so, SADB_DUMP, satype)) < 0) 831 return -1; 832 833 return len; 834 } 835 836 /* 837 * sending SADB_X_PROMISC message to the kernel. 838 * NOTE that this function handles promisc mode toggle only. 839 * IN: 840 * flag: set promisc off if zero, set promisc on if non-zero. 841 * OUT: 842 * positive: success and return length sent. 843 * -1 : error occured, and set errno. 844 * 0 : error occured, and set errno. 845 * others: a pointer to new allocated buffer in which supported 846 * algorithms is. 847 */ 848 int 849 pfkey_send_promisc_toggle(so, flag) 850 int so; 851 int flag; 852 { 853 int len; 854 855 if ((len = pfkey_send_x3(so, SADB_X_PROMISC, (flag ? 1 : 0))) < 0) 856 return -1; 857 858 return len; 859 } 860 861 /* 862 * sending SADB_X_SPDADD message to the kernel. 863 * OUT: 864 * positive: success and return length sent. 865 * -1 : error occured, and set errno. 866 */ 867 int 868 pfkey_send_spdadd(so, src, prefs, dst, prefd, proto, policy, policylen, seq) 869 int so; 870 struct sockaddr *src, *dst; 871 u_int prefs, prefd, proto; 872 caddr_t policy; 873 int policylen; 874 u_int32_t seq; 875 { 876 int len; 877 878 if ((len = pfkey_send_x4(so, SADB_X_SPDADD, 879 src, prefs, dst, prefd, proto, 880 0, 0, 881 policy, policylen, seq)) < 0) 882 return -1; 883 884 return len; 885 } 886 887 /* 888 * sending SADB_X_SPDADD message to the kernel. 889 * OUT: 890 * positive: success and return length sent. 891 * -1 : error occured, and set errno. 892 */ 893 int 894 pfkey_send_spdadd2(so, src, prefs, dst, prefd, proto, ltime, vtime, 895 policy, policylen, seq) 896 int so; 897 struct sockaddr *src, *dst; 898 u_int prefs, prefd, proto; 899 u_int64_t ltime, vtime; 900 caddr_t policy; 901 int policylen; 902 u_int32_t seq; 903 { 904 int len; 905 906 if ((len = pfkey_send_x4(so, SADB_X_SPDADD, 907 src, prefs, dst, prefd, proto, 908 ltime, vtime, 909 policy, policylen, seq)) < 0) 910 return -1; 911 912 return len; 913 } 914 915 /* 916 * sending SADB_X_SPDUPDATE message to the kernel. 917 * OUT: 918 * positive: success and return length sent. 919 * -1 : error occured, and set errno. 920 */ 921 int 922 pfkey_send_spdupdate(so, src, prefs, dst, prefd, proto, policy, policylen, seq) 923 int so; 924 struct sockaddr *src, *dst; 925 u_int prefs, prefd, proto; 926 caddr_t policy; 927 int policylen; 928 u_int32_t seq; 929 { 930 int len; 931 932 if ((len = pfkey_send_x4(so, SADB_X_SPDUPDATE, 933 src, prefs, dst, prefd, proto, 934 0, 0, 935 policy, policylen, seq)) < 0) 936 return -1; 937 938 return len; 939 } 940 941 /* 942 * sending SADB_X_SPDUPDATE message to the kernel. 943 * OUT: 944 * positive: success and return length sent. 945 * -1 : error occured, and set errno. 946 */ 947 int 948 pfkey_send_spdupdate2(so, src, prefs, dst, prefd, proto, ltime, vtime, 949 policy, policylen, seq) 950 int so; 951 struct sockaddr *src, *dst; 952 u_int prefs, prefd, proto; 953 u_int64_t ltime, vtime; 954 caddr_t policy; 955 int policylen; 956 u_int32_t seq; 957 { 958 int len; 959 960 if ((len = pfkey_send_x4(so, SADB_X_SPDUPDATE, 961 src, prefs, dst, prefd, proto, 962 ltime, vtime, 963 policy, policylen, seq)) < 0) 964 return -1; 965 966 return len; 967 } 968 969 /* 970 * sending SADB_X_SPDDELETE message to the kernel. 971 * OUT: 972 * positive: success and return length sent. 973 * -1 : error occured, and set errno. 974 */ 975 int 976 pfkey_send_spddelete(so, src, prefs, dst, prefd, proto, policy, policylen, seq) 977 int so; 978 struct sockaddr *src, *dst; 979 u_int prefs, prefd, proto; 980 caddr_t policy; 981 int policylen; 982 u_int32_t seq; 983 { 984 int len; 985 986 if (policylen != sizeof(struct sadb_x_policy)) { 987 __ipsec_errcode = EIPSEC_INVAL_ARGUMENT; 988 return -1; 989 } 990 991 if ((len = pfkey_send_x4(so, SADB_X_SPDDELETE, 992 src, prefs, dst, prefd, proto, 993 0, 0, 994 policy, policylen, seq)) < 0) 995 return -1; 996 997 return len; 998 } 999 1000 /* 1001 * sending SADB_X_SPDDELETE message to the kernel. 1002 * OUT: 1003 * positive: success and return length sent. 1004 * -1 : error occured, and set errno. 1005 */ 1006 int 1007 pfkey_send_spddelete2(so, spid) 1008 int so; 1009 u_int32_t spid; 1010 { 1011 int len; 1012 1013 if ((len = pfkey_send_x5(so, SADB_X_SPDDELETE2, spid)) < 0) 1014 return -1; 1015 1016 return len; 1017 } 1018 1019 /* 1020 * sending SADB_X_SPDGET message to the kernel. 1021 * OUT: 1022 * positive: success and return length sent. 1023 * -1 : error occured, and set errno. 1024 */ 1025 int 1026 pfkey_send_spdget(so, spid) 1027 int so; 1028 u_int32_t spid; 1029 { 1030 int len; 1031 1032 if ((len = pfkey_send_x5(so, SADB_X_SPDGET, spid)) < 0) 1033 return -1; 1034 1035 return len; 1036 } 1037 1038 /* 1039 * sending SADB_X_SPDSETIDX message to the kernel. 1040 * OUT: 1041 * positive: success and return length sent. 1042 * -1 : error occured, and set errno. 1043 */ 1044 int 1045 pfkey_send_spdsetidx(so, src, prefs, dst, prefd, proto, policy, policylen, seq) 1046 int so; 1047 struct sockaddr *src, *dst; 1048 u_int prefs, prefd, proto; 1049 caddr_t policy; 1050 int policylen; 1051 u_int32_t seq; 1052 { 1053 int len; 1054 1055 if (policylen != sizeof(struct sadb_x_policy)) { 1056 __ipsec_errcode = EIPSEC_INVAL_ARGUMENT; 1057 return -1; 1058 } 1059 1060 if ((len = pfkey_send_x4(so, SADB_X_SPDSETIDX, 1061 src, prefs, dst, prefd, proto, 1062 0, 0, 1063 policy, policylen, seq)) < 0) 1064 return -1; 1065 1066 return len; 1067 } 1068 1069 /* 1070 * sending SADB_SPDFLUSH message to the kernel. 1071 * OUT: 1072 * positive: success and return length sent. 1073 * -1 : error occured, and set errno. 1074 */ 1075 int 1076 pfkey_send_spdflush(so) 1077 int so; 1078 { 1079 int len; 1080 1081 if ((len = pfkey_send_x3(so, SADB_X_SPDFLUSH, SADB_SATYPE_UNSPEC)) < 0) 1082 return -1; 1083 1084 return len; 1085 } 1086 1087 /* 1088 * sending SADB_SPDDUMP message to the kernel. 1089 * OUT: 1090 * positive: success and return length sent. 1091 * -1 : error occured, and set errno. 1092 */ 1093 int 1094 pfkey_send_spddump(so) 1095 int so; 1096 { 1097 int len; 1098 1099 if ((len = pfkey_send_x3(so, SADB_X_SPDDUMP, SADB_SATYPE_UNSPEC)) < 0) 1100 return -1; 1101 1102 return len; 1103 } 1104 1105 /* sending SADB_ADD or SADB_UPDATE message to the kernel */ 1106 static int 1107 pfkey_send_x1(so, type, satype, mode, src, dst, spi, reqid, wsize, 1108 keymat, e_type, e_keylen, a_type, a_keylen, flags, 1109 l_alloc, l_bytes, l_addtime, l_usetime, seq) 1110 int so; 1111 u_int type, satype, mode; 1112 struct sockaddr *src, *dst; 1113 u_int32_t spi, reqid; 1114 u_int wsize; 1115 caddr_t keymat; 1116 u_int e_type, e_keylen, a_type, a_keylen, flags; 1117 u_int32_t l_alloc, l_bytes, l_addtime, l_usetime, seq; 1118 { 1119 struct sadb_msg *newmsg; 1120 int len; 1121 caddr_t p; 1122 int plen; 1123 caddr_t ep; 1124 1125 /* validity check */ 1126 if (src == NULL || dst == NULL) { 1127 __ipsec_errcode = EIPSEC_INVAL_ARGUMENT; 1128 return -1; 1129 } 1130 if (src->sa_family != dst->sa_family) { 1131 __ipsec_errcode = EIPSEC_FAMILY_MISMATCH; 1132 return -1; 1133 } 1134 switch (src->sa_family) { 1135 case AF_INET: 1136 plen = sizeof(struct in_addr) << 3; 1137 break; 1138 case AF_INET6: 1139 plen = sizeof(struct in6_addr) << 3; 1140 break; 1141 default: 1142 __ipsec_errcode = EIPSEC_INVAL_FAMILY; 1143 return -1; 1144 } 1145 1146 switch (satype) { 1147 case SADB_SATYPE_ESP: 1148 if (e_type == SADB_EALG_NONE) { 1149 __ipsec_errcode = EIPSEC_NO_ALGS; 1150 return -1; 1151 } 1152 break; 1153 case SADB_SATYPE_AH: 1154 if (e_type != SADB_EALG_NONE) { 1155 __ipsec_errcode = EIPSEC_INVAL_ALGS; 1156 return -1; 1157 } 1158 if (a_type == SADB_AALG_NONE) { 1159 __ipsec_errcode = EIPSEC_NO_ALGS; 1160 return -1; 1161 } 1162 break; 1163 case SADB_X_SATYPE_IPCOMP: 1164 if (e_type == SADB_X_CALG_NONE) { 1165 __ipsec_errcode = EIPSEC_INVAL_ALGS; 1166 return -1; 1167 } 1168 if (a_type != SADB_AALG_NONE) { 1169 __ipsec_errcode = EIPSEC_NO_ALGS; 1170 return -1; 1171 } 1172 break; 1173 case SADB_X_SATYPE_TCPSIGNATURE: 1174 if (e_type != SADB_EALG_NONE) { 1175 __ipsec_errcode = EIPSEC_INVAL_ALGS; 1176 return -1; 1177 } 1178 if (a_type != SADB_X_AALG_TCP_MD5) { 1179 __ipsec_errcode = EIPSEC_INVAL_ALGS; 1180 return -1; 1181 } 1182 break; 1183 default: 1184 __ipsec_errcode = EIPSEC_INVAL_SATYPE; 1185 return -1; 1186 } 1187 1188 /* create new sadb_msg to reply. */ 1189 len = sizeof(struct sadb_msg) 1190 + sizeof(struct sadb_sa) 1191 + sizeof(struct sadb_x_sa2) 1192 + sizeof(struct sadb_address) 1193 + PFKEY_ALIGN8(src->sa_len) 1194 + sizeof(struct sadb_address) 1195 + PFKEY_ALIGN8(dst->sa_len) 1196 + sizeof(struct sadb_lifetime) 1197 + sizeof(struct sadb_lifetime); 1198 1199 if (e_type != SADB_EALG_NONE) 1200 len += (sizeof(struct sadb_key) + PFKEY_ALIGN8(e_keylen)); 1201 if (a_type != SADB_AALG_NONE) 1202 len += (sizeof(struct sadb_key) + PFKEY_ALIGN8(a_keylen)); 1203 1204 if ((newmsg = CALLOC(len, struct sadb_msg *)) == NULL) { 1205 __ipsec_set_strerror(strerror(errno)); 1206 return -1; 1207 } 1208 ep = ((caddr_t)newmsg) + len; 1209 1210 p = pfkey_setsadbmsg((caddr_t)newmsg, ep, type, len, 1211 satype, seq, getpid()); 1212 if (!p) { 1213 free(newmsg); 1214 return -1; 1215 } 1216 p = pfkey_setsadbsa(p, ep, spi, wsize, a_type, e_type, flags); 1217 if (!p) { 1218 free(newmsg); 1219 return -1; 1220 } 1221 p = pfkey_setsadbxsa2(p, ep, mode, reqid); 1222 if (!p) { 1223 free(newmsg); 1224 return -1; 1225 } 1226 p = pfkey_setsadbaddr(p, ep, SADB_EXT_ADDRESS_SRC, src, plen, 1227 IPSEC_ULPROTO_ANY); 1228 if (!p) { 1229 free(newmsg); 1230 return -1; 1231 } 1232 p = pfkey_setsadbaddr(p, ep, SADB_EXT_ADDRESS_DST, dst, plen, 1233 IPSEC_ULPROTO_ANY); 1234 if (!p) { 1235 free(newmsg); 1236 return -1; 1237 } 1238 1239 if (e_type != SADB_EALG_NONE) { 1240 p = pfkey_setsadbkey(p, ep, SADB_EXT_KEY_ENCRYPT, 1241 keymat, e_keylen); 1242 if (!p) { 1243 free(newmsg); 1244 return -1; 1245 } 1246 } 1247 if (a_type != SADB_AALG_NONE) { 1248 p = pfkey_setsadbkey(p, ep, SADB_EXT_KEY_AUTH, 1249 keymat + e_keylen, a_keylen); 1250 if (!p) { 1251 free(newmsg); 1252 return -1; 1253 } 1254 } 1255 1256 /* set sadb_lifetime for destination */ 1257 p = pfkey_setsadblifetime(p, ep, SADB_EXT_LIFETIME_HARD, 1258 l_alloc, l_bytes, l_addtime, l_usetime); 1259 if (!p) { 1260 free(newmsg); 1261 return -1; 1262 } 1263 p = pfkey_setsadblifetime(p, ep, SADB_EXT_LIFETIME_SOFT, 1264 l_alloc, l_bytes, l_addtime, l_usetime); 1265 if (!p || p != ep) { 1266 free(newmsg); 1267 return -1; 1268 } 1269 1270 /* send message */ 1271 len = pfkey_send(so, newmsg, len); 1272 free(newmsg); 1273 1274 if (len < 0) 1275 return -1; 1276 1277 __ipsec_errcode = EIPSEC_NO_ERROR; 1278 return len; 1279 } 1280 1281 /* sending SADB_DELETE or SADB_GET message to the kernel */ 1282 static int 1283 pfkey_send_x2(so, type, satype, mode, src, dst, spi) 1284 int so; 1285 u_int type, satype, mode; 1286 struct sockaddr *src, *dst; 1287 u_int32_t spi; 1288 { 1289 struct sadb_msg *newmsg; 1290 int len; 1291 caddr_t p; 1292 int plen; 1293 caddr_t ep; 1294 1295 /* validity check */ 1296 if (src == NULL || dst == NULL) { 1297 __ipsec_errcode = EIPSEC_INVAL_ARGUMENT; 1298 return -1; 1299 } 1300 if (src->sa_family != dst->sa_family) { 1301 __ipsec_errcode = EIPSEC_FAMILY_MISMATCH; 1302 return -1; 1303 } 1304 switch (src->sa_family) { 1305 case AF_INET: 1306 plen = sizeof(struct in_addr) << 3; 1307 break; 1308 case AF_INET6: 1309 plen = sizeof(struct in6_addr) << 3; 1310 break; 1311 default: 1312 __ipsec_errcode = EIPSEC_INVAL_FAMILY; 1313 return -1; 1314 } 1315 1316 /* create new sadb_msg to reply. */ 1317 len = sizeof(struct sadb_msg) 1318 + sizeof(struct sadb_sa) 1319 + sizeof(struct sadb_address) 1320 + PFKEY_ALIGN8(src->sa_len) 1321 + sizeof(struct sadb_address) 1322 + PFKEY_ALIGN8(dst->sa_len); 1323 1324 if ((newmsg = CALLOC(len, struct sadb_msg *)) == NULL) { 1325 __ipsec_set_strerror(strerror(errno)); 1326 return -1; 1327 } 1328 ep = ((caddr_t)newmsg) + len; 1329 1330 p = pfkey_setsadbmsg((caddr_t)newmsg, ep, type, len, satype, 0, 1331 getpid()); 1332 if (!p) { 1333 free(newmsg); 1334 return -1; 1335 } 1336 p = pfkey_setsadbsa(p, ep, spi, 0, 0, 0, 0); 1337 if (!p) { 1338 free(newmsg); 1339 return -1; 1340 } 1341 p = pfkey_setsadbaddr(p, ep, SADB_EXT_ADDRESS_SRC, src, plen, 1342 IPSEC_ULPROTO_ANY); 1343 if (!p) { 1344 free(newmsg); 1345 return -1; 1346 } 1347 p = pfkey_setsadbaddr(p, ep, SADB_EXT_ADDRESS_DST, dst, plen, 1348 IPSEC_ULPROTO_ANY); 1349 if (!p || p != ep) { 1350 free(newmsg); 1351 return -1; 1352 } 1353 1354 /* send message */ 1355 len = pfkey_send(so, newmsg, len); 1356 free(newmsg); 1357 1358 if (len < 0) 1359 return -1; 1360 1361 __ipsec_errcode = EIPSEC_NO_ERROR; 1362 return len; 1363 } 1364 1365 /* 1366 * sending SADB_REGISTER, SADB_FLUSH, SADB_DUMP or SADB_X_PROMISC message 1367 * to the kernel 1368 */ 1369 static int 1370 pfkey_send_x3(so, type, satype) 1371 int so; 1372 u_int type, satype; 1373 { 1374 struct sadb_msg *newmsg; 1375 int len; 1376 caddr_t p; 1377 caddr_t ep; 1378 1379 /* validity check */ 1380 switch (type) { 1381 case SADB_X_PROMISC: 1382 if (satype != 0 && satype != 1) { 1383 __ipsec_errcode = EIPSEC_INVAL_SATYPE; 1384 return -1; 1385 } 1386 break; 1387 default: 1388 switch (satype) { 1389 case SADB_SATYPE_UNSPEC: 1390 case SADB_SATYPE_AH: 1391 case SADB_SATYPE_ESP: 1392 case SADB_X_SATYPE_IPCOMP: 1393 case SADB_X_SATYPE_TCPSIGNATURE: 1394 break; 1395 default: 1396 __ipsec_errcode = EIPSEC_INVAL_SATYPE; 1397 return -1; 1398 } 1399 } 1400 1401 /* create new sadb_msg to send. */ 1402 len = sizeof(struct sadb_msg); 1403 1404 if ((newmsg = CALLOC(len, struct sadb_msg *)) == NULL) { 1405 __ipsec_set_strerror(strerror(errno)); 1406 return -1; 1407 } 1408 ep = ((caddr_t)newmsg) + len; 1409 1410 p = pfkey_setsadbmsg((caddr_t)newmsg, ep, type, len, satype, 0, 1411 getpid()); 1412 if (!p || p != ep) { 1413 free(newmsg); 1414 return -1; 1415 } 1416 1417 /* send message */ 1418 len = pfkey_send(so, newmsg, len); 1419 free(newmsg); 1420 1421 if (len < 0) 1422 return -1; 1423 1424 __ipsec_errcode = EIPSEC_NO_ERROR; 1425 return len; 1426 } 1427 1428 /* sending SADB_X_SPDADD message to the kernel */ 1429 static int 1430 pfkey_send_x4(so, type, src, prefs, dst, prefd, proto, 1431 ltime, vtime, policy, policylen, seq) 1432 int so; 1433 struct sockaddr *src, *dst; 1434 u_int type, prefs, prefd, proto; 1435 u_int64_t ltime, vtime; 1436 char *policy; 1437 int policylen; 1438 u_int32_t seq; 1439 { 1440 struct sadb_msg *newmsg; 1441 int len; 1442 caddr_t p; 1443 int plen; 1444 caddr_t ep; 1445 1446 /* validity check */ 1447 if (src == NULL || dst == NULL) { 1448 __ipsec_errcode = EIPSEC_INVAL_ARGUMENT; 1449 return -1; 1450 } 1451 if (src->sa_family != dst->sa_family) { 1452 __ipsec_errcode = EIPSEC_FAMILY_MISMATCH; 1453 return -1; 1454 } 1455 1456 switch (src->sa_family) { 1457 case AF_INET: 1458 plen = sizeof(struct in_addr) << 3; 1459 break; 1460 case AF_INET6: 1461 plen = sizeof(struct in6_addr) << 3; 1462 break; 1463 default: 1464 __ipsec_errcode = EIPSEC_INVAL_FAMILY; 1465 return -1; 1466 } 1467 if (prefs > plen || prefd > plen) { 1468 __ipsec_errcode = EIPSEC_INVAL_PREFIXLEN; 1469 return -1; 1470 } 1471 1472 /* create new sadb_msg to reply. */ 1473 len = sizeof(struct sadb_msg) 1474 + sizeof(struct sadb_address) 1475 + PFKEY_ALIGN8(src->sa_len) 1476 + sizeof(struct sadb_address) 1477 + PFKEY_ALIGN8(src->sa_len) 1478 + sizeof(struct sadb_lifetime) 1479 + policylen; 1480 1481 if ((newmsg = CALLOC(len, struct sadb_msg *)) == NULL) { 1482 __ipsec_set_strerror(strerror(errno)); 1483 return -1; 1484 } 1485 ep = ((caddr_t)newmsg) + len; 1486 1487 p = pfkey_setsadbmsg((caddr_t)newmsg, ep, type, len, 1488 SADB_SATYPE_UNSPEC, seq, getpid()); 1489 if (!p) { 1490 free(newmsg); 1491 return -1; 1492 } 1493 p = pfkey_setsadbaddr(p, ep, SADB_EXT_ADDRESS_SRC, src, prefs, proto); 1494 if (!p) { 1495 free(newmsg); 1496 return -1; 1497 } 1498 p = pfkey_setsadbaddr(p, ep, SADB_EXT_ADDRESS_DST, dst, prefd, proto); 1499 if (!p) { 1500 free(newmsg); 1501 return -1; 1502 } 1503 p = pfkey_setsadblifetime(p, ep, SADB_EXT_LIFETIME_HARD, 1504 0, 0, ltime, vtime); 1505 if (!p || p + policylen != ep) { 1506 free(newmsg); 1507 return -1; 1508 } 1509 memcpy(p, policy, policylen); 1510 1511 /* send message */ 1512 len = pfkey_send(so, newmsg, len); 1513 free(newmsg); 1514 1515 if (len < 0) 1516 return -1; 1517 1518 __ipsec_errcode = EIPSEC_NO_ERROR; 1519 return len; 1520 } 1521 1522 /* sending SADB_X_SPDGET or SADB_X_SPDDELETE message to the kernel */ 1523 static int 1524 pfkey_send_x5(so, type, spid) 1525 int so; 1526 u_int type; 1527 u_int32_t spid; 1528 { 1529 struct sadb_msg *newmsg; 1530 struct sadb_x_policy xpl; 1531 int len; 1532 caddr_t p; 1533 caddr_t ep; 1534 1535 /* create new sadb_msg to reply. */ 1536 len = sizeof(struct sadb_msg) 1537 + sizeof(xpl); 1538 1539 if ((newmsg = CALLOC(len, struct sadb_msg *)) == NULL) { 1540 __ipsec_set_strerror(strerror(errno)); 1541 return -1; 1542 } 1543 ep = ((caddr_t)newmsg) + len; 1544 1545 p = pfkey_setsadbmsg((caddr_t)newmsg, ep, type, len, 1546 SADB_SATYPE_UNSPEC, 0, getpid()); 1547 if (!p) { 1548 free(newmsg); 1549 return -1; 1550 } 1551 1552 if (p + sizeof(xpl) != ep) { 1553 free(newmsg); 1554 return -1; 1555 } 1556 memset(&xpl, 0, sizeof(xpl)); 1557 xpl.sadb_x_policy_len = PFKEY_UNIT64(sizeof(xpl)); 1558 xpl.sadb_x_policy_exttype = SADB_X_EXT_POLICY; 1559 xpl.sadb_x_policy_id = spid; 1560 memcpy(p, &xpl, sizeof(xpl)); 1561 1562 /* send message */ 1563 len = pfkey_send(so, newmsg, len); 1564 free(newmsg); 1565 1566 if (len < 0) 1567 return -1; 1568 1569 __ipsec_errcode = EIPSEC_NO_ERROR; 1570 return len; 1571 } 1572 1573 /* 1574 * open a socket. 1575 * OUT: 1576 * -1: fail. 1577 * others : success and return value of socket. 1578 */ 1579 int 1580 pfkey_open() 1581 { 1582 int so; 1583 const int bufsiz = 128 * 1024; /*is 128K enough?*/ 1584 1585 if ((so = socket(PF_KEY, SOCK_RAW, PF_KEY_V2)) < 0) { 1586 __ipsec_set_strerror(strerror(errno)); 1587 return -1; 1588 } 1589 1590 /* 1591 * This is a temporary workaround for KAME PR 154. 1592 * Don't really care even if it fails. 1593 */ 1594 (void)setsockopt(so, SOL_SOCKET, SO_SNDBUF, &bufsiz, sizeof(bufsiz)); 1595 (void)setsockopt(so, SOL_SOCKET, SO_RCVBUF, &bufsiz, sizeof(bufsiz)); 1596 1597 __ipsec_errcode = EIPSEC_NO_ERROR; 1598 return so; 1599 } 1600 1601 /* 1602 * close a socket. 1603 * OUT: 1604 * 0: success. 1605 * -1: fail. 1606 */ 1607 void 1608 pfkey_close(so) 1609 int so; 1610 { 1611 (void)close(so); 1612 1613 __ipsec_errcode = EIPSEC_NO_ERROR; 1614 return; 1615 } 1616 1617 /* 1618 * receive sadb_msg data, and return pointer to new buffer allocated. 1619 * Must free this buffer later. 1620 * OUT: 1621 * NULL : error occured. 1622 * others : a pointer to sadb_msg structure. 1623 * 1624 * XXX should be rewritten to pass length explicitly 1625 */ 1626 struct sadb_msg * 1627 pfkey_recv(so) 1628 int so; 1629 { 1630 struct sadb_msg buf, *newmsg; 1631 int len, reallen; 1632 1633 while ((len = recv(so, (caddr_t)&buf, sizeof(buf), MSG_PEEK)) < 0) { 1634 if (errno == EINTR) 1635 continue; 1636 __ipsec_set_strerror(strerror(errno)); 1637 return NULL; 1638 } 1639 1640 if (len < sizeof(buf)) { 1641 recv(so, (caddr_t)&buf, sizeof(buf), 0); 1642 __ipsec_errcode = EIPSEC_MAX; 1643 return NULL; 1644 } 1645 1646 /* read real message */ 1647 reallen = PFKEY_UNUNIT64(buf.sadb_msg_len); 1648 if ((newmsg = CALLOC(reallen, struct sadb_msg *)) == 0) { 1649 __ipsec_set_strerror(strerror(errno)); 1650 return NULL; 1651 } 1652 1653 while ((len = recv(so, (caddr_t)newmsg, reallen, 0)) < 0) { 1654 if (errno == EINTR) 1655 continue; 1656 __ipsec_set_strerror(strerror(errno)); 1657 free(newmsg); 1658 return NULL; 1659 } 1660 1661 if (len != reallen) { 1662 __ipsec_errcode = EIPSEC_SYSTEM_ERROR; 1663 free(newmsg); 1664 return NULL; 1665 } 1666 1667 /* don't trust what the kernel says, validate! */ 1668 if (PFKEY_UNUNIT64(newmsg->sadb_msg_len) != len) { 1669 __ipsec_errcode = EIPSEC_SYSTEM_ERROR; 1670 free(newmsg); 1671 return NULL; 1672 } 1673 1674 __ipsec_errcode = EIPSEC_NO_ERROR; 1675 return newmsg; 1676 } 1677 1678 /* 1679 * send message to a socket. 1680 * OUT: 1681 * others: success and return length sent. 1682 * -1 : fail. 1683 */ 1684 int 1685 pfkey_send(so, msg, len) 1686 int so; 1687 struct sadb_msg *msg; 1688 int len; 1689 { 1690 if ((len = send(so, (caddr_t)msg, len, 0)) < 0) { 1691 __ipsec_set_strerror(strerror(errno)); 1692 return -1; 1693 } 1694 1695 __ipsec_errcode = EIPSEC_NO_ERROR; 1696 return len; 1697 } 1698 1699 /* 1700 * %%% Utilities 1701 * NOTE: These functions are derived from netkey/key.c in KAME. 1702 */ 1703 /* 1704 * set the pointer to each header in this message buffer. 1705 * IN: msg: pointer to message buffer. 1706 * mhp: pointer to the buffer initialized like below: 1707 * caddr_t mhp[SADB_EXT_MAX + 1]; 1708 * OUT: -1: invalid. 1709 * 0: valid. 1710 * 1711 * XXX should be rewritten to obtain length explicitly 1712 */ 1713 int 1714 pfkey_align(msg, mhp) 1715 struct sadb_msg *msg; 1716 caddr_t *mhp; 1717 { 1718 struct sadb_ext *ext; 1719 int i; 1720 caddr_t p; 1721 caddr_t ep; /* XXX should be passed from upper layer */ 1722 1723 /* validity check */ 1724 if (msg == NULL || mhp == NULL) { 1725 __ipsec_errcode = EIPSEC_INVAL_ARGUMENT; 1726 return -1; 1727 } 1728 1729 /* initialize */ 1730 for (i = 0; i < SADB_EXT_MAX + 1; i++) 1731 mhp[i] = NULL; 1732 1733 mhp[0] = (caddr_t)msg; 1734 1735 /* initialize */ 1736 p = (caddr_t) msg; 1737 ep = p + PFKEY_UNUNIT64(msg->sadb_msg_len); 1738 1739 /* skip base header */ 1740 p += sizeof(struct sadb_msg); 1741 1742 while (p < ep) { 1743 ext = (struct sadb_ext *)p; 1744 if (ep < p + sizeof(*ext) || PFKEY_EXTLEN(ext) < sizeof(*ext) || 1745 ep < p + PFKEY_EXTLEN(ext)) { 1746 /* invalid format */ 1747 break; 1748 } 1749 1750 /* duplicate check */ 1751 /* XXX Are there duplication either KEY_AUTH or KEY_ENCRYPT ?*/ 1752 if (mhp[ext->sadb_ext_type] != NULL) { 1753 __ipsec_errcode = EIPSEC_INVAL_EXTTYPE; 1754 return -1; 1755 } 1756 1757 /* set pointer */ 1758 switch (ext->sadb_ext_type) { 1759 case SADB_EXT_SA: 1760 case SADB_EXT_LIFETIME_CURRENT: 1761 case SADB_EXT_LIFETIME_HARD: 1762 case SADB_EXT_LIFETIME_SOFT: 1763 case SADB_EXT_ADDRESS_SRC: 1764 case SADB_EXT_ADDRESS_DST: 1765 case SADB_EXT_ADDRESS_PROXY: 1766 case SADB_EXT_KEY_AUTH: 1767 /* XXX should to be check weak keys. */ 1768 case SADB_EXT_KEY_ENCRYPT: 1769 /* XXX should to be check weak keys. */ 1770 case SADB_EXT_IDENTITY_SRC: 1771 case SADB_EXT_IDENTITY_DST: 1772 case SADB_EXT_SENSITIVITY: 1773 case SADB_EXT_PROPOSAL: 1774 case SADB_EXT_SUPPORTED_AUTH: 1775 case SADB_EXT_SUPPORTED_ENCRYPT: 1776 case SADB_EXT_SPIRANGE: 1777 case SADB_X_EXT_POLICY: 1778 case SADB_X_EXT_SA2: 1779 mhp[ext->sadb_ext_type] = (caddr_t)ext; 1780 break; 1781 case SADB_X_EXT_NAT_T_TYPE: 1782 case SADB_X_EXT_NAT_T_SPORT: 1783 case SADB_X_EXT_NAT_T_DPORT: 1784 /* case SADB_X_EXT_NAT_T_OA: is OAI */ 1785 case SADB_X_EXT_NAT_T_OAI: 1786 case SADB_X_EXT_NAT_T_OAR: 1787 case SADB_X_EXT_NAT_T_FRAG: 1788 if (feature_present("ipsec_natt")) { 1789 mhp[ext->sadb_ext_type] = (caddr_t)ext; 1790 break; 1791 } 1792 /* FALLTHROUGH */ 1793 default: 1794 __ipsec_errcode = EIPSEC_INVAL_EXTTYPE; 1795 return -1; 1796 } 1797 1798 p += PFKEY_EXTLEN(ext); 1799 } 1800 1801 if (p != ep) { 1802 __ipsec_errcode = EIPSEC_INVAL_SADBMSG; 1803 return -1; 1804 } 1805 1806 __ipsec_errcode = EIPSEC_NO_ERROR; 1807 return 0; 1808 } 1809 1810 /* 1811 * check basic usage for sadb_msg, 1812 * NOTE: This routine is derived from netkey/key.c in KAME. 1813 * IN: msg: pointer to message buffer. 1814 * mhp: pointer to the buffer initialized like below: 1815 * 1816 * caddr_t mhp[SADB_EXT_MAX + 1]; 1817 * 1818 * OUT: -1: invalid. 1819 * 0: valid. 1820 */ 1821 int 1822 pfkey_check(mhp) 1823 caddr_t *mhp; 1824 { 1825 struct sadb_msg *msg; 1826 1827 /* validity check */ 1828 if (mhp == NULL || mhp[0] == NULL) { 1829 __ipsec_errcode = EIPSEC_INVAL_ARGUMENT; 1830 return -1; 1831 } 1832 1833 msg = (struct sadb_msg *)mhp[0]; 1834 1835 /* check version */ 1836 if (msg->sadb_msg_version != PF_KEY_V2) { 1837 __ipsec_errcode = EIPSEC_INVAL_VERSION; 1838 return -1; 1839 } 1840 1841 /* check type */ 1842 if (msg->sadb_msg_type > SADB_MAX) { 1843 __ipsec_errcode = EIPSEC_INVAL_MSGTYPE; 1844 return -1; 1845 } 1846 1847 /* check SA type */ 1848 switch (msg->sadb_msg_satype) { 1849 case SADB_SATYPE_UNSPEC: 1850 switch (msg->sadb_msg_type) { 1851 case SADB_GETSPI: 1852 case SADB_UPDATE: 1853 case SADB_ADD: 1854 case SADB_DELETE: 1855 case SADB_GET: 1856 case SADB_ACQUIRE: 1857 case SADB_EXPIRE: 1858 __ipsec_errcode = EIPSEC_INVAL_SATYPE; 1859 return -1; 1860 } 1861 break; 1862 case SADB_SATYPE_ESP: 1863 case SADB_SATYPE_AH: 1864 case SADB_X_SATYPE_IPCOMP: 1865 case SADB_X_SATYPE_TCPSIGNATURE: 1866 switch (msg->sadb_msg_type) { 1867 case SADB_X_SPDADD: 1868 case SADB_X_SPDDELETE: 1869 case SADB_X_SPDGET: 1870 case SADB_X_SPDDUMP: 1871 case SADB_X_SPDFLUSH: 1872 __ipsec_errcode = EIPSEC_INVAL_SATYPE; 1873 return -1; 1874 } 1875 break; 1876 case SADB_SATYPE_RSVP: 1877 case SADB_SATYPE_OSPFV2: 1878 case SADB_SATYPE_RIPV2: 1879 case SADB_SATYPE_MIP: 1880 __ipsec_errcode = EIPSEC_NOT_SUPPORTED; 1881 return -1; 1882 case 1: /* XXX: What does it do ? */ 1883 if (msg->sadb_msg_type == SADB_X_PROMISC) 1884 break; 1885 /*FALLTHROUGH*/ 1886 default: 1887 __ipsec_errcode = EIPSEC_INVAL_SATYPE; 1888 return -1; 1889 } 1890 1891 /* check field of upper layer protocol and address family */ 1892 if (mhp[SADB_EXT_ADDRESS_SRC] != NULL 1893 && mhp[SADB_EXT_ADDRESS_DST] != NULL) { 1894 struct sadb_address *src0, *dst0; 1895 1896 src0 = (struct sadb_address *)(mhp[SADB_EXT_ADDRESS_SRC]); 1897 dst0 = (struct sadb_address *)(mhp[SADB_EXT_ADDRESS_DST]); 1898 1899 if (src0->sadb_address_proto != dst0->sadb_address_proto) { 1900 __ipsec_errcode = EIPSEC_PROTO_MISMATCH; 1901 return -1; 1902 } 1903 1904 if (PFKEY_ADDR_SADDR(src0)->sa_family 1905 != PFKEY_ADDR_SADDR(dst0)->sa_family) { 1906 __ipsec_errcode = EIPSEC_FAMILY_MISMATCH; 1907 return -1; 1908 } 1909 1910 switch (PFKEY_ADDR_SADDR(src0)->sa_family) { 1911 case AF_INET: 1912 case AF_INET6: 1913 break; 1914 default: 1915 __ipsec_errcode = EIPSEC_INVAL_FAMILY; 1916 return -1; 1917 } 1918 1919 /* 1920 * prefixlen == 0 is valid because there must be the case 1921 * all addresses are matched. 1922 */ 1923 } 1924 1925 __ipsec_errcode = EIPSEC_NO_ERROR; 1926 return 0; 1927 } 1928 1929 /* 1930 * set data into sadb_msg. 1931 * `buf' must has been allocated sufficiently. 1932 */ 1933 static caddr_t 1934 pfkey_setsadbmsg(buf, lim, type, tlen, satype, seq, pid) 1935 caddr_t buf; 1936 caddr_t lim; 1937 u_int type, satype; 1938 u_int tlen; 1939 u_int32_t seq; 1940 pid_t pid; 1941 { 1942 struct sadb_msg *p; 1943 u_int len; 1944 1945 p = (struct sadb_msg *)buf; 1946 len = sizeof(struct sadb_msg); 1947 1948 if (buf + len > lim) 1949 return NULL; 1950 1951 memset(p, 0, len); 1952 p->sadb_msg_version = PF_KEY_V2; 1953 p->sadb_msg_type = type; 1954 p->sadb_msg_errno = 0; 1955 p->sadb_msg_satype = satype; 1956 p->sadb_msg_len = PFKEY_UNIT64(tlen); 1957 p->sadb_msg_reserved = 0; 1958 p->sadb_msg_seq = seq; 1959 p->sadb_msg_pid = (u_int32_t)pid; 1960 1961 return(buf + len); 1962 } 1963 1964 /* 1965 * copy secasvar data into sadb_address. 1966 * `buf' must has been allocated sufficiently. 1967 */ 1968 static caddr_t 1969 pfkey_setsadbsa(buf, lim, spi, wsize, auth, enc, flags) 1970 caddr_t buf; 1971 caddr_t lim; 1972 u_int32_t spi, flags; 1973 u_int wsize, auth, enc; 1974 { 1975 struct sadb_sa *p; 1976 u_int len; 1977 1978 p = (struct sadb_sa *)buf; 1979 len = sizeof(struct sadb_sa); 1980 1981 if (buf + len > lim) 1982 return NULL; 1983 1984 memset(p, 0, len); 1985 p->sadb_sa_len = PFKEY_UNIT64(len); 1986 p->sadb_sa_exttype = SADB_EXT_SA; 1987 p->sadb_sa_spi = spi; 1988 p->sadb_sa_replay = wsize; 1989 p->sadb_sa_state = SADB_SASTATE_LARVAL; 1990 p->sadb_sa_auth = auth; 1991 p->sadb_sa_encrypt = enc; 1992 p->sadb_sa_flags = flags; 1993 1994 return(buf + len); 1995 } 1996 1997 /* 1998 * set data into sadb_address. 1999 * `buf' must has been allocated sufficiently. 2000 * prefixlen is in bits. 2001 */ 2002 static caddr_t 2003 pfkey_setsadbaddr(buf, lim, exttype, saddr, prefixlen, ul_proto) 2004 caddr_t buf; 2005 caddr_t lim; 2006 u_int exttype; 2007 struct sockaddr *saddr; 2008 u_int prefixlen; 2009 u_int ul_proto; 2010 { 2011 struct sadb_address *p; 2012 u_int len; 2013 2014 p = (struct sadb_address *)buf; 2015 len = sizeof(struct sadb_address) + PFKEY_ALIGN8(saddr->sa_len); 2016 2017 if (buf + len > lim) 2018 return NULL; 2019 2020 memset(p, 0, len); 2021 p->sadb_address_len = PFKEY_UNIT64(len); 2022 p->sadb_address_exttype = exttype & 0xffff; 2023 p->sadb_address_proto = ul_proto & 0xff; 2024 p->sadb_address_prefixlen = prefixlen; 2025 p->sadb_address_reserved = 0; 2026 2027 memcpy(p + 1, saddr, saddr->sa_len); 2028 2029 return(buf + len); 2030 } 2031 2032 /* 2033 * set sadb_key structure after clearing buffer with zero. 2034 * OUT: the pointer of buf + len. 2035 */ 2036 static caddr_t 2037 pfkey_setsadbkey(buf, lim, type, key, keylen) 2038 caddr_t buf; 2039 caddr_t lim; 2040 caddr_t key; 2041 u_int type, keylen; 2042 { 2043 struct sadb_key *p; 2044 u_int len; 2045 2046 p = (struct sadb_key *)buf; 2047 len = sizeof(struct sadb_key) + PFKEY_ALIGN8(keylen); 2048 2049 if (buf + len > lim) 2050 return NULL; 2051 2052 memset(p, 0, len); 2053 p->sadb_key_len = PFKEY_UNIT64(len); 2054 p->sadb_key_exttype = type; 2055 p->sadb_key_bits = keylen << 3; 2056 p->sadb_key_reserved = 0; 2057 2058 memcpy(p + 1, key, keylen); 2059 2060 return buf + len; 2061 } 2062 2063 /* 2064 * set sadb_lifetime structure after clearing buffer with zero. 2065 * OUT: the pointer of buf + len. 2066 */ 2067 static caddr_t 2068 pfkey_setsadblifetime(buf, lim, type, l_alloc, l_bytes, l_addtime, l_usetime) 2069 caddr_t buf; 2070 caddr_t lim; 2071 u_int type; 2072 u_int32_t l_alloc, l_bytes, l_addtime, l_usetime; 2073 { 2074 struct sadb_lifetime *p; 2075 u_int len; 2076 2077 p = (struct sadb_lifetime *)buf; 2078 len = sizeof(struct sadb_lifetime); 2079 2080 if (buf + len > lim) 2081 return NULL; 2082 2083 memset(p, 0, len); 2084 p->sadb_lifetime_len = PFKEY_UNIT64(len); 2085 p->sadb_lifetime_exttype = type; 2086 2087 switch (type) { 2088 case SADB_EXT_LIFETIME_SOFT: 2089 p->sadb_lifetime_allocations 2090 = (l_alloc * soft_lifetime_allocations_rate) /100; 2091 p->sadb_lifetime_bytes 2092 = (l_bytes * soft_lifetime_bytes_rate) /100; 2093 p->sadb_lifetime_addtime 2094 = (l_addtime * soft_lifetime_addtime_rate) /100; 2095 p->sadb_lifetime_usetime 2096 = (l_usetime * soft_lifetime_usetime_rate) /100; 2097 break; 2098 case SADB_EXT_LIFETIME_HARD: 2099 p->sadb_lifetime_allocations = l_alloc; 2100 p->sadb_lifetime_bytes = l_bytes; 2101 p->sadb_lifetime_addtime = l_addtime; 2102 p->sadb_lifetime_usetime = l_usetime; 2103 break; 2104 } 2105 2106 return buf + len; 2107 } 2108 2109 /* 2110 * copy secasvar data into sadb_address. 2111 * `buf' must has been allocated sufficiently. 2112 */ 2113 static caddr_t 2114 pfkey_setsadbxsa2(buf, lim, mode0, reqid) 2115 caddr_t buf; 2116 caddr_t lim; 2117 u_int32_t mode0; 2118 u_int32_t reqid; 2119 { 2120 struct sadb_x_sa2 *p; 2121 u_int8_t mode = mode0 & 0xff; 2122 u_int len; 2123 2124 p = (struct sadb_x_sa2 *)buf; 2125 len = sizeof(struct sadb_x_sa2); 2126 2127 if (buf + len > lim) 2128 return NULL; 2129 2130 memset(p, 0, len); 2131 p->sadb_x_sa2_len = PFKEY_UNIT64(len); 2132 p->sadb_x_sa2_exttype = SADB_X_EXT_SA2; 2133 p->sadb_x_sa2_mode = mode; 2134 p->sadb_x_sa2_reqid = reqid; 2135 2136 return(buf + len); 2137 } 2138