contrib/bsnmp/lib/asn1.c

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