1 /* 2 * Copyright (c) 2001-2003 3 * Fraunhofer Institute for Open Communication Systems (FhG Fokus). 4 * All rights reserved. 5 * 6 * Author: Harti Brandt <harti@freebsd.org> 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 * 29 * $Begemot: bsnmp/lib/asn1.c,v 1.31 2005/10/06 07:14:58 brandt_h Exp $ 30 * 31 * ASN.1 for SNMP. 32 */ 33 #include <sys/types.h> 34 #include <stdio.h> 35 #include <stdlib.h> 36 #include <stdarg.h> 37 #include <string.h> 38 #ifdef HAVE_STDINT_H 39 #include <stdint.h> 40 #elif defined(HAVE_INTTYPES_H) 41 #include <inttypes.h> 42 #endif 43 #include <assert.h> 44 45 #include "support.h" 46 #include "asn1.h" 47 48 static void asn_error_func(const struct asn_buf *, const char *, ...); 49 50 void (*asn_error)(const struct asn_buf *, const char *, ...) = asn_error_func; 51 52 /* 53 * Read the next header. This reads the tag (note, that only single 54 * byte tags are supported for now) and the length field. The length field 55 * is restricted to a 32-bit value. 56 * All errors of this function stop the decoding. 57 */ 58 enum asn_err 59 asn_get_header(struct asn_buf *b, u_char *type, asn_len_t *len) 60 { 61 u_int length; 62 63 if (b->asn_len == 0) { 64 asn_error(b, "no identifier for header"); 65 return (ASN_ERR_EOBUF); 66 } 67 *type = *b->asn_cptr; 68 if ((*type & ASN_TYPE_MASK) > 0x30) { 69 asn_error(b, "types > 0x30 not supported (%u)", 70 *type & ASN_TYPE_MASK); 71 return (ASN_ERR_FAILED); 72 } 73 b->asn_cptr++; 74 b->asn_len--; 75 if (b->asn_len == 0) { 76 asn_error(b, "no length field"); 77 return (ASN_ERR_EOBUF); 78 } 79 if (*b->asn_cptr & 0x80) { 80 length = *b->asn_cptr++ & 0x7f; 81 b->asn_len--; 82 if (length == 0) { 83 asn_error(b, "indefinite length not supported"); 84 return (ASN_ERR_FAILED); 85 } 86 if (length > ASN_MAXLENLEN) { 87 asn_error(b, "long length too long (%u)", length); 88 return (ASN_ERR_FAILED); 89 } 90 if (length > b->asn_len) { 91 asn_error(b, "long length truncated"); 92 return (ASN_ERR_EOBUF); 93 } 94 *len = 0; 95 while (length--) { 96 *len = (*len << 8) | *b->asn_cptr++; 97 b->asn_len--; 98 } 99 } else { 100 *len = *b->asn_cptr++; 101 b->asn_len--; 102 } 103 if (*len > b->asn_len) { 104 asn_error(b, "len %u exceeding asn_len %u", *len, b->asn_len); 105 return (ASN_ERR_EOBUF); 106 } 107 108 return (ASN_ERR_OK); 109 } 110 111 /* 112 * Write a length field (restricted to values < 2^32-1) and return the 113 * number of bytes this field takes. If ptr is NULL, the length is computed 114 * but nothing is written. If the length would be too large return 0. 115 */ 116 static u_int 117 asn_put_len(u_char *ptr, asn_len_t len) 118 { 119 u_int lenlen, lenlen1; 120 asn_len_t tmp; 121 122 if (len > ASN_MAXLEN) { 123 asn_error(NULL, "encoding length too long: (%u)", len); 124 return (0); 125 } 126 127 if (len <= 127) { 128 if (ptr) 129 *ptr++ = (u_char)len; 130 return (1); 131 } else { 132 lenlen = 0; 133 /* compute number of bytes for value (is at least 1) */ 134 for (tmp = len; tmp != 0; tmp >>= 8) 135 lenlen++; 136 if (ptr != NULL) { 137 *ptr++ = (u_char)lenlen | 0x80; 138 lenlen1 = lenlen; 139 while (lenlen1-- > 0) { 140 ptr[lenlen1] = len & 0xff; 141 len >>= 8; 142 } 143 } 144 return (lenlen + 1); 145 } 146 } 147 148 /* 149 * Write a header (tag and length fields). 150 * Tags are restricted to one byte tags (value <= 0x30) and the 151 * lenght field to 16-bit. All errors stop the encoding. 152 */ 153 enum asn_err 154 asn_put_header(struct asn_buf *b, u_char type, asn_len_t len) 155 { 156 u_int lenlen; 157 158 /* tag field */ 159 if ((type & ASN_TYPE_MASK) > 0x30) { 160 asn_error(NULL, "types > 0x30 not supported (%u)", 161 type & ASN_TYPE_MASK); 162 return (ASN_ERR_FAILED); 163 } 164 if (b->asn_len == 0) 165 return (ASN_ERR_EOBUF); 166 167 *b->asn_ptr++ = type; 168 b->asn_len--; 169 170 /* length field */ 171 if ((lenlen = asn_put_len(NULL, len)) == 0) 172 return (ASN_ERR_FAILED); 173 if (b->asn_len < lenlen) 174 return (ASN_ERR_EOBUF); 175 176 (void)asn_put_len(b->asn_ptr, len); 177 b->asn_ptr += lenlen; 178 b->asn_len -= lenlen; 179 return (ASN_ERR_OK); 180 } 181 182 183 /* 184 * This constructs a temporary sequence header with space for the maximum 185 * length field (three byte). Set the pointer that ptr points to to the 186 * start of the encoded header. This is used for a later call to 187 * asn_commit_header which will fix-up the length field and move the 188 * value if needed. All errors should stop the encoding. 189 */ 190 #define TEMP_LEN (1 + ASN_MAXLENLEN + 1) 191 enum asn_err 192 asn_put_temp_header(struct asn_buf *b, u_char type, u_char **ptr) 193 { 194 int ret; 195 196 if (b->asn_len < TEMP_LEN) 197 return (ASN_ERR_EOBUF); 198 *ptr = b->asn_ptr; 199 if ((ret = asn_put_header(b, type, ASN_MAXLEN)) == ASN_ERR_OK) 200 assert(b->asn_ptr == *ptr + TEMP_LEN); 201 return (ret); 202 } 203 enum asn_err 204 asn_commit_header(struct asn_buf *b, u_char *ptr, size_t *moved) 205 { 206 asn_len_t len; 207 u_int lenlen, shift; 208 209 /* compute length of encoded value without header */ 210 len = b->asn_ptr - (ptr + TEMP_LEN); 211 212 /* insert length. may not fail. */ 213 lenlen = asn_put_len(ptr + 1, len); 214 if (lenlen > TEMP_LEN - 1) 215 return (ASN_ERR_FAILED); 216 217 if (lenlen < TEMP_LEN - 1) { 218 /* shift value down */ 219 shift = (TEMP_LEN - 1) - lenlen; 220 memmove(ptr + 1 + lenlen, ptr + TEMP_LEN, len); 221 b->asn_ptr -= shift; 222 b->asn_len += shift; 223 if (moved != NULL) 224 *moved = shift; 225 } 226 return (ASN_ERR_OK); 227 } 228 #undef TEMP_LEN 229 230 /* 231 * BER integer. This may be used to get a signed 64 bit integer at maximum. 232 * The maximum length should be checked by the caller. This cannot overflow 233 * if the caller ensures that len is at maximum 8. 234 * 235 * <bytes> 236 */ 237 static enum asn_err 238 asn_get_real_integer(struct asn_buf *b, asn_len_t len, int64_t *vp) 239 { 240 uint64_t val; 241 int neg = 0; 242 enum asn_err err; 243 244 if (b->asn_len < len) { 245 asn_error(b, "truncated integer"); 246 return (ASN_ERR_EOBUF); 247 } 248 if (len == 0) { 249 asn_error(b, "zero-length integer"); 250 *vp = 0; 251 return (ASN_ERR_BADLEN); 252 } 253 err = ASN_ERR_OK; 254 if (len > 8) 255 err = ASN_ERR_RANGE; 256 else if (len > 1 && 257 ((*b->asn_cptr == 0x00 && (b->asn_cptr[1] & 0x80) == 0) || 258 (*b->asn_cptr == 0xff && (b->asn_cptr[1] & 0x80) == 0x80))) { 259 asn_error(b, "non-minimal integer"); 260 err = ASN_ERR_BADLEN; 261 } 262 263 if (*b->asn_cptr & 0x80) 264 neg = 1; 265 val = 0; 266 while (len--) { 267 val <<= 8; 268 val |= neg ? (u_char)~*b->asn_cptr : *b->asn_cptr; 269 b->asn_len--; 270 b->asn_cptr++; 271 } 272 if (neg) { 273 *vp = -(int64_t)val - 1; 274 } else 275 *vp = (int64_t)val; 276 return (err); 277 } 278 279 /* 280 * Write a signed integer with the given type. The caller has to ensure 281 * that the actual value is ok for this type. 282 */ 283 static enum asn_err 284 asn_put_real_integer(struct asn_buf *b, u_char type, int64_t ival) 285 { 286 int i, neg = 0; 287 # define OCTETS 8 288 u_char buf[OCTETS]; 289 uint64_t val; 290 enum asn_err ret; 291 292 if (ival < 0) { 293 /* this may fail if |INT64_MIN| > |INT64_MAX| and 294 * the value is between * INT64_MIN <= ival < -(INT64_MAX+1) */ 295 val = (uint64_t)-(ival + 1); 296 neg = 1; 297 } else 298 val = (uint64_t)ival; 299 300 /* split the value into octets */ 301 for (i = OCTETS - 1; i >= 0; i--) { 302 buf[i] = val & 0xff; 303 if (neg) 304 buf[i] = ~buf[i]; 305 val >>= 8; 306 } 307 /* no leading 9 zeroes or ones */ 308 for (i = 0; i < OCTETS - 1; i++) 309 if (!((buf[i] == 0xff && (buf[i + 1] & 0x80) != 0) || 310 (buf[i] == 0x00 && (buf[i + 1] & 0x80) == 0))) 311 break; 312 if ((ret = asn_put_header(b, type, OCTETS - i))) 313 return (ret); 314 if (OCTETS - (u_int)i > b->asn_len) 315 return (ASN_ERR_EOBUF); 316 317 while (i < OCTETS) { 318 *b->asn_ptr++ = buf[i++]; 319 b->asn_len--; 320 } 321 return (ASN_ERR_OK); 322 # undef OCTETS 323 } 324 325 326 /* 327 * The same for unsigned 64-bitters. Here we have the problem, that overflow 328 * can happen, because the value maybe 9 bytes long. In this case the 329 * first byte must be 0. 330 */ 331 static enum asn_err 332 asn_get_real_unsigned(struct asn_buf *b, asn_len_t len, uint64_t *vp) 333 { 334 enum asn_err err; 335 336 if (b->asn_len < len) { 337 asn_error(b, "truncated integer"); 338 return (ASN_ERR_EOBUF); 339 } 340 if (len == 0) { 341 asn_error(b, "zero-length integer"); 342 *vp = 0; 343 return (ASN_ERR_BADLEN); 344 } 345 err = ASN_ERR_OK; 346 *vp = 0; 347 if ((*b->asn_cptr & 0x80) || (len == 9 && *b->asn_cptr != 0)) { 348 /* negative integer or too larger */ 349 *vp = 0xffffffffffffffffULL; 350 err = ASN_ERR_RANGE; 351 } else if (len > 1 && 352 *b->asn_cptr == 0x00 && (b->asn_cptr[1] & 0x80) == 0) { 353 asn_error(b, "non-minimal unsigned"); 354 err = ASN_ERR_BADLEN; 355 } 356 357 while (len--) { 358 *vp = (*vp << 8) | *b->asn_cptr++; 359 b->asn_len--; 360 } 361 return (err); 362 } 363 364 365 /* 366 * Values with the msb on need 9 octets. 367 */ 368 static int 369 asn_put_real_unsigned(struct asn_buf *b, u_char type, uint64_t val) 370 { 371 int i; 372 # define OCTETS 9 373 u_char buf[OCTETS]; 374 enum asn_err ret; 375 376 /* split the value into octets */ 377 for (i = OCTETS - 1; i >= 0; i--) { 378 buf[i] = val & 0xff; 379 val >>= 8; 380 } 381 /* no leading 9 zeroes */ 382 for (i = 0; i < OCTETS - 1; i++) 383 if (!(buf[i] == 0x00 && (buf[i + 1] & 0x80) == 0)) 384 break; 385 if ((ret = asn_put_header(b, type, OCTETS - i))) 386 return (ret); 387 if (OCTETS - (u_int)i > b->asn_len) 388 return (ASN_ERR_EOBUF); 389 390 while (i < OCTETS) { 391 *b->asn_ptr++ = buf[i++]; 392 b->asn_len--; 393 } 394 #undef OCTETS 395 return (ASN_ERR_OK); 396 } 397 398 /* 399 * The ASN.1 INTEGER type is restricted to 32-bit signed by the SMI. 400 */ 401 enum asn_err 402 asn_get_integer_raw(struct asn_buf *b, asn_len_t len, int32_t *vp) 403 { 404 int64_t val; 405 enum asn_err ret; 406 407 if ((ret = asn_get_real_integer(b, len, &val)) == ASN_ERR_OK) { 408 if (len > 4) 409 ret = ASN_ERR_BADLEN; 410 else if (val > INT32_MAX || val < INT32_MIN) 411 /* may not happen */ 412 ret = ASN_ERR_RANGE; 413 *vp = (int32_t)val; 414 } 415 return (ret); 416 } 417 418 enum asn_err 419 asn_get_integer(struct asn_buf *b, int32_t *vp) 420 { 421 asn_len_t len; 422 u_char type; 423 enum asn_err err; 424 425 if ((err = asn_get_header(b, &type, &len)) != ASN_ERR_OK) 426 return (err); 427 if (type != ASN_TYPE_INTEGER) { 428 asn_error(b, "bad type for integer (%u)", type); 429 return (ASN_ERR_TAG); 430 } 431 432 return (asn_get_integer_raw(b, len, vp)); 433 } 434 435 enum asn_err 436 asn_put_integer(struct asn_buf *b, int32_t val) 437 { 438 return (asn_put_real_integer(b, ASN_TYPE_INTEGER, val)); 439 } 440 441 /* 442 * OCTETSTRING 443 * 444 * <0x04> <len> <data ...> 445 * 446 * Get an octetstring. noctets must point to the buffer size and on 447 * return will contain the size of the octetstring, regardless of the 448 * buffer size. 449 */ 450 enum asn_err 451 asn_get_octetstring_raw(struct asn_buf *b, asn_len_t len, u_char *octets, 452 u_int *noctets) 453 { 454 enum asn_err err = ASN_ERR_OK; 455 456 if (*noctets < len) { 457 asn_error(b, "octetstring truncated"); 458 err = ASN_ERR_RANGE; 459 } 460 if (b->asn_len < len) { 461 asn_error(b, "truncatet octetstring"); 462 return (ASN_ERR_EOBUF); 463 } 464 if (*noctets < len) 465 memcpy(octets, b->asn_cptr, *noctets); 466 else 467 memcpy(octets, b->asn_cptr, len); 468 *noctets = len; 469 b->asn_cptr += len; 470 b->asn_len -= len; 471 return (err); 472 } 473 474 enum asn_err 475 asn_get_octetstring(struct asn_buf *b, u_char *octets, u_int *noctets) 476 { 477 enum asn_err err; 478 u_char type; 479 asn_len_t len; 480 481 if ((err = asn_get_header(b, &type, &len)) != ASN_ERR_OK) 482 return (err); 483 if (type != ASN_TYPE_OCTETSTRING) { 484 asn_error(b, "bad type for octetstring (%u)", type); 485 return (ASN_ERR_TAG); 486 } 487 return (asn_get_octetstring_raw(b, len, octets, noctets)); 488 } 489 490 enum asn_err 491 asn_put_octetstring(struct asn_buf *b, const u_char *octets, u_int noctets) 492 { 493 enum asn_err ret; 494 495 if ((ret = asn_put_header(b, ASN_TYPE_OCTETSTRING, noctets)) != ASN_ERR_OK) 496 return (ret); 497 if (b->asn_len < noctets) 498 return (ASN_ERR_EOBUF); 499 500 memcpy(b->asn_ptr, octets, noctets); 501 b->asn_ptr += noctets; 502 b->asn_len -= noctets; 503 return (ASN_ERR_OK); 504 } 505 506 /* 507 * NULL 508 * 509 * <0x05> <0x00> 510 */ 511 enum asn_err 512 asn_get_null_raw(struct asn_buf *b, asn_len_t len) 513 { 514 if (len != 0) { 515 if (b->asn_len < len) { 516 asn_error(b, "truncated NULL"); 517 return (ASN_ERR_EOBUF); 518 } 519 asn_error(b, "bad length for NULL (%u)", len); 520 b->asn_len -= len; 521 b->asn_ptr += len; 522 return (ASN_ERR_BADLEN); 523 } 524 return (ASN_ERR_OK); 525 } 526 527 enum asn_err 528 asn_get_null(struct asn_buf *b) 529 { 530 u_char type; 531 asn_len_t len; 532 enum asn_err err; 533 534 if ((err = asn_get_header(b, &type, &len)) != ASN_ERR_OK) 535 return (err); 536 if (type != ASN_TYPE_NULL) { 537 asn_error(b, "bad type for NULL (%u)", type); 538 return (ASN_ERR_TAG); 539 } 540 return (asn_get_null_raw(b, len)); 541 } 542 543 enum asn_err 544 asn_put_null(struct asn_buf *b) 545 { 546 return (asn_put_header(b, ASN_TYPE_NULL, 0)); 547 } 548 549 enum asn_err 550 asn_put_exception(struct asn_buf *b, u_int except) 551 { 552 return (asn_put_header(b, ASN_CLASS_CONTEXT | except, 0)); 553 } 554 555 /* 556 * OBJID 557 * 558 * <0x06> <len> <subid...> 559 */ 560 enum asn_err 561 asn_get_objid_raw(struct asn_buf *b, asn_len_t len, struct asn_oid *oid) 562 { 563 asn_subid_t subid; 564 enum asn_err err; 565 566 if (b->asn_len < len) { 567 asn_error(b, "truncated OBJID"); 568 return (ASN_ERR_EOBUF); 569 } 570 oid->len = 0; 571 if (len == 0) { 572 asn_error(b, "short OBJID"); 573 oid->subs[oid->len++] = 0; 574 oid->subs[oid->len++] = 0; 575 return (ASN_ERR_BADLEN); 576 } 577 err = ASN_ERR_OK; 578 while (len != 0) { 579 if (oid->len == ASN_MAXOIDLEN) { 580 asn_error(b, "OID too long (%u)", oid->len); 581 b->asn_cptr += len; 582 b->asn_len -= len; 583 return (ASN_ERR_BADLEN); 584 } 585 subid = 0; 586 do { 587 if (len == 0) { 588 asn_error(b, "unterminated subid"); 589 return (ASN_ERR_EOBUF); 590 } 591 if (subid > (ASN_MAXID >> 7)) { 592 asn_error(b, "OBID subid too larger"); 593 err = ASN_ERR_RANGE; 594 } 595 subid = (subid << 7) | (*b->asn_cptr & 0x7f); 596 len--; 597 b->asn_len--; 598 } while (*b->asn_cptr++ & 0x80); 599 if (oid->len == 0) { 600 if (subid < 80) { 601 oid->subs[oid->len++] = subid / 40; 602 oid->subs[oid->len++] = subid % 40; 603 } else { 604 oid->subs[oid->len++] = 2; 605 oid->subs[oid->len++] = subid - 80; 606 } 607 } else { 608 oid->subs[oid->len++] = subid; 609 } 610 } 611 return (err); 612 613 } 614 615 enum asn_err 616 asn_get_objid(struct asn_buf *b, struct asn_oid *oid) 617 { 618 u_char type; 619 asn_len_t len; 620 enum asn_err err; 621 622 if ((err = asn_get_header(b, &type, &len)) != ASN_ERR_OK) 623 return (err); 624 if (type != ASN_TYPE_OBJID) { 625 asn_error(b, "bad type for OBJID (%u)", type); 626 return (ASN_ERR_TAG); 627 } 628 return (asn_get_objid_raw(b, len, oid)); 629 } 630 631 enum asn_err 632 asn_put_objid(struct asn_buf *b, const struct asn_oid *oid) 633 { 634 asn_subid_t first, sub; 635 enum asn_err err, err1; 636 u_int i, oidlen; 637 asn_len_t len; 638 639 err = ASN_ERR_OK; 640 if (oid->len == 0) { 641 /* illegal */ 642 asn_error(NULL, "short oid"); 643 err = ASN_ERR_RANGE; 644 first = 0; 645 oidlen = 2; 646 } else if (oid->len == 1) { 647 /* illegal */ 648 asn_error(b, "short oid"); 649 if (oid->subs[0] > 2) 650 asn_error(NULL, "oid[0] too large (%u)", oid->subs[0]); 651 err = ASN_ERR_RANGE; 652 first = oid->subs[0] * 40; 653 oidlen = 2; 654 } else { 655 if (oid->len > ASN_MAXOIDLEN) { 656 asn_error(NULL, "oid too long %u", oid->len); 657 err = ASN_ERR_RANGE; 658 } 659 if (oid->subs[0] > 2 || 660 (oid->subs[0] < 2 && oid->subs[1] >= 40)) { 661 asn_error(NULL, "oid out of range (%u,%u)", 662 oid->subs[0], oid->subs[1]); 663 err = ASN_ERR_RANGE; 664 } 665 first = 40 * oid->subs[0] + oid->subs[1]; 666 oidlen = oid->len; 667 } 668 len = 0; 669 for (i = 1; i < oidlen; i++) { 670 sub = (i == 1) ? first : oid->subs[i]; 671 if (sub > ASN_MAXID) { 672 asn_error(NULL, "oid subid too large"); 673 err = ASN_ERR_RANGE; 674 } 675 len += (sub <= 0x7f) ? 1 676 : (sub <= 0x3fff) ? 2 677 : (sub <= 0x1fffff) ? 3 678 : (sub <= 0xfffffff) ? 4 679 : 5; 680 } 681 if ((err1 = asn_put_header(b, ASN_TYPE_OBJID, len)) != ASN_ERR_OK) 682 return (err1); 683 if (b->asn_len < len) 684 return (ASN_ERR_EOBUF); 685 686 for (i = 1; i < oidlen; i++) { 687 sub = (i == 1) ? first : oid->subs[i]; 688 if (sub <= 0x7f) { 689 *b->asn_ptr++ = sub; 690 b->asn_len--; 691 } else if (sub <= 0x3fff) { 692 *b->asn_ptr++ = (sub >> 7) | 0x80; 693 *b->asn_ptr++ = sub & 0x7f; 694 b->asn_len -= 2; 695 } else if (sub <= 0x1fffff) { 696 *b->asn_ptr++ = (sub >> 14) | 0x80; 697 *b->asn_ptr++ = ((sub >> 7) & 0x7f) | 0x80; 698 *b->asn_ptr++ = sub & 0x7f; 699 b->asn_len -= 3; 700 } else if (sub <= 0xfffffff) { 701 *b->asn_ptr++ = (sub >> 21) | 0x80; 702 *b->asn_ptr++ = ((sub >> 14) & 0x7f) | 0x80; 703 *b->asn_ptr++ = ((sub >> 7) & 0x7f) | 0x80; 704 *b->asn_ptr++ = sub & 0x7f; 705 b->asn_len -= 4; 706 } else { 707 *b->asn_ptr++ = (sub >> 28) | 0x80; 708 *b->asn_ptr++ = ((sub >> 21) & 0x7f) | 0x80; 709 *b->asn_ptr++ = ((sub >> 14) & 0x7f) | 0x80; 710 *b->asn_ptr++ = ((sub >> 7) & 0x7f) | 0x80; 711 *b->asn_ptr++ = sub & 0x7f; 712 b->asn_len -= 5; 713 } 714 } 715 return (err); 716 } 717 /* 718 * SEQUENCE header 719 * 720 * <0x10|0x20> <len> <data...> 721 */ 722 enum asn_err 723 asn_get_sequence(struct asn_buf *b, asn_len_t *len) 724 { 725 u_char type; 726 enum asn_err err; 727 728 if ((err = asn_get_header(b, &type, len)) != ASN_ERR_OK) 729 return (err); 730 if (type != (ASN_TYPE_SEQUENCE|ASN_TYPE_CONSTRUCTED)) { 731 asn_error(b, "bad sequence type %u", type); 732 return (ASN_ERR_TAG); 733 } 734 if (*len > b->asn_len) { 735 asn_error(b, "truncated sequence"); 736 return (ASN_ERR_EOBUF); 737 } 738 return (ASN_ERR_OK); 739 } 740 741 /* 742 * Application types 743 * 744 * 0x40 4 MSB 2MSB 2LSB LSB 745 */ 746 enum asn_err 747 asn_get_ipaddress_raw(struct asn_buf *b, asn_len_t len, u_char *addr) 748 { 749 u_int i; 750 751 if (b->asn_len < len) { 752 asn_error(b, "truncated ip-address"); 753 return (ASN_ERR_EOBUF); 754 } 755 if (len < 4) { 756 asn_error(b, "short length for ip-Address %u", len); 757 for (i = 0; i < len; i++) 758 *addr++ = *b->asn_cptr++; 759 while (i++ < len) 760 *addr++ = 0; 761 b->asn_len -= len; 762 return (ASN_ERR_BADLEN); 763 } 764 for (i = 0; i < 4; i++) 765 *addr++ = *b->asn_cptr++; 766 b->asn_cptr += len - 4; 767 b->asn_len -= len; 768 return (ASN_ERR_OK); 769 } 770 771 enum asn_err 772 asn_get_ipaddress(struct asn_buf *b, u_char *addr) 773 { 774 u_char type; 775 asn_len_t len; 776 enum asn_err err; 777 778 if ((err = asn_get_header(b, &type, &len)) != ASN_ERR_OK) 779 return (err); 780 if (type != (ASN_CLASS_APPLICATION|ASN_APP_IPADDRESS)) { 781 asn_error(b, "bad type for ip-address %u", type); 782 return (ASN_ERR_TAG); 783 } 784 return (asn_get_ipaddress_raw(b, len, addr)); 785 } 786 787 enum asn_err 788 asn_put_ipaddress(struct asn_buf *b, const u_char *addr) 789 { 790 enum asn_err err; 791 792 if ((err = asn_put_header(b, ASN_CLASS_APPLICATION|ASN_APP_IPADDRESS, 793 4)) != ASN_ERR_OK) 794 return (err); 795 if (b->asn_len < 4) 796 return (ASN_ERR_EOBUF); 797 798 memcpy(b->asn_ptr, addr, 4); 799 b->asn_ptr += 4; 800 b->asn_len -= 4; 801 return (ASN_ERR_OK); 802 } 803 804 805 /* 806 * UNSIGNED32 807 * 808 * 0x42|0x41 <len> ... 809 */ 810 enum asn_err 811 asn_get_uint32_raw(struct asn_buf *b, asn_len_t len, uint32_t *vp) 812 { 813 uint64_t v; 814 enum asn_err err; 815 816 if ((err = asn_get_real_unsigned(b, len, &v)) == ASN_ERR_OK) { 817 if (len > 5) { 818 asn_error(b, "uint32 too long %u", len); 819 err = ASN_ERR_BADLEN; 820 } else if (v > UINT32_MAX) { 821 asn_error(b, "uint32 too large %llu", v); 822 err = ASN_ERR_RANGE; 823 } 824 *vp = (uint32_t)v; 825 } 826 return (err); 827 } 828 829 enum asn_err 830 asn_put_uint32(struct asn_buf *b, u_char type, uint32_t val) 831 { 832 uint64_t v = val; 833 834 return (asn_put_real_unsigned(b, ASN_CLASS_APPLICATION|type, v)); 835 } 836 837 /* 838 * COUNTER64 839 * 0x46 <len> ... 840 */ 841 enum asn_err 842 asn_get_counter64_raw(struct asn_buf *b, asn_len_t len, uint64_t *vp) 843 { 844 return (asn_get_real_unsigned(b, len, vp)); 845 } 846 847 enum asn_err 848 asn_put_counter64(struct asn_buf *b, uint64_t val) 849 { 850 return (asn_put_real_unsigned(b, 851 ASN_CLASS_APPLICATION | ASN_APP_COUNTER64, val)); 852 } 853 854 /* 855 * TimeTicks 856 * 0x43 <len> ... 857 */ 858 enum asn_err 859 asn_get_timeticks(struct asn_buf *b, uint32_t *vp) 860 { 861 asn_len_t len; 862 u_char type; 863 enum asn_err err; 864 865 if ((err = asn_get_header(b, &type, &len)) != ASN_ERR_OK) 866 return (err); 867 if (type != (ASN_CLASS_APPLICATION|ASN_APP_TIMETICKS)) { 868 asn_error(b, "bad type for timeticks %u", type); 869 return (ASN_ERR_TAG); 870 } 871 return (asn_get_uint32_raw(b, len, vp)); 872 } 873 874 enum asn_err 875 asn_put_timeticks(struct asn_buf *b, uint32_t val) 876 { 877 uint64_t v = val; 878 879 return (asn_put_real_unsigned(b, 880 ASN_CLASS_APPLICATION | ASN_APP_TIMETICKS, v)); 881 } 882 883 /* 884 * Construct a new OID by taking a range of sub ids of the original oid. 885 */ 886 void 887 asn_slice_oid(struct asn_oid *dest, const struct asn_oid *src, 888 u_int from, u_int to) 889 { 890 if (from >= to) { 891 dest->len = 0; 892 return; 893 } 894 dest->len = to - from; 895 memcpy(dest->subs, &src->subs[from], dest->len * sizeof(dest->subs[0])); 896 } 897 898 /* 899 * Append from to to 900 */ 901 void 902 asn_append_oid(struct asn_oid *to, const struct asn_oid *from) 903 { 904 memcpy(&to->subs[to->len], &from->subs[0], 905 from->len * sizeof(from->subs[0])); 906 to->len += from->len; 907 } 908 909 /* 910 * Skip a value 911 */ 912 enum asn_err 913 asn_skip(struct asn_buf *b, asn_len_t len) 914 { 915 if (b->asn_len < len) 916 return (ASN_ERR_EOBUF); 917 b->asn_cptr += len; 918 b->asn_len -= len; 919 return (ASN_ERR_OK); 920 } 921 922 /* 923 * Add a padding 924 */ 925 enum asn_err 926 asn_pad(struct asn_buf *b, asn_len_t len) 927 { 928 if (b->asn_len < len) 929 return (ASN_ERR_EOBUF); 930 b->asn_ptr += len; 931 b->asn_len -= len; 932 933 return (ASN_ERR_OK); 934 } 935 936 /* 937 * Compare two OIDs. 938 * 939 * o1 < o2 : -1 940 * o1 > o2 : +1 941 * o1 = o2 : 0 942 */ 943 int 944 asn_compare_oid(const struct asn_oid *o1, const struct asn_oid *o2) 945 { 946 u_long i; 947 948 for (i = 0; i < o1->len && i < o2->len; i++) { 949 if (o1->subs[i] < o2->subs[i]) 950 return (-1); 951 if (o1->subs[i] > o2->subs[i]) 952 return (+1); 953 } 954 if (o1->len < o2->len) 955 return (-1); 956 if (o1->len > o2->len) 957 return (+1); 958 return (0); 959 } 960 961 /* 962 * Check whether an OID is a sub-string of another OID. 963 */ 964 int 965 asn_is_suboid(const struct asn_oid *o1, const struct asn_oid *o2) 966 { 967 u_long i; 968 969 for (i = 0; i < o1->len; i++) 970 if (i >= o2->len || o1->subs[i] != o2->subs[i]) 971 return (0); 972 return (1); 973 } 974 975 /* 976 * Put a string representation of an oid into a user buffer. This buffer 977 * is assumed to be at least ASN_OIDSTRLEN characters long. 978 * 979 * sprintf is assumed not to fail here. 980 */ 981 char * 982 asn_oid2str_r(const struct asn_oid *oid, char *buf) 983 { 984 u_int len, i; 985 char *ptr; 986 987 if ((len = oid->len) > ASN_MAXOIDLEN) 988 len = ASN_MAXOIDLEN; 989 buf[0] = '\0'; 990 for (i = 0, ptr = buf; i < len; i++) { 991 if (i > 0) 992 *ptr++ = '.'; 993 ptr += sprintf(ptr, "%u", oid->subs[i]); 994 } 995 return (buf); 996 } 997 998 /* 999 * Make a string from an OID in a private buffer. 1000 */ 1001 char * 1002 asn_oid2str(const struct asn_oid *oid) 1003 { 1004 static char str[ASN_OIDSTRLEN]; 1005 1006 return (asn_oid2str_r(oid, str)); 1007 } 1008 1009 1010 static void 1011 asn_error_func(const struct asn_buf *b, const char *err, ...) 1012 { 1013 va_list ap; 1014 u_long i; 1015 1016 fprintf(stderr, "ASN.1: "); 1017 va_start(ap, err); 1018 vfprintf(stderr, err, ap); 1019 va_end(ap); 1020 1021 if (b != NULL) { 1022 fprintf(stderr, " at"); 1023 for (i = 0; b->asn_len > i; i++) 1024 fprintf(stderr, " %02x", b->asn_cptr[i]); 1025 } 1026 fprintf(stderr, "\n"); 1027 } 1028