xref: /freebsd/contrib/bsnmp/lib/asn1.c (revision f6a3b357e9be4c6423c85eff9a847163a0d307c8)
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