aboutsummaryrefslogtreecommitdiff
path: root/asn1_internal.h
blob: 0b08b847228adbe14d6df71c5d0b85962931f7db (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
/*
 * asn1_internal.h
 * ---------------
 * Library internal header file for ASN.1 routines.  These functions
 * are not part of the public libhal API.
 *
 * The only reason for not collapsing this header file into
 * hal_internal.h is to maintain some isolation between the few
 * modules which use libtfm and the rest of the library.
 *
 * More than 20 years after it was written, the best simple
 * introduction to ASN.1 is still Burt Kalski's "A Layman's Guide to a
 * Subset of ASN.1, BER, and DER".  Ask your nearest search engine.
 *
 * Authors: Rob Austein
 * Copyright (c) 2015, NORDUnet A/S
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 * - Redistributions of source code must retain the above copyright notice,
 *   this list of conditions and the following disclaimer.
 *
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 *
 * - Neither the name of the NORDUnet nor the names of its contributors may
 *   be used to endorse or promote products derived from this software
 *   without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef _HAL_ASN1_INTERNAL_H_
#define _HAL_ASN1_INTERNAL_H_

#include <stdint.h>

#include <tfm.h>

#define ASN1_UNIVERSAL          0x00
#define ASN1_APPLICATION        0x40
#define ASN1_CONTEXT_SPECIFIC   0x80
#define ASN1_PRIVATE            0xC0

#define ASN1_PRIMITIVE          0x00
#define ASN1_CONSTRUCTED        0x20

#define ASN1_TAG_MASK           0x1F

#define ASN1_INTEGER            (ASN1_PRIMITIVE   | 0x02)
#define ASN1_BIT_STRING         (ASN1_PRIMITIVE   | 0x03)
#define ASN1_OCTET_STRING       (ASN1_PRIMITIVE   | 0x04)
#define ASN1_NULL               (ASN1_PRIMITIVE   | 0x05)
#define ASN1_OBJECT_IDENTIFIER  (ASN1_PRIMITIVE   | 0x06)
#define ASN1_SEQUENCE           (ASN1_CONSTRUCTED | 0x10)
#define ASN1_SET                (ASN1_CONSTRUCTED | 0x11)

#define ASN1_EXPLICIT_CONTEXT   (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTED)
#define ASN1_EXPLICIT_0         (ASN1_EXPLICIT_CONTEXT + 0)
#define ASN1_EXPLICIT_1         (ASN1_EXPLICIT_CONTEXT + 1)

/*
 * Functions to strip const qualifiers from arguments to libtfm calls
 * in a relatively type-safe manner.  These don't really have anything
 * to do with ASN.1 per se, but all the code that needs them reads
 * this header file, so this is the simplest place to put them.
 */

static inline fp_int *unconst_fp_int(const fp_int * const arg)
{
  return (fp_int *) arg;
}

static inline uint8_t *unconst_uint8_t(const uint8_t * const arg)
{
  return (uint8_t *) arg;
}

extern hal_error_t hal_asn1_encode_header(const uint8_t tag,
                                          const size_t value_len,
                                          uint8_t *der, size_t *der_len, const size_t der_max);

extern hal_error_t hal_asn1_decode_header(const uint8_t tag,
                                          const uint8_t * const der, size_t der_max,
                                          size_t *hlen, size_t *vlen);

extern hal_error_t hal_asn1_encode_integer(const fp_int * const bn,
                                           uint8_t *der, size_t *der_len, const size_t der_max);

extern hal_error_t hal_asn1_decode_integer(fp_int *bn,
                                           const uint8_t * const der, size_t *der_len, const size_t der_max);

extern hal_error_t hal_asn1_encode_spki(const uint8_t * const alg_oid,   const size_t alg_oid_len,
                                        const uint8_t * const curve_oid, const size_t curve_oid_len,
                                        const uint8_t * const pubkey,    const size_t pubkey_len,
                                        uint8_t *der, size_t *der_len, const size_t der_max);

extern hal_error_t hal_asn1_decode_spki(const uint8_t **alg_oid,   size_t *alg_oid_len,
                                        const uint8_t **curve_oid, size_t *curve_oid_len,
                                        const uint8_t **pubkey,    size_t *pubkey_len,
                                        const uint8_t *const der,  const size_t der_len);

#endif /* _HAL_ASN1_INTERNAL_H_ */

/*
 * Local variables:
 * indent-tabs-mode: nil
 * End:
 */
needed */ for (size_t n = value_len; n > 0; n >>= 8) ++header_len; if (der_len != NULL) *der_len = header_len; if (der == NULL) /* If caller just wanted the length, we're done */ return HAL_OK; /* * Make sure there's enough room for header + value, then encode. */ if (value_len + header_len > der_max) return HAL_ERROR_RESULT_TOO_LONG; *der++ = tag; if (value_len < 128) { *der = (uint8_t) value_len; } else { *der = 0x80 | (uint8_t) (header_len -= 2); for (size_t n = value_len; n > 0 && header_len > 0; n >>= 8) der[header_len--] = (uint8_t) (n & 0xFF); } return HAL_OK; } /* * Encode an unsigned ASN.1 INTEGER from a libtfm bignum. If der is * NULL, just return the length of what we would have encoded. */ hal_error_t hal_asn1_encode_integer(const fp_int * const bn, uint8_t *der, size_t *der_len, const size_t der_max) { if (bn == NULL) return HAL_ERROR_BAD_ARGUMENTS; /* * We only handle unsigned INTEGERs, so we need to pad data with a * leading zero if the most significant bit is set, to avoid * flipping the ASN.1 sign bit. Conveniently, this also handles the * difference between libtfm's and ASN.1's encoding of zero. */ if (fp_cmp_d(unconst_fp_int(bn), 0) == FP_LT) return HAL_ERROR_BAD_ARGUMENTS; const int leading_zero = fp_iszero(bn) || (fp_count_bits(unconst_fp_int(bn)) & 7) == 0; const size_t vlen = fp_unsigned_bin_size(unconst_fp_int(bn)) + leading_zero; hal_error_t err; size_t hlen; err = hal_asn1_encode_header(ASN1_INTEGER, vlen, der, &hlen, der_max); if (der_len != NULL) *der_len = hlen + vlen; if (der == NULL || err != HAL_OK) return err; assert(hlen + vlen <= der_max); der += hlen; if (leading_zero) *der++ = 0x00; fp_to_unsigned_bin(unconst_fp_int(bn), der); return HAL_OK; } /* * Encode a public key into an RFC 5280 SubjectPublicKeyInfo. */ hal_error_t hal_asn1_encode_spki(const uint8_t * const alg_oid, const size_t alg_oid_len, const uint8_t * const curve_oid, const size_t curve_oid_len, const uint8_t * const pubkey, const size_t pubkey_len, uint8_t *der, size_t *der_len, const size_t der_max) { if (alg_oid == NULL || alg_oid_len == 0 || pubkey_len == 0 || (der != NULL && pubkey == NULL) || (curve_oid == NULL && curve_oid_len != 0)) return HAL_ERROR_BAD_ARGUMENTS; const uint8_t curve_oid_tag = curve_oid == NULL ? ASN1_NULL : ASN1_OBJECT_IDENTIFIER; hal_error_t err; size_t hlen, hlen_spki, hlen_algid, hlen_alg, hlen_curve, hlen_bit; if ((err = hal_asn1_encode_header(ASN1_OBJECT_IDENTIFIER, alg_oid_len, NULL, &hlen_alg, 0)) != HAL_OK || (err = hal_asn1_encode_header(curve_oid_tag, curve_oid_len, NULL, &hlen_curve, 0)) != HAL_OK || (err = hal_asn1_encode_header(ASN1_BIT_STRING, 1 + pubkey_len, NULL, &hlen_bit, 0)) != HAL_OK) return err; const size_t algid_len = hlen_alg + alg_oid_len + hlen_curve + curve_oid_len; if ((err = hal_asn1_encode_header(ASN1_SEQUENCE, algid_len, NULL, &hlen_algid, 0)) != HAL_OK) return err; const size_t vlen = hlen_algid + hlen_alg + alg_oid_len + hlen_curve + curve_oid_len + hlen_bit + 1 + pubkey_len; if ((err = hal_asn1_encode_header(ASN1_SEQUENCE, vlen, NULL, &hlen_spki, 0)) != HAL_OK) return err; /* * Handle pubkey early, in case it was staged into our output buffer. */ if (der != NULL && hlen_spki + vlen <= der_max) memmove(der + hlen_spki + vlen - pubkey_len, pubkey, pubkey_len); err = hal_asn1_encode_header(ASN1_SEQUENCE, vlen, der, &hlen, der_max); if (der_len != NULL) *der_len = hlen + vlen; if (der == NULL || err != HAL_OK) return err; uint8_t *d = der + hlen; memset(d, 0, vlen - pubkey_len); if ((err = hal_asn1_encode_header(ASN1_SEQUENCE, algid_len, d, &hlen, der + der_max - d)) != HAL_OK) return err; d += hlen; if ((err = hal_asn1_encode_header(ASN1_OBJECT_IDENTIFIER, alg_oid_len, d, &hlen, der + der_max - d)) != HAL_OK) return err; d += hlen; memcpy(d, alg_oid, alg_oid_len); d += alg_oid_len; if ((err = hal_asn1_encode_header(curve_oid_tag, curve_oid_len, d, &hlen, der + der_max - d)) != HAL_OK) return err; d += hlen; if (curve_oid != NULL) memcpy(d, curve_oid, curve_oid_len); d += curve_oid_len; if ((err = hal_asn1_encode_header(ASN1_BIT_STRING, 1 + pubkey_len, d, &hlen, der + der_max - d)) != HAL_OK) return err; d += hlen; *d++ = 0x00; d += pubkey_len; /* pubkey handled early, above. */ assert(d == der + hlen_spki + vlen); assert(d <= der + der_max); return HAL_OK; } /* * Parse tag and length of an ASN.1 object. Tag must match value * specified by the caller. On success, sets hlen and vlen to lengths * of header and value, respectively. */ hal_error_t hal_asn1_decode_header(const uint8_t tag, const uint8_t * const der, size_t der_max, size_t *hlen, size_t *vlen) { assert(der != NULL && hlen != NULL && vlen != NULL); if (der_max < 2 || der[0] != tag) return HAL_ERROR_ASN1_PARSE_FAILED; if ((der[1] & 0x80) == 0) { *hlen = 2; *vlen = der[1]; } else { *hlen = 2 + (der[1] & 0x7F); *vlen = 0; if (*hlen > der_max) return HAL_ERROR_ASN1_PARSE_FAILED; for (size_t i = 2; i < *hlen; i++) *vlen = (*vlen << 8) + der[i]; } if (*hlen + *vlen > der_max) return HAL_ERROR_ASN1_PARSE_FAILED; return HAL_OK; } /* * Decode an ASN.1 INTEGER into a libtfm bignum. Since we only * support (or need to support, or expect to see) unsigned integers, * we return failure if the sign bit is set in the ASN.1 INTEGER. */ hal_error_t hal_asn1_decode_integer(fp_int *bn, const uint8_t * const der, size_t *der_len, const size_t der_max) { if (bn == NULL || der == NULL) return HAL_ERROR_BAD_ARGUMENTS; hal_error_t err; size_t hlen, vlen; if ((err = hal_asn1_decode_header(ASN1_INTEGER, der, der_max, &hlen, &vlen)) != HAL_OK) return err; if (der_len != NULL) *der_len = hlen + vlen; if (vlen < 1 || (der[hlen] & 0x80) != 0x00) return HAL_ERROR_ASN1_PARSE_FAILED; fp_init(bn); fp_read_unsigned_bin(bn, (uint8_t *) der + hlen, vlen); return HAL_OK; } /* * Decode a public key from an RFC 5280 SubjectPublicKeyInfo. */ hal_error_t hal_asn1_decode_spki(const uint8_t **alg_oid, size_t *alg_oid_len, const uint8_t **curve_oid, size_t *curve_oid_len, const uint8_t **pubkey, size_t *pubkey_len, const uint8_t *const der, const size_t der_len) { if (alg_oid == NULL || alg_oid_len == NULL || curve_oid == NULL || curve_oid_len == NULL || pubkey == NULL || pubkey_len == NULL || der == NULL) return HAL_ERROR_BAD_ARGUMENTS; const uint8_t * const der_end = der + der_len; const uint8_t *d = der; size_t hlen, vlen; hal_error_t err; if ((err = hal_asn1_decode_header(ASN1_SEQUENCE, d, der_end - d, &hlen, &vlen)) != HAL_OK) return err; d += hlen; if ((err = hal_asn1_decode_header(ASN1_SEQUENCE, d, der_end - d, &hlen, &vlen)) != HAL_OK) return err; d += hlen; const uint8_t * const algid_end = d + vlen; if ((err = hal_asn1_decode_header(ASN1_OBJECT_IDENTIFIER, d, algid_end - d, &hlen, &vlen)) != HAL_OK) return err; d += hlen; if (vlen > algid_end - d) return HAL_ERROR_ASN1_PARSE_FAILED; *alg_oid = d; *alg_oid_len = vlen; d += vlen; *curve_oid = NULL; *curve_oid_len = 0; if (d < algid_end) { switch (*d) { case ASN1_OBJECT_IDENTIFIER: if ((err = hal_asn1_decode_header(ASN1_OBJECT_IDENTIFIER, d, algid_end - d, &hlen, &vlen)) != HAL_OK) return err; d += hlen; if (vlen > algid_end - d) return HAL_ERROR_ASN1_PARSE_FAILED; *curve_oid = d; *curve_oid_len = vlen; d += vlen; break; case ASN1_NULL: if ((err = hal_asn1_decode_header(ASN1_NULL, d, algid_end - d, &hlen, &vlen)) != HAL_OK) return err; d += hlen; if (vlen == 0) break; default: return HAL_ERROR_ASN1_PARSE_FAILED; } } if (d != algid_end) return HAL_ERROR_ASN1_PARSE_FAILED; if ((err = hal_asn1_decode_header(ASN1_BIT_STRING, d, der_end - d, &hlen, &vlen)) != HAL_OK) return err; d += hlen; if (vlen >= algid_end - d || vlen == 0 || *d != 0x00) return HAL_ERROR_ASN1_PARSE_FAILED; *pubkey = ++d; *pubkey_len = --vlen; d += vlen; if (d != der_end) return HAL_ERROR_ASN1_PARSE_FAILED; return HAL_OK; } /* * Local variables: * indent-tabs-mode: nil * End: */