2 * Copyright (c) 1997 - 2007 Kungliga Tekniska Högskolan
3 * (Royal Institute of Technology, Stockholm, Sweden).
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * 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.
17 * 3. Neither the name of the Institute nor the names of its contributors
18 * may be used to endorse or promote products derived from this software
19 * without specific prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
37 * All decoding functions take a pointer `p' to first position in
38 * which to read, from the left, `len' which means the maximum number
39 * of characters we are able to read, `ret' were the value will be
40 * returned and `size' where the number of used bytes is stored.
41 * Either 0 or an error code is returned.
45 der_get_unsigned (const unsigned char *p
, size_t len
,
46 unsigned *ret
, size_t *size
)
51 if (len
== sizeof(val
) + 1 && p
[0] == 0)
53 else if (len
> sizeof(val
))
57 val
= val
* 256 + *p
++;
59 if(size
) *size
= oldlen
;
64 der_get_unsigned64 (const unsigned char *p
, size_t len
,
65 uint64_t *ret
, size_t *size
)
70 if (len
== sizeof(val
) + 1 && p
[0] == 0)
72 else if (len
> sizeof(val
))
76 val
= val
* 256 + *p
++;
78 if(size
) *size
= oldlen
;
83 der_get_integer (const unsigned char *p
, size_t len
,
84 int *ret
, size_t *size
)
89 if (len
> sizeof(val
))
93 val
= (signed char)*p
++;
95 val
= val
* 256 + *p
++;
98 if(size
) *size
= oldlen
;
103 der_get_integer64 (const unsigned char *p
, size_t len
,
104 int64_t *ret
, size_t *size
)
109 if (len
> sizeof(val
))
113 val
= (signed char)*p
++;
115 val
= val
* 256 + *p
++;
118 if(size
) *size
= oldlen
;
124 der_get_length (const unsigned char *p
, size_t len
,
125 size_t *val
, size_t *size
)
142 *val
= ASN1_INDEFINITE
;
149 e
= der_get_unsigned (p
, v
, &tmp
, &l
);
152 if(size
) *size
= l
+ 1;
158 der_get_boolean(const unsigned char *p
, size_t len
, int *data
, size_t *size
)
171 der_get_general_string (const unsigned char *p
, size_t len
,
172 heim_general_string
*str
, size_t *size
)
174 const unsigned char *p1
;
177 p1
= memchr(p
, 0, len
);
180 * Allow trailing NULs. We allow this since MIT Kerberos sends
181 * an strings in the NEED_PREAUTH case that includes a
184 while ((size_t)(p1
- p
) < len
&& *p1
== '\0')
186 if ((size_t)(p1
- p
) != len
) {
188 return ASN1_BAD_CHARACTER
;
193 return ASN1_BAD_LENGTH
;
196 *str
= s
= malloc (len
+ 1);
202 if(size
) *size
= len
;
207 der_get_utf8string (const unsigned char *p
, size_t len
,
208 heim_utf8_string
*str
, size_t *size
)
210 return der_get_general_string(p
, len
, str
, size
);
213 #define gen_data_zero(_data) \
214 do { (_data)->length = 0; (_data)->data = NULL; } while(0)
217 der_get_printable_string(const unsigned char *p
, size_t len
,
218 heim_printable_string
*str
, size_t *size
)
222 return ASN1_BAD_LENGTH
;
225 str
->data
= malloc(len
+ 1);
226 if (str
->data
== NULL
) {
230 memcpy(str
->data
, p
, len
);
231 ((char *)str
->data
)[len
] = '\0';
232 if(size
) *size
= len
;
237 der_get_ia5_string(const unsigned char *p
, size_t len
,
238 heim_ia5_string
*str
, size_t *size
)
240 return der_get_printable_string(p
, len
, str
, size
);
244 der_get_bmp_string (const unsigned char *p
, size_t len
,
245 heim_bmp_string
*data
, size_t *size
)
251 return ASN1_BAD_FORMAT
;
253 data
->length
= len
/ 2;
254 if (data
->length
> UINT_MAX
/sizeof(data
->data
[0])) {
258 data
->data
= malloc(data
->length
* sizeof(data
->data
[0]));
259 if (data
->data
== NULL
&& data
->length
!= 0) {
264 for (i
= 0; i
< data
->length
; i
++) {
265 data
->data
[i
] = (p
[0] << 8) | p
[1];
267 /* check for NUL in the middle of the string */
268 if (data
->data
[i
] == 0 && i
!= (data
->length
- 1)) {
271 return ASN1_BAD_CHARACTER
;
274 if (size
) *size
= len
;
280 der_get_universal_string (const unsigned char *p
, size_t len
,
281 heim_universal_string
*data
, size_t *size
)
287 return ASN1_BAD_FORMAT
;
289 data
->length
= len
/ 4;
290 if (data
->length
> UINT_MAX
/sizeof(data
->data
[0])) {
294 data
->data
= malloc(data
->length
* sizeof(data
->data
[0]));
295 if (data
->data
== NULL
&& data
->length
!= 0) {
300 for (i
= 0; i
< data
->length
; i
++) {
301 data
->data
[i
] = (p
[0] << 24) | (p
[1] << 16) | (p
[2] << 8) | p
[3];
303 /* check for NUL in the middle of the string */
304 if (data
->data
[i
] == 0 && i
!= (data
->length
- 1)) {
307 return ASN1_BAD_CHARACTER
;
310 if (size
) *size
= len
;
315 der_get_visible_string (const unsigned char *p
, size_t len
,
316 heim_visible_string
*str
, size_t *size
)
318 return der_get_general_string(p
, len
, str
, size
);
322 der_get_octet_string (const unsigned char *p
, size_t len
,
323 heim_octet_string
*data
, size_t *size
)
326 data
->data
= malloc(len
);
327 if (data
->data
== NULL
&& data
->length
!= 0)
329 memcpy (data
->data
, p
, len
);
330 if(size
) *size
= len
;
335 der_get_octet_string_ber (const unsigned char *p
, size_t len
,
336 heim_octet_string
*data
, size_t *size
)
341 unsigned int tag
, depth
= 0;
342 size_t l
, datalen
, oldlen
= len
;
348 e
= der_get_tag (p
, len
, &cls
, &type
, &tag
, &l
);
350 if (cls
!= ASN1_C_UNIV
) {
354 if (type
== PRIM
&& tag
== UT_EndOfContent
) {
359 if (tag
!= UT_OctetString
) {
366 e
= der_get_length (p
, len
, &datalen
, &l
);
377 ptr
= realloc(data
->data
, data
->length
+ datalen
);
383 memcpy(((unsigned char *)data
->data
) + data
->length
, p
, datalen
);
384 data
->length
+= datalen
;
392 return ASN1_INDEF_OVERRUN
;
393 if(size
) *size
= oldlen
- len
;
404 der_get_heim_integer (const unsigned char *p
, size_t len
,
405 heim_integer
*data
, size_t *size
)
427 data
->data
= malloc(data
->length
);
428 if (data
->data
== NULL
) {
434 q
= &((unsigned char*)data
->data
)[data
->length
- 1];
435 p
+= data
->length
- 1;
436 while (q
>= (unsigned char*)data
->data
) {
451 data
->data
= malloc(data
->length
);
452 if (data
->data
== NULL
&& data
->length
!= 0) {
458 memcpy(data
->data
, p
, data
->length
);
466 generalizedtime2time (const char *s
, time_t *t
)
470 memset(&tm
, 0, sizeof(tm
));
471 if (sscanf (s
, "%04d%02d%02d%02d%02d%02dZ",
472 &tm
.tm_year
, &tm
.tm_mon
, &tm
.tm_mday
, &tm
.tm_hour
,
473 &tm
.tm_min
, &tm
.tm_sec
) != 6) {
474 if (sscanf (s
, "%02d%02d%02d%02d%02d%02dZ",
475 &tm
.tm_year
, &tm
.tm_mon
, &tm
.tm_mday
, &tm
.tm_hour
,
476 &tm
.tm_min
, &tm
.tm_sec
) != 6)
477 return ASN1_BAD_TIMEFORMAT
;
485 *t
= _der_timegm (&tm
);
490 der_get_time (const unsigned char *p
, size_t len
,
491 time_t *data
, size_t *size
)
496 if (len
> len
+ 1 || len
== 0)
497 return ASN1_BAD_LENGTH
;
499 times
= malloc(len
+ 1);
502 memcpy(times
, p
, len
);
504 e
= generalizedtime2time(times
, data
);
506 if(size
) *size
= len
;
511 der_get_generalized_time (const unsigned char *p
, size_t len
,
512 time_t *data
, size_t *size
)
514 return der_get_time(p
, len
, data
, size
);
518 der_get_utctime (const unsigned char *p
, size_t len
,
519 time_t *data
, size_t *size
)
521 return der_get_time(p
, len
, data
, size
);
525 der_get_oid (const unsigned char *p
, size_t len
,
526 heim_oid
*data
, size_t *size
)
535 return ASN1_BAD_LENGTH
;
537 if (len
+ 1 > UINT_MAX
/sizeof(data
->components
[0]))
540 data
->components
= malloc((len
+ 1) * sizeof(data
->components
[0]));
541 if (data
->components
== NULL
)
543 data
->components
[0] = (*p
) / 40;
544 data
->components
[1] = (*p
) % 40;
547 for (n
= 2; len
> 0; ++n
) {
552 u1
= u
* 128 + (*p
++ % 128);
553 /* check that we don't overflow the element */
559 } while (len
> 0 && p
[-1] & 0x80);
560 data
->components
[n
] = u
;
562 if (n
> 2 && p
[-1] & 0x80) {
573 der_get_tag (const unsigned char *p
, size_t len
,
574 Der_class
*cls
, Der_type
*type
,
575 unsigned int *tag
, size_t *size
)
580 *cls
= (Der_class
)(((*p
) >> 6) & 0x03);
581 *type
= (Der_type
)(((*p
) >> 5) & 0x01);
585 unsigned int continuation
;
591 continuation
= *p
& 128;
592 tag1
= *tag
* 128 + (*p
% 128);
593 /* check that we don't overflow the tag */
595 return ASN1_OVERFLOW
;
598 } while(continuation
);
600 if(size
) *size
= ret
;
605 der_match_tag (const unsigned char *p
, size_t len
,
606 Der_class cls
, Der_type type
,
607 unsigned int tag
, size_t *size
)
612 e
= der_match_tag2(p
, len
, cls
, &thistype
, tag
, size
);
614 if (thistype
!= type
) return ASN1_BAD_ID
;
619 der_match_tag2 (const unsigned char *p
, size_t len
,
620 Der_class cls
, Der_type
*type
,
621 unsigned int tag
, size_t *size
)
625 unsigned int thistag
;
628 e
= der_get_tag (p
, len
, &thisclass
, type
, &thistag
, &l
);
630 if (cls
!= thisclass
)
633 return ASN1_MISPLACED_FIELD
;
635 return ASN1_MISSING_FIELD
;
641 der_match_tag_and_length (const unsigned char *p
, size_t len
,
642 Der_class cls
, Der_type
*type
, unsigned int tag
,
643 size_t *length_ret
, size_t *size
)
648 e
= der_match_tag2 (p
, len
, cls
, type
, tag
, &l
);
653 e
= der_get_length (p
, len
, length_ret
, &l
);
655 if(size
) *size
= ret
+ l
;
662 * Old versions of DCE was based on a very early beta of the MIT code,
663 * which used MAVROS for ASN.1 encoding. MAVROS had the interesting
664 * feature that it encoded data in the forward direction, which has
665 * it's problems, since you have no idea how long the data will be
666 * until after you're done. MAVROS solved this by reserving one byte
667 * for length, and later, if the actual length was longer, it reverted
668 * to indefinite, BER style, lengths. The version of MAVROS used by
669 * the DCE people could apparently generate correct X.509 DER encodings, and
670 * did this by making space for the length after encoding, but
671 * unfortunately this feature wasn't used with Kerberos.
675 _heim_fix_dce(size_t reallen
, size_t *len
)
677 if(reallen
== ASN1_INDEFINITE
)
686 der_get_bit_string (const unsigned char *p
, size_t len
,
687 heim_bit_string
*data
, size_t *size
)
692 return ASN1_BAD_FORMAT
;
693 if (len
- 1 == 0 && p
[0] != 0)
694 return ASN1_BAD_FORMAT
;
695 /* check if any of the three upper bits are set
696 * any of them will cause a interger overrun */
697 if ((len
- 1) >> (sizeof(len
) * 8 - 3))
700 * If there is data to copy, do that now.
703 data
->length
= (len
- 1) * 8;
704 data
->data
= malloc(len
- 1);
705 if (data
->data
== NULL
)
707 memcpy (data
->data
, p
+ 1, len
- 1);
708 data
->length
-= p
[0];
713 if(size
) *size
= len
;