xref: /qemu/crypto/der.c (revision 8b7b9c5c) 
1 /*
2  * QEMU Crypto ASN.1 DER decoder
3  *
4  * Copyright (c) 2022 Bytedance
5  * Author: lei he <helei.sig11@bytedance.com>
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
19  *
20  */
21 
22 #include "qemu/osdep.h"
23 #include "crypto/der.h"
24 
25 typedef struct QCryptoDerEncodeNode {
26     uint8_t tag;
27     struct QCryptoDerEncodeNode *parent;
28     struct QCryptoDerEncodeNode *next;
29     /* for constructed type, data is null */
30     const uint8_t *data;
31     size_t dlen;
32 } QCryptoDerEncodeNode;
33 
34 typedef struct QCryptoEncodeContext {
35     QCryptoDerEncodeNode root;
36     QCryptoDerEncodeNode *current_parent;
37     QCryptoDerEncodeNode *tail;
38 } QCryptoEncodeContext;
39 
40 enum QCryptoDERTypeTag {
41     QCRYPTO_DER_TYPE_TAG_BOOL = 0x1,
42     QCRYPTO_DER_TYPE_TAG_INT = 0x2,
43     QCRYPTO_DER_TYPE_TAG_BIT_STR = 0x3,
44     QCRYPTO_DER_TYPE_TAG_OCT_STR = 0x4,
45     QCRYPTO_DER_TYPE_TAG_NULL = 0x5,
46     QCRYPTO_DER_TYPE_TAG_OID = 0x6,
47     QCRYPTO_DER_TYPE_TAG_SEQ = 0x10,
48     QCRYPTO_DER_TYPE_TAG_SET = 0x11,
49 };
50 
51 enum QCryptoDERTagClass {
52     QCRYPTO_DER_TAG_CLASS_UNIV = 0x0,
53     QCRYPTO_DER_TAG_CLASS_APPL = 0x1,
54     QCRYPTO_DER_TAG_CLASS_CONT = 0x2,
55     QCRYPTO_DER_TAG_CLASS_PRIV = 0x3,
56 };
57 
58 enum QCryptoDERTagEnc {
59     QCRYPTO_DER_TAG_ENC_PRIM = 0x0,
60     QCRYPTO_DER_TAG_ENC_CONS = 0x1,
61 };
62 
63 #define QCRYPTO_DER_TAG_ENC_MASK 0x20
64 #define QCRYPTO_DER_TAG_ENC_SHIFT 5
65 
66 #define QCRYPTO_DER_TAG_CLASS_MASK 0xc0
67 #define QCRYPTO_DER_TAG_CLASS_SHIFT 6
68 
69 #define QCRYPTO_DER_TAG_VAL_MASK 0x1f
70 #define QCRYPTO_DER_SHORT_LEN_MASK 0x80
71 
72 #define QCRYPTO_DER_TAG(class, enc, val)           \
73     (((class) << QCRYPTO_DER_TAG_CLASS_SHIFT) |    \
74      ((enc) << QCRYPTO_DER_TAG_ENC_SHIFT) | (val))
75 
76 /**
77  * qcrypto_der_encode_length:
78  * @src_len: the length of source data
79  * @dst: destination to save the encoded 'length', if dst is NULL, only compute
80  * the expected buffer size in bytes.
81  * @dst_len: output parameter, indicates how many bytes wrote.
82  *
83  * Encode the 'length' part of TLV tuple.
84  */
85 static void qcrypto_der_encode_length(size_t src_len,
86                                       uint8_t *dst, size_t *dst_len)
87 {
88     size_t max_length = 0xFF;
89     uint8_t length_bytes = 0, header_byte;
90 
91     if (src_len < QCRYPTO_DER_SHORT_LEN_MASK) {
92         header_byte = src_len;
93         *dst_len = 1;
94     } else {
95         for (length_bytes = 1; max_length < src_len; length_bytes++) {
96             max_length = (max_length << 8) + max_length;
97         }
98         header_byte = length_bytes;
99         header_byte |= QCRYPTO_DER_SHORT_LEN_MASK;
100         *dst_len = length_bytes + 1;
101     }
102     if (!dst) {
103         return;
104     }
105     *dst++ = header_byte;
106     /* Bigendian length bytes */
107     for (; length_bytes > 0; length_bytes--) {
108         *dst++ = ((src_len >> (length_bytes - 1) * 8) & 0xFF);
109     }
110 }
111 
112 static uint8_t qcrypto_der_peek_byte(const uint8_t **data, size_t *dlen)
113 {
114     return **data;
115 }
116 
117 static void qcrypto_der_cut_nbytes(const uint8_t **data,
118                                    size_t *dlen,
119                                    size_t nbytes)
120 {
121     *data += nbytes;
122     *dlen -= nbytes;
123 }
124 
125 static uint8_t qcrypto_der_cut_byte(const uint8_t **data, size_t *dlen)
126 {
127     uint8_t val = qcrypto_der_peek_byte(data, dlen);
128 
129     qcrypto_der_cut_nbytes(data, dlen, 1);
130 
131     return val;
132 }
133 
134 static int qcrypto_der_invoke_callback(QCryptoDERDecodeCb cb, void *ctx,
135                                        const uint8_t *value, size_t vlen,
136                                        Error **errp)
137 {
138     if (!cb) {
139         return 0;
140     }
141 
142     return cb(ctx, value, vlen, errp);
143 }
144 
145 static int qcrypto_der_extract_definite_data(const uint8_t **data, size_t *dlen,
146                                              QCryptoDERDecodeCb cb, void *ctx,
147                                              Error **errp)
148 {
149     const uint8_t *value;
150     size_t vlen = 0;
151     uint8_t byte_count = qcrypto_der_cut_byte(data, dlen);
152 
153     /* short format of definite-length */
154     if (!(byte_count & QCRYPTO_DER_SHORT_LEN_MASK)) {
155         if (byte_count > *dlen) {
156             error_setg(errp, "Invalid content length: %u", byte_count);
157             return -1;
158         }
159 
160         value = *data;
161         vlen = byte_count;
162         qcrypto_der_cut_nbytes(data, dlen, vlen);
163 
164         if (qcrypto_der_invoke_callback(cb, ctx, value, vlen, errp) != 0) {
165             return -1;
166         }
167         return vlen;
168     }
169 
170     /* Ignore highest bit */
171     byte_count &= ~QCRYPTO_DER_SHORT_LEN_MASK;
172 
173     /*
174      * size_t is enough to store the value of length, although the DER
175      * encoding standard supports larger length.
176      */
177     if (byte_count > sizeof(size_t)) {
178         error_setg(errp, "Invalid byte count of content length: %u",
179                    byte_count);
180         return -1;
181     }
182 
183     if (byte_count > *dlen) {
184         error_setg(errp, "Invalid content length: %u", byte_count);
185         return -1;
186     }
187     while (byte_count--) {
188         vlen <<= 8;
189         vlen += qcrypto_der_cut_byte(data, dlen);
190     }
191 
192     if (vlen > *dlen) {
193         error_setg(errp, "Invalid content length: %zu", vlen);
194         return -1;
195     }
196 
197     value = *data;
198     qcrypto_der_cut_nbytes(data, dlen, vlen);
199 
200     if (qcrypto_der_invoke_callback(cb, ctx, value, vlen, errp) != 0) {
201         return -1;
202     }
203     return vlen;
204 }
205 
206 static int qcrypto_der_extract_data(const uint8_t **data, size_t *dlen,
207                                     QCryptoDERDecodeCb cb, void *ctx,
208                                     Error **errp)
209 {
210     uint8_t val;
211     if (*dlen < 1) {
212         error_setg(errp, "Need more data");
213         return -1;
214     }
215     val = qcrypto_der_peek_byte(data, dlen);
216 
217     /* must use definite length format */
218     if (val == QCRYPTO_DER_SHORT_LEN_MASK) {
219         error_setg(errp, "Only definite length format is allowed");
220         return -1;
221     }
222 
223     return qcrypto_der_extract_definite_data(data, dlen, cb, ctx, errp);
224 }
225 
226 static int qcrypto_der_decode_tlv(const uint8_t expected_tag,
227                                   const uint8_t **data, size_t *dlen,
228                                   QCryptoDERDecodeCb cb,
229                                   void *ctx, Error **errp)
230 {
231     const uint8_t *saved_data = *data;
232     size_t saved_dlen = *dlen;
233     uint8_t tag;
234     int data_length;
235 
236     if (*dlen < 1) {
237         error_setg(errp, "Need more data");
238         return -1;
239     }
240     tag = qcrypto_der_cut_byte(data, dlen);
241     if (tag != expected_tag) {
242         error_setg(errp, "Unexpected tag: expected: %u, actual: %u",
243                    expected_tag, tag);
244         goto error;
245     }
246 
247     data_length = qcrypto_der_extract_data(data, dlen, cb, ctx, errp);
248     if (data_length < 0) {
249         goto error;
250     }
251     return data_length;
252 
253 error:
254     *data = saved_data;
255     *dlen = saved_dlen;
256     return -1;
257 }
258 
259 int qcrypto_der_decode_int(const uint8_t **data, size_t *dlen,
260                            QCryptoDERDecodeCb cb, void *ctx, Error **errp)
261 {
262     const uint8_t tag = QCRYPTO_DER_TAG(QCRYPTO_DER_TAG_CLASS_UNIV,
263                                         QCRYPTO_DER_TAG_ENC_PRIM,
264                                         QCRYPTO_DER_TYPE_TAG_INT);
265     return qcrypto_der_decode_tlv(tag, data, dlen, cb, ctx, errp);
266 }
267 
268 int qcrypto_der_decode_seq(const uint8_t **data, size_t *dlen,
269                            QCryptoDERDecodeCb cb, void *ctx, Error **errp)
270 {
271     uint8_t tag = QCRYPTO_DER_TAG(QCRYPTO_DER_TAG_CLASS_UNIV,
272                                   QCRYPTO_DER_TAG_ENC_CONS,
273                                   QCRYPTO_DER_TYPE_TAG_SEQ);
274     return qcrypto_der_decode_tlv(tag, data, dlen, cb, ctx, errp);
275 }
276 
277 int qcrypto_der_decode_octet_str(const uint8_t **data, size_t *dlen,
278                                  QCryptoDERDecodeCb cb, void *ctx, Error **errp)
279 {
280     uint8_t tag = QCRYPTO_DER_TAG(QCRYPTO_DER_TAG_CLASS_UNIV,
281                                   QCRYPTO_DER_TAG_ENC_PRIM,
282                                   QCRYPTO_DER_TYPE_TAG_OCT_STR);
283     return qcrypto_der_decode_tlv(tag, data, dlen, cb, ctx, errp);
284 }
285 
286 int qcrypto_der_decode_bit_str(const uint8_t **data, size_t *dlen,
287                                QCryptoDERDecodeCb cb, void *ctx, Error **errp)
288 {
289     uint8_t tag = QCRYPTO_DER_TAG(QCRYPTO_DER_TAG_CLASS_UNIV,
290                                   QCRYPTO_DER_TAG_ENC_PRIM,
291                                   QCRYPTO_DER_TYPE_TAG_BIT_STR);
292     return qcrypto_der_decode_tlv(tag, data, dlen, cb, ctx, errp);
293 }
294 
295 int qcrypto_der_decode_oid(const uint8_t **data, size_t *dlen,
296                            QCryptoDERDecodeCb cb, void *ctx, Error **errp)
297 {
298     uint8_t tag = QCRYPTO_DER_TAG(QCRYPTO_DER_TAG_CLASS_UNIV,
299                                   QCRYPTO_DER_TAG_ENC_PRIM,
300                                   QCRYPTO_DER_TYPE_TAG_OID);
301     return qcrypto_der_decode_tlv(tag, data, dlen, cb, ctx, errp);
302 }
303 
304 int qcrypto_der_decode_ctx_tag(const uint8_t **data, size_t *dlen, int tag_id,
305                                QCryptoDERDecodeCb cb, void *ctx, Error **errp)
306 {
307     uint8_t tag = QCRYPTO_DER_TAG(QCRYPTO_DER_TAG_CLASS_CONT,
308                                   QCRYPTO_DER_TAG_ENC_CONS,
309                                   tag_id);
310     return qcrypto_der_decode_tlv(tag, data, dlen, cb, ctx, errp);
311 }
312 
313 static void qcrypto_der_encode_prim(QCryptoEncodeContext *ctx, uint8_t tag,
314                                     const uint8_t *data, size_t dlen)
315 {
316     QCryptoDerEncodeNode *node = g_new0(QCryptoDerEncodeNode, 1);
317     size_t nbytes_len;
318 
319     node->tag = tag;
320     node->data = data;
321     node->dlen = dlen;
322     node->parent = ctx->current_parent;
323 
324     qcrypto_der_encode_length(dlen, NULL, &nbytes_len);
325     /* 1 byte for Tag, nbyte_len for Length, and dlen for Value */
326     node->parent->dlen += 1 + nbytes_len + dlen;
327 
328     ctx->tail->next = node;
329     ctx->tail = node;
330 }
331 
332 QCryptoEncodeContext *qcrypto_der_encode_ctx_new(void)
333 {
334     QCryptoEncodeContext *ctx = g_new0(QCryptoEncodeContext, 1);
335     ctx->current_parent = &ctx->root;
336     ctx->tail = &ctx->root;
337     return ctx;
338 }
339 
340 static void qcrypto_der_encode_cons_begin(QCryptoEncodeContext *ctx,
341                                           uint8_t tag)
342 {
343     QCryptoDerEncodeNode *node = g_new0(QCryptoDerEncodeNode, 1);
344 
345     node->tag = tag;
346     node->parent = ctx->current_parent;
347     ctx->current_parent = node;
348     ctx->tail->next = node;
349     ctx->tail = node;
350 }
351 
352 static void qcrypto_der_encode_cons_end(QCryptoEncodeContext *ctx)
353 {
354     QCryptoDerEncodeNode *cons_node = ctx->current_parent;
355     size_t nbytes_len;
356 
357     qcrypto_der_encode_length(cons_node->dlen, NULL, &nbytes_len);
358     /* 1 byte for Tag, nbyte_len for Length, and dlen for Value */
359     cons_node->parent->dlen += 1 + nbytes_len + cons_node->dlen;
360     ctx->current_parent = cons_node->parent;
361 }
362 
363 void qcrypto_der_encode_seq_begin(QCryptoEncodeContext *ctx)
364 {
365     uint8_t tag = QCRYPTO_DER_TAG(QCRYPTO_DER_TAG_CLASS_UNIV,
366                                   QCRYPTO_DER_TAG_ENC_CONS,
367                                   QCRYPTO_DER_TYPE_TAG_SEQ);
368     qcrypto_der_encode_cons_begin(ctx, tag);
369 }
370 
371 void qcrypto_der_encode_seq_end(QCryptoEncodeContext *ctx)
372 {
373     qcrypto_der_encode_cons_end(ctx);
374 }
375 
376 void qcrypto_der_encode_oid(QCryptoEncodeContext *ctx,
377                             const uint8_t *src, size_t src_len)
378 {
379     uint8_t tag = QCRYPTO_DER_TAG(QCRYPTO_DER_TAG_CLASS_UNIV,
380                                   QCRYPTO_DER_TAG_ENC_PRIM,
381                                   QCRYPTO_DER_TYPE_TAG_OID);
382     qcrypto_der_encode_prim(ctx, tag, src, src_len);
383 }
384 
385 void qcrypto_der_encode_int(QCryptoEncodeContext *ctx,
386                             const uint8_t *src, size_t src_len)
387 {
388     uint8_t tag = QCRYPTO_DER_TAG(QCRYPTO_DER_TAG_CLASS_UNIV,
389                                   QCRYPTO_DER_TAG_ENC_PRIM,
390                                   QCRYPTO_DER_TYPE_TAG_INT);
391     qcrypto_der_encode_prim(ctx, tag, src, src_len);
392 }
393 
394 void qcrypto_der_encode_null(QCryptoEncodeContext *ctx)
395 {
396     uint8_t tag = QCRYPTO_DER_TAG(QCRYPTO_DER_TAG_CLASS_UNIV,
397                                   QCRYPTO_DER_TAG_ENC_PRIM,
398                                   QCRYPTO_DER_TYPE_TAG_NULL);
399     qcrypto_der_encode_prim(ctx, tag, NULL, 0);
400 }
401 
402 void qcrypto_der_encode_octet_str(QCryptoEncodeContext *ctx,
403                                   const uint8_t *src, size_t src_len)
404 {
405     uint8_t tag = QCRYPTO_DER_TAG(QCRYPTO_DER_TAG_CLASS_UNIV,
406                                   QCRYPTO_DER_TAG_ENC_PRIM,
407                                   QCRYPTO_DER_TYPE_TAG_OCT_STR);
408     qcrypto_der_encode_prim(ctx, tag, src, src_len);
409 }
410 
411 void qcrypto_der_encode_octet_str_begin(QCryptoEncodeContext *ctx)
412 {
413     uint8_t tag = QCRYPTO_DER_TAG(QCRYPTO_DER_TAG_CLASS_UNIV,
414                                   QCRYPTO_DER_TAG_ENC_PRIM,
415                                   QCRYPTO_DER_TYPE_TAG_OCT_STR);
416     qcrypto_der_encode_cons_begin(ctx, tag);
417 }
418 
419 void qcrypto_der_encode_octet_str_end(QCryptoEncodeContext *ctx)
420 {
421     qcrypto_der_encode_cons_end(ctx);
422 }
423 
424 size_t qcrypto_der_encode_ctx_buffer_len(QCryptoEncodeContext *ctx)
425 {
426     return ctx->root.dlen;
427 }
428 
429 void qcrypto_der_encode_ctx_flush_and_free(QCryptoEncodeContext *ctx,
430                                            uint8_t *dst)
431 {
432     QCryptoDerEncodeNode *node, *prev;
433     size_t len;
434 
435     for (prev = &ctx->root;
436          (node = prev->next) && (prev->next = node->next, 1);) {
437         /* Tag */
438         *dst++ = node->tag;
439 
440         /* Length */
441         qcrypto_der_encode_length(node->dlen, dst, &len);
442         dst += len;
443 
444         /* Value */
445         if (node->data) {
446             memcpy(dst, node->data, node->dlen);
447             dst += node->dlen;
448         }
449         g_free(node);
450     }
451     g_free(ctx);
452 }
453