1 /* $OpenBSD: x509_addr.c,v 1.85 2022/11/26 16:08:54 tb Exp $ */ 2 /* 3 * Contributed to the OpenSSL Project by the American Registry for 4 * Internet Numbers ("ARIN"). 5 */ 6 /* ==================================================================== 7 * Copyright (c) 2006-2016 The OpenSSL Project. All rights reserved. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in 18 * the documentation and/or other materials provided with the 19 * distribution. 20 * 21 * 3. All advertising materials mentioning features or use of this 22 * software must display the following acknowledgment: 23 * "This product includes software developed by the OpenSSL Project 24 * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" 25 * 26 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to 27 * endorse or promote products derived from this software without 28 * prior written permission. For written permission, please contact 29 * licensing@OpenSSL.org. 30 * 31 * 5. Products derived from this software may not be called "OpenSSL" 32 * nor may "OpenSSL" appear in their names without prior written 33 * permission of the OpenSSL Project. 34 * 35 * 6. Redistributions of any form whatsoever must retain the following 36 * acknowledgment: 37 * "This product includes software developed by the OpenSSL Project 38 * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" 39 * 40 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY 41 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 42 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 43 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR 44 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 45 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 46 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 47 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 48 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 49 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 50 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 51 * OF THE POSSIBILITY OF SUCH DAMAGE. 52 * ==================================================================== 53 * 54 * This product includes cryptographic software written by Eric Young 55 * (eay@cryptsoft.com). This product includes software written by Tim 56 * Hudson (tjh@cryptsoft.com). 57 */ 58 59 /* 60 * Implementation of RFC 3779 section 2.2. 61 */ 62 63 #include <limits.h> 64 #include <stdio.h> 65 #include <stdlib.h> 66 #include <string.h> 67 68 #include <openssl/asn1.h> 69 #include <openssl/asn1t.h> 70 #include <openssl/buffer.h> 71 #include <openssl/conf.h> 72 #include <openssl/err.h> 73 #include <openssl/x509.h> 74 #include <openssl/x509v3.h> 75 76 #include "asn1_local.h" 77 #include "bytestring.h" 78 #include "x509_local.h" 79 80 #ifndef OPENSSL_NO_RFC3779 81 82 /* 83 * OpenSSL ASN.1 template translation of RFC 3779 2.2.3. 84 */ 85 86 static const ASN1_TEMPLATE IPAddressRange_seq_tt[] = { 87 { 88 .flags = 0, 89 .tag = 0, 90 .offset = offsetof(IPAddressRange, min), 91 .field_name = "min", 92 .item = &ASN1_BIT_STRING_it, 93 }, 94 { 95 .flags = 0, 96 .tag = 0, 97 .offset = offsetof(IPAddressRange, max), 98 .field_name = "max", 99 .item = &ASN1_BIT_STRING_it, 100 }, 101 }; 102 103 const ASN1_ITEM IPAddressRange_it = { 104 .itype = ASN1_ITYPE_SEQUENCE, 105 .utype = V_ASN1_SEQUENCE, 106 .templates = IPAddressRange_seq_tt, 107 .tcount = sizeof(IPAddressRange_seq_tt) / sizeof(ASN1_TEMPLATE), 108 .funcs = NULL, 109 .size = sizeof(IPAddressRange), 110 .sname = "IPAddressRange", 111 }; 112 113 static const ASN1_TEMPLATE IPAddressOrRange_ch_tt[] = { 114 { 115 .flags = 0, 116 .tag = 0, 117 .offset = offsetof(IPAddressOrRange, u.addressPrefix), 118 .field_name = "u.addressPrefix", 119 .item = &ASN1_BIT_STRING_it, 120 }, 121 { 122 .flags = 0, 123 .tag = 0, 124 .offset = offsetof(IPAddressOrRange, u.addressRange), 125 .field_name = "u.addressRange", 126 .item = &IPAddressRange_it, 127 }, 128 }; 129 130 const ASN1_ITEM IPAddressOrRange_it = { 131 .itype = ASN1_ITYPE_CHOICE, 132 .utype = offsetof(IPAddressOrRange, type), 133 .templates = IPAddressOrRange_ch_tt, 134 .tcount = sizeof(IPAddressOrRange_ch_tt) / sizeof(ASN1_TEMPLATE), 135 .funcs = NULL, 136 .size = sizeof(IPAddressOrRange), 137 .sname = "IPAddressOrRange", 138 }; 139 140 static const ASN1_TEMPLATE IPAddressChoice_ch_tt[] = { 141 { 142 .flags = 0, 143 .tag = 0, 144 .offset = offsetof(IPAddressChoice, u.inherit), 145 .field_name = "u.inherit", 146 .item = &ASN1_NULL_it, 147 }, 148 { 149 .flags = ASN1_TFLG_SEQUENCE_OF, 150 .tag = 0, 151 .offset = offsetof(IPAddressChoice, u.addressesOrRanges), 152 .field_name = "u.addressesOrRanges", 153 .item = &IPAddressOrRange_it, 154 }, 155 }; 156 157 const ASN1_ITEM IPAddressChoice_it = { 158 .itype = ASN1_ITYPE_CHOICE, 159 .utype = offsetof(IPAddressChoice, type), 160 .templates = IPAddressChoice_ch_tt, 161 .tcount = sizeof(IPAddressChoice_ch_tt) / sizeof(ASN1_TEMPLATE), 162 .funcs = NULL, 163 .size = sizeof(IPAddressChoice), 164 .sname = "IPAddressChoice", 165 }; 166 167 static const ASN1_TEMPLATE IPAddressFamily_seq_tt[] = { 168 { 169 .flags = 0, 170 .tag = 0, 171 .offset = offsetof(IPAddressFamily, addressFamily), 172 .field_name = "addressFamily", 173 .item = &ASN1_OCTET_STRING_it, 174 }, 175 { 176 .flags = 0, 177 .tag = 0, 178 .offset = offsetof(IPAddressFamily, ipAddressChoice), 179 .field_name = "ipAddressChoice", 180 .item = &IPAddressChoice_it, 181 }, 182 }; 183 184 const ASN1_ITEM IPAddressFamily_it = { 185 .itype = ASN1_ITYPE_SEQUENCE, 186 .utype = V_ASN1_SEQUENCE, 187 .templates = IPAddressFamily_seq_tt, 188 .tcount = sizeof(IPAddressFamily_seq_tt) / sizeof(ASN1_TEMPLATE), 189 .funcs = NULL, 190 .size = sizeof(IPAddressFamily), 191 .sname = "IPAddressFamily", 192 }; 193 194 static const ASN1_TEMPLATE IPAddrBlocks_item_tt = { 195 .flags = ASN1_TFLG_SEQUENCE_OF, 196 .tag = 0, 197 .offset = 0, 198 .field_name = "IPAddrBlocks", 199 .item = &IPAddressFamily_it, 200 }; 201 202 static const ASN1_ITEM IPAddrBlocks_it = { 203 .itype = ASN1_ITYPE_PRIMITIVE, 204 .utype = -1, 205 .templates = &IPAddrBlocks_item_tt, 206 .tcount = 0, 207 .funcs = NULL, 208 .size = 0, 209 .sname = "IPAddrBlocks", 210 }; 211 212 IPAddressRange * 213 d2i_IPAddressRange(IPAddressRange **a, const unsigned char **in, long len) 214 { 215 return (IPAddressRange *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, 216 &IPAddressRange_it); 217 } 218 LCRYPTO_ALIAS(d2i_IPAddressRange) 219 220 int 221 i2d_IPAddressRange(IPAddressRange *a, unsigned char **out) 222 { 223 return ASN1_item_i2d((ASN1_VALUE *)a, out, &IPAddressRange_it); 224 } 225 LCRYPTO_ALIAS(i2d_IPAddressRange) 226 227 IPAddressRange * 228 IPAddressRange_new(void) 229 { 230 return (IPAddressRange *)ASN1_item_new(&IPAddressRange_it); 231 } 232 LCRYPTO_ALIAS(IPAddressRange_new) 233 234 void 235 IPAddressRange_free(IPAddressRange *a) 236 { 237 ASN1_item_free((ASN1_VALUE *)a, &IPAddressRange_it); 238 } 239 LCRYPTO_ALIAS(IPAddressRange_free) 240 241 IPAddressOrRange * 242 d2i_IPAddressOrRange(IPAddressOrRange **a, const unsigned char **in, long len) 243 { 244 return (IPAddressOrRange *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, 245 &IPAddressOrRange_it); 246 } 247 LCRYPTO_ALIAS(d2i_IPAddressOrRange) 248 249 int 250 i2d_IPAddressOrRange(IPAddressOrRange *a, unsigned char **out) 251 { 252 return ASN1_item_i2d((ASN1_VALUE *)a, out, &IPAddressOrRange_it); 253 } 254 LCRYPTO_ALIAS(i2d_IPAddressOrRange) 255 256 IPAddressOrRange * 257 IPAddressOrRange_new(void) 258 { 259 return (IPAddressOrRange *)ASN1_item_new(&IPAddressOrRange_it); 260 } 261 LCRYPTO_ALIAS(IPAddressOrRange_new) 262 263 void 264 IPAddressOrRange_free(IPAddressOrRange *a) 265 { 266 ASN1_item_free((ASN1_VALUE *)a, &IPAddressOrRange_it); 267 } 268 LCRYPTO_ALIAS(IPAddressOrRange_free) 269 270 IPAddressChoice * 271 d2i_IPAddressChoice(IPAddressChoice **a, const unsigned char **in, long len) 272 { 273 return (IPAddressChoice *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, 274 &IPAddressChoice_it); 275 } 276 LCRYPTO_ALIAS(d2i_IPAddressChoice) 277 278 int 279 i2d_IPAddressChoice(IPAddressChoice *a, unsigned char **out) 280 { 281 return ASN1_item_i2d((ASN1_VALUE *)a, out, &IPAddressChoice_it); 282 } 283 LCRYPTO_ALIAS(i2d_IPAddressChoice) 284 285 IPAddressChoice * 286 IPAddressChoice_new(void) 287 { 288 return (IPAddressChoice *)ASN1_item_new(&IPAddressChoice_it); 289 } 290 LCRYPTO_ALIAS(IPAddressChoice_new) 291 292 void 293 IPAddressChoice_free(IPAddressChoice *a) 294 { 295 ASN1_item_free((ASN1_VALUE *)a, &IPAddressChoice_it); 296 } 297 LCRYPTO_ALIAS(IPAddressChoice_free) 298 299 IPAddressFamily * 300 d2i_IPAddressFamily(IPAddressFamily **a, const unsigned char **in, long len) 301 { 302 return (IPAddressFamily *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, 303 &IPAddressFamily_it); 304 } 305 LCRYPTO_ALIAS(d2i_IPAddressFamily) 306 307 int 308 i2d_IPAddressFamily(IPAddressFamily *a, unsigned char **out) 309 { 310 return ASN1_item_i2d((ASN1_VALUE *)a, out, &IPAddressFamily_it); 311 } 312 LCRYPTO_ALIAS(i2d_IPAddressFamily) 313 314 IPAddressFamily * 315 IPAddressFamily_new(void) 316 { 317 return (IPAddressFamily *)ASN1_item_new(&IPAddressFamily_it); 318 } 319 LCRYPTO_ALIAS(IPAddressFamily_new) 320 321 void 322 IPAddressFamily_free(IPAddressFamily *a) 323 { 324 ASN1_item_free((ASN1_VALUE *)a, &IPAddressFamily_it); 325 } 326 LCRYPTO_ALIAS(IPAddressFamily_free) 327 328 /* 329 * Convenience accessors for IPAddressFamily. 330 */ 331 332 static int 333 IPAddressFamily_type(IPAddressFamily *af) 334 { 335 /* XXX - can af->ipAddressChoice == NULL actually happen? */ 336 if (af == NULL || af->ipAddressChoice == NULL) 337 return -1; 338 339 switch (af->ipAddressChoice->type) { 340 case IPAddressChoice_inherit: 341 case IPAddressChoice_addressesOrRanges: 342 return af->ipAddressChoice->type; 343 default: 344 return -1; 345 } 346 } 347 348 static IPAddressOrRanges * 349 IPAddressFamily_addressesOrRanges(IPAddressFamily *af) 350 { 351 if (IPAddressFamily_type(af) == IPAddressChoice_addressesOrRanges) 352 return af->ipAddressChoice->u.addressesOrRanges; 353 354 return NULL; 355 } 356 357 static ASN1_NULL * 358 IPAddressFamily_inheritance(IPAddressFamily *af) 359 { 360 if (IPAddressFamily_type(af) == IPAddressChoice_inherit) 361 return af->ipAddressChoice->u.inherit; 362 363 return NULL; 364 } 365 366 static int 367 IPAddressFamily_set_inheritance(IPAddressFamily *af) 368 { 369 if (IPAddressFamily_addressesOrRanges(af) != NULL) 370 return 0; 371 372 if (IPAddressFamily_inheritance(af) != NULL) 373 return 1; 374 375 if ((af->ipAddressChoice->u.inherit = ASN1_NULL_new()) == NULL) 376 return 0; 377 af->ipAddressChoice->type = IPAddressChoice_inherit; 378 379 return 1; 380 } 381 382 /* 383 * How much buffer space do we need for a raw address? 384 */ 385 #define ADDR_RAW_BUF_LEN 16 386 387 /* 388 * What's the address length associated with this AFI? 389 */ 390 static int 391 length_from_afi(const unsigned afi) 392 { 393 switch (afi) { 394 case IANA_AFI_IPV4: 395 return 4; 396 case IANA_AFI_IPV6: 397 return 16; 398 default: 399 return 0; 400 } 401 } 402 403 /* 404 * Get AFI and optional SAFI from an IPAddressFamily. All three out arguments 405 * are optional; if |out_safi| is non-NULL, |safi_is_set| must be non-NULL. 406 */ 407 static int 408 IPAddressFamily_afi_safi(const IPAddressFamily *af, uint16_t *out_afi, 409 uint8_t *out_safi, int *safi_is_set) 410 { 411 CBS cbs; 412 uint16_t afi; 413 uint8_t safi = 0; 414 int got_safi = 0; 415 416 CBS_init(&cbs, af->addressFamily->data, af->addressFamily->length); 417 418 if (!CBS_get_u16(&cbs, &afi)) 419 return 0; 420 421 /* Fetch the optional SAFI. */ 422 if (CBS_len(&cbs) != 0) { 423 if (!CBS_get_u8(&cbs, &safi)) 424 return 0; 425 got_safi = 1; 426 } 427 428 /* If there's anything left, it's garbage. */ 429 if (CBS_len(&cbs) != 0) 430 return 0; 431 432 /* XXX - error on reserved AFI/SAFI? */ 433 434 if (out_afi != NULL) 435 *out_afi = afi; 436 437 if (out_safi != NULL) { 438 *out_safi = safi; 439 *safi_is_set = got_safi; 440 } 441 442 return 1; 443 } 444 445 static int 446 IPAddressFamily_afi(const IPAddressFamily *af, uint16_t *out_afi) 447 { 448 return IPAddressFamily_afi_safi(af, out_afi, NULL, NULL); 449 } 450 451 static int 452 IPAddressFamily_afi_is_valid(const IPAddressFamily *af) 453 { 454 return IPAddressFamily_afi_safi(af, NULL, NULL, NULL); 455 } 456 457 static int 458 IPAddressFamily_afi_length(const IPAddressFamily *af, int *out_length) 459 { 460 uint16_t afi; 461 462 *out_length = 0; 463 464 if (!IPAddressFamily_afi(af, &afi)) 465 return 0; 466 467 *out_length = length_from_afi(afi); 468 469 return 1; 470 } 471 472 #define MINIMUM(a, b) (((a) < (b)) ? (a) : (b)) 473 474 /* 475 * Sort comparison function for a sequence of IPAddressFamily. 476 * 477 * The last paragraph of RFC 3779 2.2.3.3 is slightly ambiguous about 478 * the ordering: I can read it as meaning that IPv6 without a SAFI 479 * comes before IPv4 with a SAFI, which seems pretty weird. The 480 * examples in appendix B suggest that the author intended the 481 * null-SAFI rule to apply only within a single AFI, which is what I 482 * would have expected and is what the following code implements. 483 */ 484 static int 485 IPAddressFamily_cmp(const IPAddressFamily *const *a_, 486 const IPAddressFamily *const *b_) 487 { 488 const ASN1_OCTET_STRING *a = (*a_)->addressFamily; 489 const ASN1_OCTET_STRING *b = (*b_)->addressFamily; 490 int len, cmp; 491 492 len = MINIMUM(a->length, b->length); 493 494 if ((cmp = memcmp(a->data, b->data, len)) != 0) 495 return cmp; 496 497 return a->length - b->length; 498 } 499 500 static IPAddressFamily * 501 IPAddressFamily_find_in_parent(IPAddrBlocks *parent, IPAddressFamily *child_af) 502 { 503 int index; 504 505 (void)sk_IPAddressFamily_set_cmp_func(parent, IPAddressFamily_cmp); 506 507 if ((index = sk_IPAddressFamily_find(parent, child_af)) < 0) 508 return NULL; 509 510 return sk_IPAddressFamily_value(parent, index); 511 } 512 513 /* 514 * Extract the AFI from an IPAddressFamily. 515 * 516 * This is public API. It uses the reserved AFI 0 as an in-band error 517 * while it doesn't care about the reserved AFI 65535... 518 */ 519 unsigned int 520 X509v3_addr_get_afi(const IPAddressFamily *af) 521 { 522 uint16_t afi; 523 524 /* 525 * XXX are these NULL checks really sensible? If af is non-NULL, it 526 * should have both addressFamily and ipAddressChoice... 527 */ 528 if (af == NULL || af->addressFamily == NULL || 529 af->addressFamily->data == NULL) 530 return 0; 531 532 if (!IPAddressFamily_afi(af, &afi)) 533 return 0; 534 535 return afi; 536 } 537 LCRYPTO_ALIAS(X509v3_addr_get_afi) 538 539 /* 540 * Expand the bitstring form (RFC 3779, section 2.1.2) of an address into 541 * a raw byte array. At the moment this is coded for simplicity, not speed. 542 * 543 * Unused bits in the last octet of |bs| and all bits in subsequent bytes 544 * of |addr| are set to 0 or 1 depending on whether |fill| is 0 or not. 545 */ 546 static int 547 addr_expand(unsigned char *addr, const ASN1_BIT_STRING *bs, const int length, 548 uint8_t fill) 549 { 550 if (bs->length < 0 || bs->length > length) 551 return 0; 552 553 if (fill != 0) 554 fill = 0xff; 555 556 if (bs->length > 0) { 557 /* XXX - shouldn't this check ASN1_STRING_FLAG_BITS_LEFT? */ 558 uint8_t unused_bits = bs->flags & 7; 559 uint8_t mask = (1 << unused_bits) - 1; 560 561 memcpy(addr, bs->data, bs->length); 562 563 if (fill == 0) 564 addr[bs->length - 1] &= ~mask; 565 else 566 addr[bs->length - 1] |= mask; 567 } 568 569 memset(addr + bs->length, fill, length - bs->length); 570 571 return 1; 572 } 573 574 /* 575 * Extract the prefix length from a bitstring: 8 * length - unused bits. 576 */ 577 #define addr_prefix_len(bs) ((int) ((bs)->length * 8 - ((bs)->flags & 7))) 578 579 /* 580 * i2r handler for one address bitstring. 581 */ 582 static int 583 i2r_address(BIO *out, const unsigned afi, const unsigned char fill, 584 const ASN1_BIT_STRING *bs) 585 { 586 unsigned char addr[ADDR_RAW_BUF_LEN]; 587 int i, n; 588 589 if (bs->length < 0) 590 return 0; 591 switch (afi) { 592 case IANA_AFI_IPV4: 593 if (!addr_expand(addr, bs, 4, fill)) 594 return 0; 595 BIO_printf(out, "%d.%d.%d.%d", addr[0], addr[1], addr[2], 596 addr[3]); 597 break; 598 case IANA_AFI_IPV6: 599 if (!addr_expand(addr, bs, 16, fill)) 600 return 0; 601 for (n = 16; 602 n > 1 && addr[n - 1] == 0x00 && addr[n - 2] == 0x00; n -= 2) 603 continue; 604 for (i = 0; i < n; i += 2) 605 BIO_printf(out, "%x%s", (addr[i] << 8) | addr[i + 1], 606 (i < 14 ? ":" : "")); 607 if (i < 16) 608 BIO_puts(out, ":"); 609 if (i == 0) 610 BIO_puts(out, ":"); 611 break; 612 default: 613 for (i = 0; i < bs->length; i++) 614 BIO_printf(out, "%s%02x", (i > 0 ? ":" : ""), 615 bs->data[i]); 616 BIO_printf(out, "[%d]", (int)(bs->flags & 7)); 617 break; 618 } 619 return 1; 620 } 621 622 /* 623 * i2r handler for a sequence of addresses and ranges. 624 */ 625 static int 626 i2r_IPAddressOrRanges(BIO *out, const int indent, 627 const IPAddressOrRanges *aors, const unsigned afi) 628 { 629 const IPAddressOrRange *aor; 630 const ASN1_BIT_STRING *prefix; 631 const IPAddressRange *range; 632 int i; 633 634 for (i = 0; i < sk_IPAddressOrRange_num(aors); i++) { 635 aor = sk_IPAddressOrRange_value(aors, i); 636 637 BIO_printf(out, "%*s", indent, ""); 638 639 switch (aor->type) { 640 case IPAddressOrRange_addressPrefix: 641 prefix = aor->u.addressPrefix; 642 643 if (!i2r_address(out, afi, 0x00, prefix)) 644 return 0; 645 BIO_printf(out, "/%d\n", addr_prefix_len(prefix)); 646 continue; 647 case IPAddressOrRange_addressRange: 648 range = aor->u.addressRange; 649 650 if (!i2r_address(out, afi, 0x00, range->min)) 651 return 0; 652 BIO_puts(out, "-"); 653 if (!i2r_address(out, afi, 0xff, range->max)) 654 return 0; 655 BIO_puts(out, "\n"); 656 continue; 657 } 658 } 659 660 return 1; 661 } 662 663 /* 664 * i2r handler for an IPAddrBlocks extension. 665 */ 666 static int 667 i2r_IPAddrBlocks(const X509V3_EXT_METHOD *method, void *ext, BIO *out, 668 int indent) 669 { 670 const IPAddrBlocks *addr = ext; 671 IPAddressFamily *af; 672 uint16_t afi; 673 uint8_t safi; 674 int i, safi_is_set; 675 676 for (i = 0; i < sk_IPAddressFamily_num(addr); i++) { 677 af = sk_IPAddressFamily_value(addr, i); 678 679 if (!IPAddressFamily_afi_safi(af, &afi, &safi, &safi_is_set)) 680 goto print_addresses; 681 682 switch (afi) { 683 case IANA_AFI_IPV4: 684 BIO_printf(out, "%*sIPv4", indent, ""); 685 break; 686 case IANA_AFI_IPV6: 687 BIO_printf(out, "%*sIPv6", indent, ""); 688 break; 689 default: 690 BIO_printf(out, "%*sUnknown AFI %u", indent, "", afi); 691 break; 692 } 693 if (safi_is_set) { 694 switch (safi) { 695 case 1: 696 BIO_puts(out, " (Unicast)"); 697 break; 698 case 2: 699 BIO_puts(out, " (Multicast)"); 700 break; 701 case 3: 702 BIO_puts(out, " (Unicast/Multicast)"); 703 break; 704 case 4: 705 BIO_puts(out, " (MPLS)"); 706 break; 707 case 64: 708 BIO_puts(out, " (Tunnel)"); 709 break; 710 case 65: 711 BIO_puts(out, " (VPLS)"); 712 break; 713 case 66: 714 BIO_puts(out, " (BGP MDT)"); 715 break; 716 case 128: 717 BIO_puts(out, " (MPLS-labeled VPN)"); 718 break; 719 default: 720 BIO_printf(out, " (Unknown SAFI %u)", safi); 721 break; 722 } 723 } 724 725 print_addresses: 726 switch (IPAddressFamily_type(af)) { 727 case IPAddressChoice_inherit: 728 BIO_puts(out, ": inherit\n"); 729 break; 730 case IPAddressChoice_addressesOrRanges: 731 BIO_puts(out, ":\n"); 732 if (!i2r_IPAddressOrRanges(out, indent + 2, 733 IPAddressFamily_addressesOrRanges(af), afi)) 734 return 0; 735 break; 736 /* XXX - how should we handle -1 here? */ 737 } 738 } 739 return 1; 740 } 741 742 /* 743 * Sort comparison function for a sequence of IPAddressOrRange 744 * elements. 745 * 746 * There's no sane answer we can give if addr_expand() fails, and an 747 * assertion failure on externally supplied data is seriously uncool, 748 * so we just arbitrarily declare that if given invalid inputs this 749 * function returns -1. If this messes up your preferred sort order 750 * for garbage input, tough noogies. 751 */ 752 static int 753 IPAddressOrRange_cmp(const IPAddressOrRange *a, const IPAddressOrRange *b, 754 const int length) 755 { 756 unsigned char addr_a[ADDR_RAW_BUF_LEN], addr_b[ADDR_RAW_BUF_LEN]; 757 int prefix_len_a = 0, prefix_len_b = 0; 758 int r; 759 760 switch (a->type) { 761 case IPAddressOrRange_addressPrefix: 762 if (!addr_expand(addr_a, a->u.addressPrefix, length, 0x00)) 763 return -1; 764 prefix_len_a = addr_prefix_len(a->u.addressPrefix); 765 break; 766 case IPAddressOrRange_addressRange: 767 if (!addr_expand(addr_a, a->u.addressRange->min, length, 0x00)) 768 return -1; 769 prefix_len_a = length * 8; 770 break; 771 } 772 773 switch (b->type) { 774 case IPAddressOrRange_addressPrefix: 775 if (!addr_expand(addr_b, b->u.addressPrefix, length, 0x00)) 776 return -1; 777 prefix_len_b = addr_prefix_len(b->u.addressPrefix); 778 break; 779 case IPAddressOrRange_addressRange: 780 if (!addr_expand(addr_b, b->u.addressRange->min, length, 0x00)) 781 return -1; 782 prefix_len_b = length * 8; 783 break; 784 } 785 786 if ((r = memcmp(addr_a, addr_b, length)) != 0) 787 return r; 788 else 789 return prefix_len_a - prefix_len_b; 790 } 791 792 /* 793 * IPv4-specific closure over IPAddressOrRange_cmp, since sk_sort() 794 * comparison routines are only allowed two arguments. 795 */ 796 static int 797 v4IPAddressOrRange_cmp(const IPAddressOrRange *const *a, 798 const IPAddressOrRange *const *b) 799 { 800 return IPAddressOrRange_cmp(*a, *b, 4); 801 } 802 803 /* 804 * IPv6-specific closure over IPAddressOrRange_cmp, since sk_sort() 805 * comparison routines are only allowed two arguments. 806 */ 807 static int 808 v6IPAddressOrRange_cmp(const IPAddressOrRange *const *a, 809 const IPAddressOrRange *const *b) 810 { 811 return IPAddressOrRange_cmp(*a, *b, 16); 812 } 813 814 /* 815 * Calculate whether a range collapses to a prefix. 816 * See last paragraph of RFC 3779 2.2.3.7. 817 * 818 * It's the caller's responsibility to ensure that min <= max. 819 */ 820 static int 821 range_should_be_prefix(const unsigned char *min, const unsigned char *max, 822 const int length) 823 { 824 unsigned char mask; 825 int i, j; 826 827 for (i = 0; i < length && min[i] == max[i]; i++) 828 continue; 829 for (j = length - 1; j >= 0 && min[j] == 0x00 && max[j] == 0xff; j--) 830 continue; 831 if (i < j) 832 return -1; 833 if (i > j) 834 return i * 8; 835 mask = min[i] ^ max[i]; 836 switch (mask) { 837 case 0x01: 838 j = 7; 839 break; 840 case 0x03: 841 j = 6; 842 break; 843 case 0x07: 844 j = 5; 845 break; 846 case 0x0f: 847 j = 4; 848 break; 849 case 0x1f: 850 j = 3; 851 break; 852 case 0x3f: 853 j = 2; 854 break; 855 case 0x7f: 856 j = 1; 857 break; 858 default: 859 return -1; 860 } 861 if ((min[i] & mask) != 0 || (max[i] & mask) != mask) 862 return -1; 863 else 864 return i * 8 + j; 865 } 866 867 /* 868 * Fill IPAddressOrRange with bit string encoding of a prefix - RFC 3779, 2.1.1. 869 */ 870 static int 871 make_addressPrefix(IPAddressOrRange **out_aor, uint8_t *addr, uint32_t afi, 872 int prefix_len) 873 { 874 IPAddressOrRange *aor = NULL; 875 int afi_len, max_len, num_bits, num_octets; 876 uint8_t unused_bits; 877 878 if (prefix_len < 0) 879 goto err; 880 881 max_len = 16; 882 if ((afi_len = length_from_afi(afi)) > 0) 883 max_len = afi_len; 884 if (prefix_len > 8 * max_len) 885 goto err; 886 887 num_octets = (prefix_len + 7) / 8; 888 num_bits = prefix_len % 8; 889 890 unused_bits = 0; 891 if (num_bits > 0) 892 unused_bits = 8 - num_bits; 893 894 if ((aor = IPAddressOrRange_new()) == NULL) 895 goto err; 896 897 aor->type = IPAddressOrRange_addressPrefix; 898 899 if ((aor->u.addressPrefix = ASN1_BIT_STRING_new()) == NULL) 900 goto err; 901 if (!ASN1_BIT_STRING_set(aor->u.addressPrefix, addr, num_octets)) 902 goto err; 903 if (!asn1_abs_set_unused_bits(aor->u.addressPrefix, unused_bits)) 904 goto err; 905 906 *out_aor = aor; 907 return 1; 908 909 err: 910 IPAddressOrRange_free(aor); 911 return 0; 912 } 913 914 static uint8_t 915 count_trailing_zeroes(uint8_t octet) 916 { 917 uint8_t count = 0; 918 919 if (octet == 0) 920 return 8; 921 922 while ((octet & (1 << count)) == 0) 923 count++; 924 925 return count; 926 } 927 928 static int 929 trim_end_u8(CBS *cbs, uint8_t trim) 930 { 931 uint8_t octet; 932 933 while (CBS_len(cbs) > 0) { 934 if (!CBS_peek_last_u8(cbs, &octet)) 935 return 0; 936 if (octet != trim) 937 return 1; 938 if (!CBS_get_last_u8(cbs, &octet)) 939 return 0; 940 } 941 942 return 1; 943 } 944 945 /* 946 * Populate IPAddressOrRange with bit string encoding of a range, see 947 * RFC 3779, 2.1.2. 948 */ 949 static int 950 make_addressRange(IPAddressOrRange **out_aor, uint8_t *min, uint8_t *max, 951 uint32_t afi, int length) 952 { 953 IPAddressOrRange *aor = NULL; 954 IPAddressRange *range; 955 int prefix_len; 956 CBS cbs; 957 size_t max_len, min_len; 958 uint8_t unused_bits_min, unused_bits_max; 959 uint8_t octet; 960 961 if (memcmp(min, max, length) > 0) 962 goto err; 963 964 /* 965 * RFC 3779, 2.2.3.6 - a range that can be expressed as a prefix 966 * must be encoded as a prefix. 967 */ 968 969 if ((prefix_len = range_should_be_prefix(min, max, length)) >= 0) 970 return make_addressPrefix(out_aor, min, afi, prefix_len); 971 972 /* 973 * The bit string representing min is formed by removing all its 974 * trailing zero bits, so remove all trailing zero octets and count 975 * the trailing zero bits of the last octet. 976 */ 977 978 CBS_init(&cbs, min, length); 979 980 if (!trim_end_u8(&cbs, 0x00)) 981 goto err; 982 983 unused_bits_min = 0; 984 if ((min_len = CBS_len(&cbs)) > 0) { 985 if (!CBS_peek_last_u8(&cbs, &octet)) 986 goto err; 987 988 unused_bits_min = count_trailing_zeroes(octet); 989 } 990 991 /* 992 * The bit string representing max is formed by removing all its 993 * trailing one bits, so remove all trailing 0xff octets and count 994 * the trailing ones of the last octet. 995 */ 996 997 CBS_init(&cbs, max, length); 998 999 if (!trim_end_u8(&cbs, 0xff)) 1000 goto err; 1001 1002 unused_bits_max = 0; 1003 if ((max_len = CBS_len(&cbs)) > 0) { 1004 if (!CBS_peek_last_u8(&cbs, &octet)) 1005 goto err; 1006 1007 unused_bits_max = count_trailing_zeroes(octet + 1); 1008 } 1009 1010 /* 1011 * Populate IPAddressOrRange. 1012 */ 1013 1014 if ((aor = IPAddressOrRange_new()) == NULL) 1015 goto err; 1016 1017 aor->type = IPAddressOrRange_addressRange; 1018 1019 if ((range = aor->u.addressRange = IPAddressRange_new()) == NULL) 1020 goto err; 1021 1022 if (!ASN1_BIT_STRING_set(range->min, min, min_len)) 1023 goto err; 1024 if (!asn1_abs_set_unused_bits(range->min, unused_bits_min)) 1025 goto err; 1026 1027 if (!ASN1_BIT_STRING_set(range->max, max, max_len)) 1028 goto err; 1029 if (!asn1_abs_set_unused_bits(range->max, unused_bits_max)) 1030 goto err; 1031 1032 *out_aor = aor; 1033 1034 return 1; 1035 1036 err: 1037 IPAddressOrRange_free(aor); 1038 return 0; 1039 } 1040 1041 /* 1042 * Construct a new address family or find an existing one. 1043 */ 1044 static IPAddressFamily * 1045 make_IPAddressFamily(IPAddrBlocks *addr, const unsigned afi, 1046 const unsigned *safi) 1047 { 1048 IPAddressFamily *af = NULL; 1049 CBB cbb; 1050 CBS cbs; 1051 uint8_t *key = NULL; 1052 size_t keylen; 1053 int i; 1054 1055 if (!CBB_init(&cbb, 0)) 1056 goto err; 1057 1058 /* XXX - should afi <= 65535 and *safi <= 255 be checked here? */ 1059 1060 if (!CBB_add_u16(&cbb, afi)) 1061 goto err; 1062 if (safi != NULL) { 1063 if (!CBB_add_u8(&cbb, *safi)) 1064 goto err; 1065 } 1066 1067 if (!CBB_finish(&cbb, &key, &keylen)) 1068 goto err; 1069 1070 for (i = 0; i < sk_IPAddressFamily_num(addr); i++) { 1071 af = sk_IPAddressFamily_value(addr, i); 1072 1073 CBS_init(&cbs, af->addressFamily->data, 1074 af->addressFamily->length); 1075 if (CBS_mem_equal(&cbs, key, keylen)) 1076 goto done; 1077 } 1078 1079 if ((af = IPAddressFamily_new()) == NULL) 1080 goto err; 1081 if (!ASN1_OCTET_STRING_set(af->addressFamily, key, keylen)) 1082 goto err; 1083 if (!sk_IPAddressFamily_push(addr, af)) 1084 goto err; 1085 1086 done: 1087 free(key); 1088 1089 return af; 1090 1091 err: 1092 CBB_cleanup(&cbb); 1093 free(key); 1094 IPAddressFamily_free(af); 1095 1096 return NULL; 1097 } 1098 1099 /* 1100 * Add an inheritance element. 1101 */ 1102 int 1103 X509v3_addr_add_inherit(IPAddrBlocks *addr, const unsigned afi, 1104 const unsigned *safi) 1105 { 1106 IPAddressFamily *af; 1107 1108 if ((af = make_IPAddressFamily(addr, afi, safi)) == NULL) 1109 return 0; 1110 1111 return IPAddressFamily_set_inheritance(af); 1112 } 1113 LCRYPTO_ALIAS(X509v3_addr_add_inherit) 1114 1115 /* 1116 * Construct an IPAddressOrRange sequence, or return an existing one. 1117 */ 1118 static IPAddressOrRanges * 1119 make_prefix_or_range(IPAddrBlocks *addr, const unsigned afi, 1120 const unsigned *safi) 1121 { 1122 IPAddressFamily *af; 1123 IPAddressOrRanges *aors = NULL; 1124 1125 if ((af = make_IPAddressFamily(addr, afi, safi)) == NULL) 1126 return NULL; 1127 1128 if (IPAddressFamily_inheritance(af) != NULL) 1129 return NULL; 1130 1131 if ((aors = IPAddressFamily_addressesOrRanges(af)) != NULL) 1132 return aors; 1133 1134 if ((aors = sk_IPAddressOrRange_new_null()) == NULL) 1135 return NULL; 1136 1137 switch (afi) { 1138 case IANA_AFI_IPV4: 1139 (void)sk_IPAddressOrRange_set_cmp_func(aors, 1140 v4IPAddressOrRange_cmp); 1141 break; 1142 case IANA_AFI_IPV6: 1143 (void)sk_IPAddressOrRange_set_cmp_func(aors, 1144 v6IPAddressOrRange_cmp); 1145 break; 1146 } 1147 1148 af->ipAddressChoice->type = IPAddressChoice_addressesOrRanges; 1149 af->ipAddressChoice->u.addressesOrRanges = aors; 1150 1151 return aors; 1152 } 1153 1154 /* 1155 * Add a prefix. 1156 */ 1157 int 1158 X509v3_addr_add_prefix(IPAddrBlocks *addr, const unsigned afi, 1159 const unsigned *safi, unsigned char *a, const int prefix_len) 1160 { 1161 IPAddressOrRanges *aors; 1162 IPAddressOrRange *aor; 1163 1164 if ((aors = make_prefix_or_range(addr, afi, safi)) == NULL) 1165 return 0; 1166 1167 if (!make_addressPrefix(&aor, a, afi, prefix_len)) 1168 return 0; 1169 1170 if (sk_IPAddressOrRange_push(aors, aor) <= 0) { 1171 IPAddressOrRange_free(aor); 1172 return 0; 1173 } 1174 1175 return 1; 1176 } 1177 LCRYPTO_ALIAS(X509v3_addr_add_prefix) 1178 1179 /* 1180 * Add a range. 1181 */ 1182 int 1183 X509v3_addr_add_range(IPAddrBlocks *addr, const unsigned afi, 1184 const unsigned *safi, unsigned char *min, unsigned char *max) 1185 { 1186 IPAddressOrRanges *aors; 1187 IPAddressOrRange *aor; 1188 int length; 1189 1190 if ((aors = make_prefix_or_range(addr, afi, safi)) == NULL) 1191 return 0; 1192 1193 length = length_from_afi(afi); 1194 1195 if (!make_addressRange(&aor, min, max, afi, length)) 1196 return 0; 1197 1198 if (sk_IPAddressOrRange_push(aors, aor) <= 0) { 1199 IPAddressOrRange_free(aor); 1200 return 0; 1201 } 1202 1203 return 1; 1204 } 1205 LCRYPTO_ALIAS(X509v3_addr_add_range) 1206 1207 static int 1208 extract_min_max_bitstr(IPAddressOrRange *aor, ASN1_BIT_STRING **out_min, 1209 ASN1_BIT_STRING **out_max) 1210 { 1211 switch (aor->type) { 1212 case IPAddressOrRange_addressPrefix: 1213 *out_min = *out_max = aor->u.addressPrefix; 1214 return 1; 1215 case IPAddressOrRange_addressRange: 1216 *out_min = aor->u.addressRange->min; 1217 *out_max = aor->u.addressRange->max; 1218 return 1; 1219 default: 1220 return 0; 1221 } 1222 } 1223 1224 /* 1225 * Extract min and max values from an IPAddressOrRange. 1226 */ 1227 static int 1228 extract_min_max(IPAddressOrRange *aor, unsigned char *min, unsigned char *max, 1229 int length) 1230 { 1231 ASN1_BIT_STRING *min_bitstr, *max_bitstr; 1232 1233 if (aor == NULL || min == NULL || max == NULL) 1234 return 0; 1235 1236 if (!extract_min_max_bitstr(aor, &min_bitstr, &max_bitstr)) 1237 return 0; 1238 1239 if (!addr_expand(min, min_bitstr, length, 0)) 1240 return 0; 1241 1242 return addr_expand(max, max_bitstr, length, 1); 1243 } 1244 1245 /* 1246 * Public wrapper for extract_min_max(). 1247 */ 1248 int 1249 X509v3_addr_get_range(IPAddressOrRange *aor, const unsigned afi, 1250 unsigned char *min, unsigned char *max, const int length) 1251 { 1252 int afi_len; 1253 1254 if ((afi_len = length_from_afi(afi)) == 0) 1255 return 0; 1256 1257 if (length < afi_len) 1258 return 0; 1259 1260 if (!extract_min_max(aor, min, max, afi_len)) 1261 return 0; 1262 1263 return afi_len; 1264 } 1265 LCRYPTO_ALIAS(X509v3_addr_get_range) 1266 1267 /* 1268 * Check whether an IPAddrBLocks is in canonical form. 1269 */ 1270 int 1271 X509v3_addr_is_canonical(IPAddrBlocks *addr) 1272 { 1273 unsigned char a_min[ADDR_RAW_BUF_LEN], a_max[ADDR_RAW_BUF_LEN]; 1274 unsigned char b_min[ADDR_RAW_BUF_LEN], b_max[ADDR_RAW_BUF_LEN]; 1275 IPAddressFamily *af; 1276 IPAddressOrRanges *aors; 1277 IPAddressOrRange *aor, *aor_a, *aor_b; 1278 int i, j, k, length; 1279 1280 /* 1281 * Empty extension is canonical. 1282 */ 1283 if (addr == NULL) 1284 return 1; 1285 1286 /* 1287 * Check whether the top-level list is in order. 1288 */ 1289 for (i = 0; i < sk_IPAddressFamily_num(addr) - 1; i++) { 1290 const IPAddressFamily *a = sk_IPAddressFamily_value(addr, i); 1291 const IPAddressFamily *b = sk_IPAddressFamily_value(addr, i + 1); 1292 1293 /* Check that both have valid AFIs before comparing them. */ 1294 if (!IPAddressFamily_afi_is_valid(a)) 1295 return 0; 1296 if (!IPAddressFamily_afi_is_valid(b)) 1297 return 0; 1298 1299 if (IPAddressFamily_cmp(&a, &b) >= 0) 1300 return 0; 1301 } 1302 1303 /* 1304 * Top level's ok, now check each address family. 1305 */ 1306 for (i = 0; i < sk_IPAddressFamily_num(addr); i++) { 1307 af = sk_IPAddressFamily_value(addr, i); 1308 1309 if (!IPAddressFamily_afi_length(af, &length)) 1310 return 0; 1311 1312 /* 1313 * If this family has an inheritance element, it is canonical. 1314 */ 1315 if (IPAddressFamily_inheritance(af) != NULL) 1316 continue; 1317 1318 /* 1319 * If this family has neither an inheritance element nor an 1320 * addressesOrRanges, we don't know what this is. 1321 */ 1322 if ((aors = IPAddressFamily_addressesOrRanges(af)) == NULL) 1323 return 0; 1324 1325 if (sk_IPAddressOrRange_num(aors) == 0) 1326 return 0; 1327 1328 for (j = 0; j < sk_IPAddressOrRange_num(aors) - 1; j++) { 1329 aor_a = sk_IPAddressOrRange_value(aors, j); 1330 aor_b = sk_IPAddressOrRange_value(aors, j + 1); 1331 1332 if (!extract_min_max(aor_a, a_min, a_max, length) || 1333 !extract_min_max(aor_b, b_min, b_max, length)) 1334 return 0; 1335 1336 /* 1337 * Punt misordered list, overlapping start, or inverted 1338 * range. 1339 */ 1340 if (memcmp(a_min, b_min, length) >= 0 || 1341 memcmp(a_min, a_max, length) > 0 || 1342 memcmp(b_min, b_max, length) > 0) 1343 return 0; 1344 1345 /* 1346 * Punt if adjacent or overlapping. Check for adjacency 1347 * by subtracting one from b_min first. 1348 */ 1349 for (k = length - 1; k >= 0 && b_min[k]-- == 0x00; k--) 1350 continue; 1351 if (memcmp(a_max, b_min, length) >= 0) 1352 return 0; 1353 1354 /* 1355 * Check for range that should be expressed as a prefix. 1356 */ 1357 if (aor_a->type == IPAddressOrRange_addressPrefix) 1358 continue; 1359 1360 if (range_should_be_prefix(a_min, a_max, length) >= 0) 1361 return 0; 1362 } 1363 1364 /* 1365 * Check final range to see if it's inverted or should be a 1366 * prefix. 1367 */ 1368 aor = sk_IPAddressOrRange_value(aors, j); 1369 if (aor->type == IPAddressOrRange_addressRange) { 1370 if (!extract_min_max(aor, a_min, a_max, length)) 1371 return 0; 1372 if (memcmp(a_min, a_max, length) > 0) 1373 return 0; 1374 if (range_should_be_prefix(a_min, a_max, length) >= 0) 1375 return 0; 1376 } 1377 } 1378 1379 /* 1380 * If we made it through all that, we're happy. 1381 */ 1382 return 1; 1383 } 1384 LCRYPTO_ALIAS(X509v3_addr_is_canonical) 1385 1386 /* 1387 * Whack an IPAddressOrRanges into canonical form. 1388 */ 1389 static int 1390 IPAddressOrRanges_canonize(IPAddressOrRanges *aors, const unsigned afi) 1391 { 1392 IPAddressOrRange *a, *b, *merged; 1393 unsigned char a_min[ADDR_RAW_BUF_LEN], a_max[ADDR_RAW_BUF_LEN]; 1394 unsigned char b_min[ADDR_RAW_BUF_LEN], b_max[ADDR_RAW_BUF_LEN]; 1395 int i, j, length; 1396 1397 length = length_from_afi(afi); 1398 1399 /* 1400 * Sort the IPAddressOrRanges sequence. 1401 */ 1402 sk_IPAddressOrRange_sort(aors); 1403 1404 /* 1405 * Clean up representation issues, punt on duplicates or overlaps. 1406 */ 1407 for (i = 0; i < sk_IPAddressOrRange_num(aors) - 1; i++) { 1408 a = sk_IPAddressOrRange_value(aors, i); 1409 b = sk_IPAddressOrRange_value(aors, i + 1); 1410 1411 if (!extract_min_max(a, a_min, a_max, length) || 1412 !extract_min_max(b, b_min, b_max, length)) 1413 return 0; 1414 1415 /* 1416 * Punt inverted ranges. 1417 */ 1418 if (memcmp(a_min, a_max, length) > 0 || 1419 memcmp(b_min, b_max, length) > 0) 1420 return 0; 1421 1422 /* 1423 * Punt overlaps. 1424 */ 1425 if (memcmp(a_max, b_min, length) >= 0) 1426 return 0; 1427 1428 /* 1429 * Merge if a and b are adjacent. We check for 1430 * adjacency by subtracting one from b_min first. 1431 */ 1432 for (j = length - 1; j >= 0 && b_min[j]-- == 0x00; j--) 1433 continue; 1434 1435 if (memcmp(a_max, b_min, length) != 0) 1436 continue; 1437 1438 if (!make_addressRange(&merged, a_min, b_max, afi, length)) 1439 return 0; 1440 sk_IPAddressOrRange_set(aors, i, merged); 1441 (void)sk_IPAddressOrRange_delete(aors, i + 1); 1442 IPAddressOrRange_free(a); 1443 IPAddressOrRange_free(b); 1444 i--; 1445 } 1446 1447 /* 1448 * Check for inverted final range. 1449 */ 1450 a = sk_IPAddressOrRange_value(aors, i); 1451 if (a != NULL && a->type == IPAddressOrRange_addressRange) { 1452 if (!extract_min_max(a, a_min, a_max, length)) 1453 return 0; 1454 if (memcmp(a_min, a_max, length) > 0) 1455 return 0; 1456 } 1457 1458 return 1; 1459 } 1460 1461 /* 1462 * Whack an IPAddrBlocks extension into canonical form. 1463 */ 1464 int 1465 X509v3_addr_canonize(IPAddrBlocks *addr) 1466 { 1467 IPAddressFamily *af; 1468 IPAddressOrRanges *aors; 1469 uint16_t afi; 1470 int i; 1471 1472 for (i = 0; i < sk_IPAddressFamily_num(addr); i++) { 1473 af = sk_IPAddressFamily_value(addr, i); 1474 1475 /* Check AFI/SAFI here - IPAddressFamily_cmp() can't error. */ 1476 if (!IPAddressFamily_afi(af, &afi)) 1477 return 0; 1478 1479 if ((aors = IPAddressFamily_addressesOrRanges(af)) == NULL) 1480 continue; 1481 1482 if (!IPAddressOrRanges_canonize(aors, afi)) 1483 return 0; 1484 } 1485 1486 (void)sk_IPAddressFamily_set_cmp_func(addr, IPAddressFamily_cmp); 1487 sk_IPAddressFamily_sort(addr); 1488 1489 return X509v3_addr_is_canonical(addr); 1490 } 1491 LCRYPTO_ALIAS(X509v3_addr_canonize) 1492 1493 /* 1494 * v2i handler for the IPAddrBlocks extension. 1495 */ 1496 static void * 1497 v2i_IPAddrBlocks(const struct v3_ext_method *method, struct v3_ext_ctx *ctx, 1498 STACK_OF(CONF_VALUE)*values) 1499 { 1500 static const char v4addr_chars[] = "0123456789."; 1501 static const char v6addr_chars[] = "0123456789.:abcdefABCDEF"; 1502 IPAddrBlocks *addr = NULL; 1503 char *s = NULL, *t; 1504 int i; 1505 1506 if ((addr = sk_IPAddressFamily_new(IPAddressFamily_cmp)) == NULL) { 1507 X509V3error(ERR_R_MALLOC_FAILURE); 1508 return NULL; 1509 } 1510 1511 for (i = 0; i < sk_CONF_VALUE_num(values); i++) { 1512 CONF_VALUE *val = sk_CONF_VALUE_value(values, i); 1513 unsigned char min[ADDR_RAW_BUF_LEN], max[ADDR_RAW_BUF_LEN]; 1514 unsigned afi, *safi = NULL, safi_; 1515 const char *addr_chars = NULL; 1516 const char *errstr; 1517 int prefix_len, i1, i2, delim, length; 1518 1519 if (!name_cmp(val->name, "IPv4")) { 1520 afi = IANA_AFI_IPV4; 1521 } else if (!name_cmp(val->name, "IPv6")) { 1522 afi = IANA_AFI_IPV6; 1523 } else if (!name_cmp(val->name, "IPv4-SAFI")) { 1524 afi = IANA_AFI_IPV4; 1525 safi = &safi_; 1526 } else if (!name_cmp(val->name, "IPv6-SAFI")) { 1527 afi = IANA_AFI_IPV6; 1528 safi = &safi_; 1529 } else { 1530 X509V3error(X509V3_R_EXTENSION_NAME_ERROR); 1531 X509V3_conf_err(val); 1532 goto err; 1533 } 1534 1535 switch (afi) { 1536 case IANA_AFI_IPV4: 1537 addr_chars = v4addr_chars; 1538 break; 1539 case IANA_AFI_IPV6: 1540 addr_chars = v6addr_chars; 1541 break; 1542 } 1543 1544 length = length_from_afi(afi); 1545 1546 /* 1547 * Handle SAFI, if any, and strdup() so we can null-terminate 1548 * the other input values. 1549 */ 1550 if (safi != NULL) { 1551 unsigned long parsed_safi; 1552 int saved_errno = errno; 1553 1554 errno = 0; 1555 parsed_safi = strtoul(val->value, &t, 0); 1556 1557 /* Value must be present, then a tab, space or colon. */ 1558 if (val->value[0] == '\0' || 1559 (*t != '\t' && *t != ' ' && *t != ':')) { 1560 X509V3error(X509V3_R_INVALID_SAFI); 1561 X509V3_conf_err(val); 1562 goto err; 1563 } 1564 /* Range and overflow check. */ 1565 if ((errno == ERANGE && parsed_safi == ULONG_MAX) || 1566 parsed_safi > 0xff) { 1567 X509V3error(X509V3_R_INVALID_SAFI); 1568 X509V3_conf_err(val); 1569 goto err; 1570 } 1571 errno = saved_errno; 1572 1573 *safi = parsed_safi; 1574 1575 /* Check possible whitespace is followed by a colon. */ 1576 t += strspn(t, " \t"); 1577 if (*t != ':') { 1578 X509V3error(X509V3_R_INVALID_SAFI); 1579 X509V3_conf_err(val); 1580 goto err; 1581 } 1582 1583 /* Skip over colon. */ 1584 t++; 1585 1586 /* Then over any trailing whitespace. */ 1587 t += strspn(t, " \t"); 1588 1589 s = strdup(t); 1590 } else { 1591 s = strdup(val->value); 1592 } 1593 if (s == NULL) { 1594 X509V3error(ERR_R_MALLOC_FAILURE); 1595 goto err; 1596 } 1597 1598 /* 1599 * Check for inheritance. Not worth additional complexity to 1600 * optimize this (seldom-used) case. 1601 */ 1602 if (strcmp(s, "inherit") == 0) { 1603 if (!X509v3_addr_add_inherit(addr, afi, safi)) { 1604 X509V3error(X509V3_R_INVALID_INHERITANCE); 1605 X509V3_conf_err(val); 1606 goto err; 1607 } 1608 free(s); 1609 s = NULL; 1610 continue; 1611 } 1612 1613 i1 = strspn(s, addr_chars); 1614 i2 = i1 + strspn(s + i1, " \t"); 1615 delim = s[i2++]; 1616 s[i1] = '\0'; 1617 1618 if (a2i_ipadd(min, s) != length) { 1619 X509V3error(X509V3_R_INVALID_IPADDRESS); 1620 X509V3_conf_err(val); 1621 goto err; 1622 } 1623 1624 switch (delim) { 1625 case '/': 1626 /* length contains the size of the address in bytes. */ 1627 if (length != 4 && length != 16) 1628 goto err; 1629 prefix_len = strtonum(s + i2, 0, 8 * length, &errstr); 1630 if (errstr != NULL) { 1631 X509V3error(X509V3_R_EXTENSION_VALUE_ERROR); 1632 X509V3_conf_err(val); 1633 goto err; 1634 } 1635 if (!X509v3_addr_add_prefix(addr, afi, safi, min, 1636 prefix_len)) { 1637 X509V3error(ERR_R_MALLOC_FAILURE); 1638 goto err; 1639 } 1640 break; 1641 case '-': 1642 i1 = i2 + strspn(s + i2, " \t"); 1643 i2 = i1 + strspn(s + i1, addr_chars); 1644 if (i1 == i2 || s[i2] != '\0') { 1645 X509V3error(X509V3_R_EXTENSION_VALUE_ERROR); 1646 X509V3_conf_err(val); 1647 goto err; 1648 } 1649 if (a2i_ipadd(max, s + i1) != length) { 1650 X509V3error(X509V3_R_INVALID_IPADDRESS); 1651 X509V3_conf_err(val); 1652 goto err; 1653 } 1654 if (memcmp(min, max, length_from_afi(afi)) > 0) { 1655 X509V3error(X509V3_R_EXTENSION_VALUE_ERROR); 1656 X509V3_conf_err(val); 1657 goto err; 1658 } 1659 if (!X509v3_addr_add_range(addr, afi, safi, min, max)) { 1660 X509V3error(ERR_R_MALLOC_FAILURE); 1661 goto err; 1662 } 1663 break; 1664 case '\0': 1665 if (!X509v3_addr_add_prefix(addr, afi, safi, min, 1666 length * 8)) { 1667 X509V3error(ERR_R_MALLOC_FAILURE); 1668 goto err; 1669 } 1670 break; 1671 default: 1672 X509V3error(X509V3_R_EXTENSION_VALUE_ERROR); 1673 X509V3_conf_err(val); 1674 goto err; 1675 } 1676 1677 free(s); 1678 s = NULL; 1679 } 1680 1681 /* 1682 * Canonize the result, then we're done. 1683 */ 1684 if (!X509v3_addr_canonize(addr)) 1685 goto err; 1686 return addr; 1687 1688 err: 1689 free(s); 1690 sk_IPAddressFamily_pop_free(addr, IPAddressFamily_free); 1691 return NULL; 1692 } 1693 1694 /* 1695 * OpenSSL dispatch 1696 */ 1697 const X509V3_EXT_METHOD v3_addr = { 1698 .ext_nid = NID_sbgp_ipAddrBlock, 1699 .ext_flags = 0, 1700 .it = &IPAddrBlocks_it, 1701 .ext_new = NULL, 1702 .ext_free = NULL, 1703 .d2i = NULL, 1704 .i2d = NULL, 1705 .i2s = NULL, 1706 .s2i = NULL, 1707 .i2v = NULL, 1708 .v2i = v2i_IPAddrBlocks, 1709 .i2r = i2r_IPAddrBlocks, 1710 .r2i = NULL, 1711 .usr_data = NULL, 1712 }; 1713 1714 /* 1715 * Figure out whether extension uses inheritance. 1716 */ 1717 int 1718 X509v3_addr_inherits(IPAddrBlocks *addr) 1719 { 1720 IPAddressFamily *af; 1721 int i; 1722 1723 if (addr == NULL) 1724 return 0; 1725 1726 for (i = 0; i < sk_IPAddressFamily_num(addr); i++) { 1727 af = sk_IPAddressFamily_value(addr, i); 1728 1729 if (IPAddressFamily_inheritance(af) != NULL) 1730 return 1; 1731 } 1732 1733 return 0; 1734 } 1735 LCRYPTO_ALIAS(X509v3_addr_inherits) 1736 1737 /* 1738 * Figure out whether parent contains child. 1739 * 1740 * This only works correctly if both parent and child are in canonical form. 1741 */ 1742 static int 1743 addr_contains(IPAddressOrRanges *parent, IPAddressOrRanges *child, int length) 1744 { 1745 IPAddressOrRange *child_aor, *parent_aor; 1746 uint8_t parent_min[ADDR_RAW_BUF_LEN], parent_max[ADDR_RAW_BUF_LEN]; 1747 uint8_t child_min[ADDR_RAW_BUF_LEN], child_max[ADDR_RAW_BUF_LEN]; 1748 int p, c; 1749 1750 if (child == NULL || parent == child) 1751 return 1; 1752 if (parent == NULL) 1753 return 0; 1754 1755 p = 0; 1756 for (c = 0; c < sk_IPAddressOrRange_num(child); c++) { 1757 child_aor = sk_IPAddressOrRange_value(child, c); 1758 1759 if (!extract_min_max(child_aor, child_min, child_max, length)) 1760 return 0; 1761 1762 for (;; p++) { 1763 if (p >= sk_IPAddressOrRange_num(parent)) 1764 return 0; 1765 1766 parent_aor = sk_IPAddressOrRange_value(parent, p); 1767 1768 if (!extract_min_max(parent_aor, parent_min, parent_max, 1769 length)) 1770 return 0; 1771 1772 if (memcmp(parent_max, child_max, length) < 0) 1773 continue; 1774 if (memcmp(parent_min, child_min, length) > 0) 1775 return 0; 1776 break; 1777 } 1778 } 1779 1780 return 1; 1781 } 1782 1783 /* 1784 * Test whether |child| is a subset of |parent|. 1785 */ 1786 int 1787 X509v3_addr_subset(IPAddrBlocks *child, IPAddrBlocks *parent) 1788 { 1789 IPAddressFamily *child_af, *parent_af; 1790 IPAddressOrRanges *child_aor, *parent_aor; 1791 int i, length; 1792 1793 if (child == NULL || child == parent) 1794 return 1; 1795 if (parent == NULL) 1796 return 0; 1797 1798 if (X509v3_addr_inherits(child) || X509v3_addr_inherits(parent)) 1799 return 0; 1800 1801 for (i = 0; i < sk_IPAddressFamily_num(child); i++) { 1802 child_af = sk_IPAddressFamily_value(child, i); 1803 1804 parent_af = IPAddressFamily_find_in_parent(parent, child_af); 1805 if (parent_af == NULL) 1806 return 0; 1807 1808 if (!IPAddressFamily_afi_length(parent_af, &length)) 1809 return 0; 1810 1811 child_aor = IPAddressFamily_addressesOrRanges(child_af); 1812 parent_aor = IPAddressFamily_addressesOrRanges(parent_af); 1813 1814 if (!addr_contains(parent_aor, child_aor, length)) 1815 return 0; 1816 } 1817 return 1; 1818 } 1819 LCRYPTO_ALIAS(X509v3_addr_subset) 1820 1821 static int 1822 verify_error(X509_STORE_CTX *ctx, X509 *cert, int error, int depth) 1823 { 1824 if (ctx == NULL) 1825 return 0; 1826 1827 ctx->current_cert = cert; 1828 ctx->error = error; 1829 ctx->error_depth = depth; 1830 1831 return ctx->verify_cb(0, ctx); 1832 } 1833 1834 /* 1835 * Core code for RFC 3779 2.3 path validation. 1836 * 1837 * Returns 1 for success, 0 on error. 1838 * 1839 * When returning 0, ctx->error MUST be set to an appropriate value other than 1840 * X509_V_OK. 1841 */ 1842 static int 1843 addr_validate_path_internal(X509_STORE_CTX *ctx, STACK_OF(X509) *chain, 1844 IPAddrBlocks *ext) 1845 { 1846 IPAddrBlocks *child = NULL, *parent = NULL; 1847 IPAddressFamily *child_af, *parent_af; 1848 IPAddressOrRanges *child_aor, *parent_aor; 1849 X509 *cert = NULL; 1850 int depth = -1; 1851 int i; 1852 unsigned int length; 1853 int ret = 1; 1854 1855 /* We need a non-empty chain to test against. */ 1856 if (sk_X509_num(chain) <= 0) 1857 goto err; 1858 /* We need either a store ctx or an extension to work with. */ 1859 if (ctx == NULL && ext == NULL) 1860 goto err; 1861 /* If there is a store ctx, it needs a verify_cb. */ 1862 if (ctx != NULL && ctx->verify_cb == NULL) 1863 goto err; 1864 1865 /* 1866 * Figure out where to start. If we don't have an extension to check, 1867 * (either extracted from the leaf or passed by the caller), we're done. 1868 * Otherwise, check canonical form and set up for walking up the chain. 1869 */ 1870 if (ext == NULL) { 1871 depth = 0; 1872 cert = sk_X509_value(chain, depth); 1873 if ((X509_get_extension_flags(cert) & EXFLAG_INVALID) != 0) 1874 goto done; 1875 if ((ext = cert->rfc3779_addr) == NULL) 1876 goto done; 1877 } else if (!X509v3_addr_is_canonical(ext)) { 1878 if ((ret = verify_error(ctx, cert, 1879 X509_V_ERR_INVALID_EXTENSION, depth)) == 0) 1880 goto done; 1881 } 1882 1883 (void)sk_IPAddressFamily_set_cmp_func(ext, IPAddressFamily_cmp); 1884 if ((child = sk_IPAddressFamily_dup(ext)) == NULL) { 1885 X509V3error(ERR_R_MALLOC_FAILURE); 1886 if (ctx != NULL) 1887 ctx->error = X509_V_ERR_OUT_OF_MEM; 1888 ret = 0; 1889 goto done; 1890 } 1891 1892 /* 1893 * Now walk up the chain. No cert may list resources that its parent 1894 * doesn't list. 1895 */ 1896 for (depth++; depth < sk_X509_num(chain); depth++) { 1897 cert = sk_X509_value(chain, depth); 1898 1899 if ((X509_get_extension_flags(cert) & EXFLAG_INVALID) != 0) { 1900 if ((ret = verify_error(ctx, cert, 1901 X509_V_ERR_INVALID_EXTENSION, depth)) == 0) 1902 goto done; 1903 } 1904 1905 if ((parent = cert->rfc3779_addr) == NULL) { 1906 for (i = 0; i < sk_IPAddressFamily_num(child); i++) { 1907 child_af = sk_IPAddressFamily_value(child, i); 1908 1909 if (IPAddressFamily_inheritance(child_af) != 1910 NULL) 1911 continue; 1912 1913 if ((ret = verify_error(ctx, cert, 1914 X509_V_ERR_UNNESTED_RESOURCE, depth)) == 0) 1915 goto done; 1916 break; 1917 } 1918 continue; 1919 } 1920 1921 /* 1922 * Check that the child's resources are covered by the parent. 1923 * Each covered resource is replaced with the parent's resource 1924 * covering it, so the next iteration will check that the 1925 * parent's resources are covered by the grandparent. 1926 */ 1927 for (i = 0; i < sk_IPAddressFamily_num(child); i++) { 1928 child_af = sk_IPAddressFamily_value(child, i); 1929 1930 if ((parent_af = IPAddressFamily_find_in_parent(parent, 1931 child_af)) == NULL) { 1932 /* 1933 * If we have no match in the parent and the 1934 * child inherits, that's fine. 1935 */ 1936 if (IPAddressFamily_inheritance(child_af) != 1937 NULL) 1938 continue; 1939 1940 /* Otherwise the child isn't covered. */ 1941 if ((ret = verify_error(ctx, cert, 1942 X509_V_ERR_UNNESTED_RESOURCE, depth)) == 0) 1943 goto done; 1944 break; 1945 } 1946 1947 /* Parent inherits, nothing to do. */ 1948 if (IPAddressFamily_inheritance(parent_af) != NULL) 1949 continue; 1950 1951 /* Child inherits. Use parent's address family. */ 1952 if (IPAddressFamily_inheritance(child_af) != NULL) { 1953 sk_IPAddressFamily_set(child, i, parent_af); 1954 continue; 1955 } 1956 1957 child_aor = IPAddressFamily_addressesOrRanges(child_af); 1958 parent_aor = 1959 IPAddressFamily_addressesOrRanges(parent_af); 1960 1961 /* 1962 * Child and parent are canonical and neither inherits. 1963 * If either addressesOrRanges is NULL, something's 1964 * very wrong. 1965 */ 1966 if (child_aor == NULL || parent_aor == NULL) 1967 goto err; 1968 1969 if (!IPAddressFamily_afi_length(child_af, &length)) 1970 goto err; 1971 1972 /* Now check containment and replace or error. */ 1973 if (addr_contains(parent_aor, child_aor, length)) { 1974 sk_IPAddressFamily_set(child, i, parent_af); 1975 continue; 1976 } 1977 1978 if ((ret = verify_error(ctx, cert, 1979 X509_V_ERR_UNNESTED_RESOURCE, depth)) == 0) 1980 goto done; 1981 } 1982 } 1983 1984 /* 1985 * Trust anchor can't inherit. 1986 */ 1987 if ((parent = cert->rfc3779_addr) != NULL) { 1988 for (i = 0; i < sk_IPAddressFamily_num(parent); i++) { 1989 parent_af = sk_IPAddressFamily_value(parent, i); 1990 1991 if (IPAddressFamily_inheritance(parent_af) == NULL) 1992 continue; 1993 1994 if ((ret = verify_error(ctx, cert, 1995 X509_V_ERR_UNNESTED_RESOURCE, depth)) == 0) 1996 goto done; 1997 } 1998 } 1999 2000 done: 2001 sk_IPAddressFamily_free(child); 2002 return ret; 2003 2004 err: 2005 sk_IPAddressFamily_free(child); 2006 2007 if (ctx != NULL) 2008 ctx->error = X509_V_ERR_UNSPECIFIED; 2009 2010 return 0; 2011 } 2012 2013 /* 2014 * RFC 3779 2.3 path validation -- called from X509_verify_cert(). 2015 */ 2016 int 2017 X509v3_addr_validate_path(X509_STORE_CTX *ctx) 2018 { 2019 if (sk_X509_num(ctx->chain) <= 0 || ctx->verify_cb == NULL) { 2020 ctx->error = X509_V_ERR_UNSPECIFIED; 2021 return 0; 2022 } 2023 return addr_validate_path_internal(ctx, ctx->chain, NULL); 2024 } 2025 LCRYPTO_ALIAS(X509v3_addr_validate_path) 2026 2027 /* 2028 * RFC 3779 2.3 path validation of an extension. 2029 * Test whether chain covers extension. 2030 */ 2031 int 2032 X509v3_addr_validate_resource_set(STACK_OF(X509) *chain, IPAddrBlocks *ext, 2033 int allow_inheritance) 2034 { 2035 if (ext == NULL) 2036 return 1; 2037 if (sk_X509_num(chain) <= 0) 2038 return 0; 2039 if (!allow_inheritance && X509v3_addr_inherits(ext)) 2040 return 0; 2041 return addr_validate_path_internal(NULL, chain, ext); 2042 } 2043 LCRYPTO_ALIAS(X509v3_addr_validate_resource_set) 2044 2045 #endif /* OPENSSL_NO_RFC3779 */ 2046