2 * Copyright (c) 1997-2005 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
39 * All encoding functions take a pointer `p' to first position in
40 * which to write, from the right, `len' which means the maximum
41 * number of characters we are able to write. The function returns
42 * the number of characters written in `size' (if non-NULL).
43 * The return value is 0 or an error.
47 der_put_unsigned (unsigned char *p
, size_t len
, const unsigned *v
, size_t *size
)
49 unsigned char *base
= p
;
55 while (len
> 0 && val
) {
81 der_put_unsigned64 (unsigned char *p
, size_t len
, const uint64_t *v
, size_t *size
)
83 unsigned char *base
= p
;
89 while (len
> 0 && val
) {
106 return ASN1_OVERFLOW
;
115 der_put_integer (unsigned char *p
, size_t len
, const int *v
, size_t *size
)
117 unsigned char *base
= p
;
125 return ASN1_OVERFLOW
;
132 return ASN1_OVERFLOW
;
140 return ASN1_OVERFLOW
;
147 return ASN1_OVERFLOW
;
157 der_put_integer64 (unsigned char *p
, size_t len
, const int64_t *v
, size_t *size
)
159 unsigned char *base
= p
;
167 return ASN1_OVERFLOW
;
174 return ASN1_OVERFLOW
;
182 return ASN1_OVERFLOW
;
189 return ASN1_OVERFLOW
;
200 der_put_length (unsigned char *p
, size_t len
, size_t val
, size_t *size
)
206 return ASN1_OVERFLOW
;
217 return ASN1_OVERFLOW
;
231 der_put_boolean(unsigned char *p
, size_t len
, const int *data
, size_t *size
)
236 return ASN1_OVERFLOW
;
246 der_put_general_string (unsigned char *p
, size_t len
,
247 const heim_general_string
*str
, size_t *size
)
251 assert(p
!= NULL
&& str
!= NULL
&& *str
!= NULL
&& size
!= NULL
);
255 return ASN1_OVERFLOW
;
257 memcpy (p
+1, *str
, slen
);
263 der_put_utf8string (unsigned char *p
, size_t len
,
264 const heim_utf8_string
*str
, size_t *size
)
266 return der_put_general_string(p
, len
, str
, size
);
270 der_put_printable_string (unsigned char *p
, size_t len
,
271 const heim_printable_string
*str
, size_t *size
)
273 return der_put_octet_string(p
, len
, str
, size
);
277 der_put_ia5_string (unsigned char *p
, size_t len
,
278 const heim_ia5_string
*str
, size_t *size
)
280 return der_put_octet_string(p
, len
, str
, size
);
284 der_put_bmp_string (unsigned char *p
, size_t len
,
285 const heim_bmp_string
*data
, size_t *size
)
289 assert(p
!= NULL
&& data
!= NULL
);
294 if (len
/ 2 < data
->length
)
295 return ASN1_OVERFLOW
;
296 p
-= data
->length
* 2;
297 for (i
= 0; i
< data
->length
; i
++) {
298 p
[1] = (data
->data
[i
] >> 8) & 0xff;
299 p
[2] = data
->data
[i
] & 0xff;
302 if (size
) *size
= data
->length
* 2;
307 der_put_universal_string (unsigned char *p
, size_t len
,
308 const heim_universal_string
*data
, size_t *size
)
315 if (len
/ 4 < data
->length
)
316 return ASN1_OVERFLOW
;
317 p
-= data
->length
* 4;
318 for (i
= 0; i
< data
->length
; i
++) {
319 p
[1] = (data
->data
[i
] >> 24) & 0xff;
320 p
[2] = (data
->data
[i
] >> 16) & 0xff;
321 p
[3] = (data
->data
[i
] >> 8) & 0xff;
322 p
[4] = data
->data
[i
] & 0xff;
325 if (size
) *size
= data
->length
* 4;
330 der_put_visible_string (unsigned char *p
, size_t len
,
331 const heim_visible_string
*str
, size_t *size
)
333 return der_put_general_string(p
, len
, str
, size
);
337 der_put_octet_string (unsigned char *p
, size_t len
,
338 const heim_octet_string
*data
, size_t *size
)
340 assert(p
!= NULL
&& data
!= NULL
&& size
!= NULL
);
343 if (len
< data
->length
)
344 return ASN1_OVERFLOW
;
346 memcpy (p
+1, data
->data
, data
->length
);
347 *size
= data
->length
;
352 der_put_heim_integer (unsigned char *p
, size_t len
,
353 const heim_integer
*data
, size_t *size
)
363 if (data
->length
== 0) {
365 return ASN1_OVERFLOW
;
371 if (len
< data
->length
)
372 return ASN1_OVERFLOW
;
374 assert(data
->data
!= NULL
);
378 if (data
->negative
) {
381 for (i
= data
->length
- 1, carry
= 1; i
>= 0; i
--) {
389 return ASN1_OVERFLOW
;
396 memcpy(p
+ 1, buf
, data
->length
);
400 return ASN1_OVERFLOW
;
407 *size
= data
->length
+ hibitset
;
412 der_put_generalized_time (unsigned char *p
, size_t len
,
413 const time_t *data
, size_t *size
)
419 e
= _heim_time2generalizedtime (*data
, &k
, 1);
422 e
= der_put_octet_string(p
, len
, &k
, &l
);
432 der_put_utctime (unsigned char *p
, size_t len
,
433 const time_t *data
, size_t *size
)
439 e
= _heim_time2generalizedtime (*data
, &k
, 0);
442 e
= der_put_octet_string(p
, len
, &k
, &l
);
452 der_put_oid (unsigned char *p
, size_t len
,
453 const heim_oid
*data
, size_t *size
)
455 unsigned char *base
= p
;
458 for (n
= data
->length
- 1; n
>= 2; --n
) {
459 unsigned u
= data
->components
[n
];
462 return ASN1_OVERFLOW
;
468 return ASN1_OVERFLOW
;
469 *p
-- = 128 + u
% 128;
475 return ASN1_OVERFLOW
;
476 *p
-- = 40 * data
->components
[0] + data
->components
[1];
482 * Output a copy of the DER TLV at `p' with a different outermost tag.
484 * This is used in the implementation of IMPLICIT tags in generated decoder
488 der_replace_tag(const unsigned char *p
, size_t len
,
489 unsigned char **out
, size_t *outlen
,
490 Der_class
class, Der_type type
,
493 Der_class found_class
;
495 unsigned int found_tag
;
496 size_t payload_len
, l
, tag_len
, len_len
;
499 assert(p
!= NULL
&& out
!= NULL
&& outlen
!= NULL
);
501 e
= der_get_tag(p
, len
, &found_class
, &found_type
, &found_tag
, &l
);
504 if (found_type
!= type
)
505 return ASN1_TYPE_MISMATCH
;
506 /* We don't care what found_class and found_tag are though */
507 tag_len
= der_length_tag(tag
);
510 e
= der_get_length(p
, len
, &payload_len
, &len_len
);
513 if (payload_len
> len
)
514 return ASN1_OVERFLOW
;
516 * `p' now points at the payload; `*out' + the length of the tag points at
517 * where we should copy the DER length and the payload.
519 if ((*out
= malloc(*outlen
= tag_len
+ len_len
+ payload_len
)) == NULL
)
521 memcpy(*out
+ tag_len
, p
, len_len
+ payload_len
);
523 /* Put the new tag */
524 e
= der_put_tag(*out
+ tag_len
- 1, tag_len
, class, type
, tag
, &l
);
528 return ASN1_OVERFLOW
;
534 der_encode_implicit(unsigned char *p
, size_t len
,
535 asn1_generic_encoder_f encoder
,
536 void *obj
, size_t *size
,
538 unsigned int ttag
, Der_class iclass
, unsigned int itag
)
540 size_t ttaglen
= der_length_tag(ttag
);
541 size_t itaglen
= der_length_tag(itag
);
546 assert(p
!= NULL
&& size
!= NULL
);
548 /* Attempt to encode in place */
549 e
= encoder(p
, len
, obj
, size
);
551 /* Fits! Rewrite tag, adjust reported size. */
552 e
= der_put_tag(p
+ ttaglen
- 1, itaglen
, iclass
, type
, itag
, &l
);
559 if (e
!= ASN1_OVERFLOW
|| itaglen
<= ttaglen
)
563 * Did not fit because ttaglen > itaglen and this was the last / only thing
564 * being encoded in a buffer of just the right size.
566 if ((p2
= malloc(len
+ ttaglen
- itaglen
)) == NULL
)
569 e
= encoder(p2
+ len
+ ttaglen
- itaglen
- 1, len
+ ttaglen
- itaglen
,
572 e
= der_put_tag(p2
+ ttaglen
- 1, itaglen
, iclass
, type
, itag
, &l
);
576 memcpy(p
- *size
, p2
+ ttaglen
- itaglen
, *size
);
584 der_put_tag (unsigned char *p
, size_t len
, Der_class
class, Der_type type
,
585 unsigned int tag
, size_t *size
)
589 return ASN1_OVERFLOW
;
590 *p
= MAKE_TAG(class, type
, tag
);
594 unsigned int continuation
= 0;
598 return ASN1_OVERFLOW
;
599 *p
-- = tag
% 128 | continuation
;
606 return ASN1_OVERFLOW
;
607 *p
-- = MAKE_TAG(class, type
, 0x1f);
615 der_put_length_and_tag (unsigned char *p
, size_t len
, size_t len_val
,
616 Der_class
class, Der_type type
,
617 unsigned int tag
, size_t *size
)
623 e
= der_put_length (p
, len
, len_val
, &l
);
629 e
= der_put_tag (p
, len
, class, type
, tag
, &l
);
639 _heim_time2generalizedtime (time_t t
, heim_octet_string
*s
, int gtimep
)
642 const size_t len
= gtimep
? 15 : 13;
647 if (_der_gmtime(t
, &tm
) == NULL
)
648 return ASN1_BAD_TIMEFORMAT
;
649 s
->data
= malloc(len
+ 1);
654 bytes
= snprintf(s
->data
, len
+ 1, "%04d%02d%02d%02d%02d%02dZ",
655 tm
.tm_year
+ 1900, tm
.tm_mon
+ 1, tm
.tm_mday
,
656 tm
.tm_hour
, tm
.tm_min
, tm
.tm_sec
);
658 bytes
= snprintf(s
->data
, len
+ 1, "%02d%02d%02d%02d%02d%02dZ",
659 tm
.tm_year
% 100, tm
.tm_mon
+ 1, tm
.tm_mday
,
660 tm
.tm_hour
, tm
.tm_min
, tm
.tm_sec
);
669 der_put_bit_string (unsigned char *p
, size_t len
,
670 const heim_bit_string
*data
, size_t *size
)
674 assert(p
!= NULL
&& data
!= NULL
&& size
!= NULL
);
677 data_size
= (data
->length
+ 7) / 8;
678 if (len
< data_size
+ 1)
679 return ASN1_OVERFLOW
;
682 memcpy (p
+2, data
->data
, data_size
);
683 if (data
->length
&& (data
->length
% 8) != 0)
684 p
[1] = 8 - (data
->length
% 8);
687 *size
= data_size
+ 1;
692 _heim_der_set_sort(const void *a1
, const void *a2
)
694 const heim_octet_string
*s1
, *s2
;
697 assert(a1
!= NULL
&& a2
!= NULL
);
700 ret
= memcmp(s1
->data
, s2
->data
,
701 s1
->length
< s2
->length
? s1
->length
: s2
->length
);
704 return (int)(s1
->length
- s2
->length
);