1/* BEGIN_HEADER */
2#include "mbedtls/asn1write.h"
3
4#define GUARD_LEN 4
5#define GUARD_VAL 0x2a
6
7typedef struct {
8    unsigned char *output;
9    unsigned char *start;
10    unsigned char *end;
11    unsigned char *p;
12    size_t size;
13} generic_write_data_t;
14
15int generic_write_start_step(generic_write_data_t *data)
16{
17    mbedtls_test_set_step(data->size);
18    mbedtls_free(data->output);
19    data->output = NULL;
20    TEST_CALLOC(data->output, data->size == 0 ? 1 : data->size);
21    data->end = data->output + data->size;
22    data->p = data->end;
23    data->start = data->end - data->size;
24    return 1;
25exit:
26    return 0;
27}
28
29int generic_write_finish_step(generic_write_data_t *data,
30                              const data_t *expected, int ret)
31{
32    int ok = 0;
33
34    if (data->size < expected->len) {
35        TEST_EQUAL(ret, MBEDTLS_ERR_ASN1_BUF_TOO_SMALL);
36    } else {
37        TEST_EQUAL(ret, data->end - data->p);
38        TEST_ASSERT(data->p >= data->start);
39        TEST_ASSERT(data->p <= data->end);
40        TEST_MEMORY_COMPARE(data->p, (size_t) (data->end - data->p),
41                            expected->x, expected->len);
42    }
43    ok = 1;
44
45exit:
46    return ok;
47}
48
49/* END_HEADER */
50
51/* BEGIN_DEPENDENCIES
52 * depends_on:MBEDTLS_ASN1_WRITE_C
53 * END_DEPENDENCIES
54 */
55
56/* BEGIN_CASE */
57void mbedtls_asn1_write_null(data_t *expected)
58{
59    generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 };
60    int ret;
61
62    for (data.size = 0; data.size <= expected->len + 1; data.size++) {
63        if (!generic_write_start_step(&data)) {
64            goto exit;
65        }
66        ret = mbedtls_asn1_write_null(&data.p, data.start);
67        if (!generic_write_finish_step(&data, expected, ret)) {
68            goto exit;
69        }
70        /* There's no parsing function for NULL. */
71    }
72
73exit:
74    mbedtls_free(data.output);
75}
76/* END_CASE */
77
78/* BEGIN_CASE */
79void mbedtls_asn1_write_bool(int val, data_t *expected)
80{
81    generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 };
82    int ret;
83
84    for (data.size = 0; data.size <= expected->len + 1; data.size++) {
85        if (!generic_write_start_step(&data)) {
86            goto exit;
87        }
88        ret = mbedtls_asn1_write_bool(&data.p, data.start, val);
89        if (!generic_write_finish_step(&data, expected, ret)) {
90            goto exit;
91        }
92#if defined(MBEDTLS_ASN1_PARSE_C)
93        if (ret >= 0) {
94            int read = 0xdeadbeef;
95            TEST_EQUAL(mbedtls_asn1_get_bool(&data.p, data.end, &read), 0);
96            TEST_EQUAL(val, read);
97        }
98#endif /* MBEDTLS_ASN1_PARSE_C */
99    }
100
101exit:
102    mbedtls_free(data.output);
103}
104/* END_CASE */
105
106/* BEGIN_CASE */
107void mbedtls_asn1_write_int(int val, data_t *expected)
108{
109    generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 };
110    int ret;
111
112    for (data.size = 0; data.size <= expected->len + 1; data.size++) {
113        if (!generic_write_start_step(&data)) {
114            goto exit;
115        }
116        ret = mbedtls_asn1_write_int(&data.p, data.start, val);
117        if (!generic_write_finish_step(&data, expected, ret)) {
118            goto exit;
119        }
120#if defined(MBEDTLS_ASN1_PARSE_C)
121        if (ret >= 0) {
122            int read = 0xdeadbeef;
123            TEST_EQUAL(mbedtls_asn1_get_int(&data.p, data.end, &read), 0);
124            TEST_EQUAL(val, read);
125        }
126#endif /* MBEDTLS_ASN1_PARSE_C */
127    }
128
129exit:
130    mbedtls_free(data.output);
131}
132/* END_CASE */
133
134
135/* BEGIN_CASE */
136void mbedtls_asn1_write_enum(int val, data_t *expected)
137{
138    generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 };
139    int ret;
140
141    for (data.size = 0; data.size <= expected->len + 1; data.size++) {
142        if (!generic_write_start_step(&data)) {
143            goto exit;
144        }
145        ret = mbedtls_asn1_write_enum(&data.p, data.start, val);
146        if (!generic_write_finish_step(&data, expected, ret)) {
147            goto exit;
148        }
149#if defined(MBEDTLS_ASN1_PARSE_C)
150        if (ret >= 0) {
151            int read = 0xdeadbeef;
152            TEST_EQUAL(mbedtls_asn1_get_enum(&data.p, data.end, &read), 0);
153            TEST_EQUAL(val, read);
154        }
155#endif /* MBEDTLS_ASN1_PARSE_C */
156    }
157
158exit:
159    mbedtls_free(data.output);
160}
161/* END_CASE */
162
163/* BEGIN_CASE depends_on:MBEDTLS_BIGNUM_C */
164void mbedtls_asn1_write_mpi(data_t *val, data_t *expected)
165{
166    generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 };
167    mbedtls_mpi mpi, read;
168    int ret;
169
170    mbedtls_mpi_init(&mpi);
171    mbedtls_mpi_init(&read);
172    TEST_ASSERT(mbedtls_mpi_read_binary(&mpi, val->x, val->len) == 0);
173
174    for (data.size = 0; data.size <= expected->len + 1; data.size++) {
175        if (!generic_write_start_step(&data)) {
176            goto exit;
177        }
178        ret = mbedtls_asn1_write_mpi(&data.p, data.start, &mpi);
179        if (!generic_write_finish_step(&data, expected, ret)) {
180            goto exit;
181        }
182#if defined(MBEDTLS_ASN1_PARSE_C)
183        if (ret >= 0) {
184            TEST_EQUAL(mbedtls_asn1_get_mpi(&data.p, data.end, &read), 0);
185            TEST_EQUAL(0, mbedtls_mpi_cmp_mpi(&mpi, &read));
186        }
187#endif /* MBEDTLS_ASN1_PARSE_C */
188        /* Skip some intermediate lengths, they're boring. */
189        if (expected->len > 10 && data.size == 8) {
190            data.size = expected->len - 2;
191        }
192    }
193
194exit:
195    mbedtls_mpi_free(&mpi);
196    mbedtls_mpi_free(&read);
197    mbedtls_free(data.output);
198}
199/* END_CASE */
200
201/* BEGIN_CASE */
202void mbedtls_asn1_write_string(int tag, data_t *content, data_t *expected)
203{
204    generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 };
205    int ret;
206
207    for (data.size = 0; data.size <= expected->len + 1; data.size++) {
208        if (!generic_write_start_step(&data)) {
209            goto exit;
210        }
211        switch (tag) {
212            case MBEDTLS_ASN1_OCTET_STRING:
213                ret = mbedtls_asn1_write_octet_string(
214                    &data.p, data.start, content->x, content->len);
215                break;
216            case MBEDTLS_ASN1_OID:
217                ret = mbedtls_asn1_write_oid(
218                    &data.p, data.start,
219                    (const char *) content->x, content->len);
220                break;
221            case MBEDTLS_ASN1_UTF8_STRING:
222                ret = mbedtls_asn1_write_utf8_string(
223                    &data.p, data.start,
224                    (const char *) content->x, content->len);
225                break;
226            case MBEDTLS_ASN1_PRINTABLE_STRING:
227                ret = mbedtls_asn1_write_printable_string(
228                    &data.p, data.start,
229                    (const char *) content->x, content->len);
230                break;
231            case MBEDTLS_ASN1_IA5_STRING:
232                ret = mbedtls_asn1_write_ia5_string(
233                    &data.p, data.start,
234                    (const char *) content->x, content->len);
235                break;
236            default:
237                ret = mbedtls_asn1_write_tagged_string(
238                    &data.p, data.start, tag,
239                    (const char *) content->x, content->len);
240        }
241        if (!generic_write_finish_step(&data, expected, ret)) {
242            goto exit;
243        }
244        /* There's no parsing function for octet or character strings. */
245        /* Skip some intermediate lengths, they're boring. */
246        if (expected->len > 10 && data.size == 8) {
247            data.size = expected->len - 2;
248        }
249    }
250
251exit:
252    mbedtls_free(data.output);
253}
254/* END_CASE */
255
256/* BEGIN_CASE */
257void mbedtls_asn1_write_algorithm_identifier(data_t *oid,
258                                             int par_len,
259                                             data_t *expected)
260{
261    generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 };
262    int ret;
263#if defined(MBEDTLS_ASN1_PARSE_C)
264    unsigned char *buf_complete = NULL;
265#endif /* MBEDTLS_ASN1_PARSE_C */
266
267    for (data.size = 0; data.size <= expected->len + 1; data.size++) {
268        if (!generic_write_start_step(&data)) {
269            goto exit;
270        }
271        ret = mbedtls_asn1_write_algorithm_identifier(
272            &data.p, data.start,
273            (const char *) oid->x, oid->len, par_len);
274        /* If params_len != 0, mbedtls_asn1_write_algorithm_identifier()
275         * assumes that the parameters are already present in the buffer
276         * and returns a length that accounts for this, but our test
277         * data omits the parameters. */
278        if (ret >= 0) {
279            ret -= par_len;
280        }
281        if (!generic_write_finish_step(&data, expected, ret)) {
282            goto exit;
283        }
284
285#if defined(MBEDTLS_ASN1_PARSE_C)
286        /* Only do a parse-back test if the parameters aren't too large for
287         * a small-heap environment. The boundary is somewhat arbitrary. */
288        if (ret >= 0 && par_len <= 1234) {
289            mbedtls_asn1_buf alg = { 0, 0, NULL };
290            mbedtls_asn1_buf params = { 0, 0, NULL };
291            /* The writing function doesn't write the parameters unless
292             * they're null: it only takes their length as input. But the
293             * parsing function requires the parameters to be present.
294             * Thus make up parameters. */
295            size_t data_len = data.end - data.p;
296            size_t len_complete = data_len + par_len;
297            unsigned char expected_params_tag;
298            size_t expected_params_len;
299            TEST_CALLOC(buf_complete, len_complete);
300            unsigned char *end_complete = buf_complete + len_complete;
301            memcpy(buf_complete, data.p, data_len);
302            if (par_len == 0) {
303                /* mbedtls_asn1_write_algorithm_identifier() wrote a NULL */
304                expected_params_tag = 0x05;
305                expected_params_len = 0;
306            } else if (par_len >= 2 && par_len < 2 + 128) {
307                /* Write an OCTET STRING with a short length encoding */
308                expected_params_tag = buf_complete[data_len] = 0x04;
309                expected_params_len = par_len - 2;
310                buf_complete[data_len + 1] = (unsigned char) expected_params_len;
311            } else if (par_len >= 4 + 128 && par_len < 3 + 256 * 256) {
312                /* Write an OCTET STRING with a two-byte length encoding */
313                expected_params_tag = buf_complete[data_len] = 0x04;
314                expected_params_len = par_len - 4;
315                buf_complete[data_len + 1] = 0x82;
316                buf_complete[data_len + 2] = (unsigned char) (expected_params_len >> 8);
317                buf_complete[data_len + 3] = (unsigned char) (expected_params_len);
318            } else {
319                TEST_FAIL("Bad test data: invalid length of ASN.1 element");
320            }
321            unsigned char *p = buf_complete;
322            TEST_EQUAL(mbedtls_asn1_get_alg(&p, end_complete,
323                                            &alg, &params), 0);
324            TEST_EQUAL(alg.tag, MBEDTLS_ASN1_OID);
325            TEST_MEMORY_COMPARE(alg.p, alg.len, oid->x, oid->len);
326            TEST_EQUAL(params.tag, expected_params_tag);
327            TEST_EQUAL(params.len, expected_params_len);
328            mbedtls_free(buf_complete);
329            buf_complete = NULL;
330        }
331#endif /* MBEDTLS_ASN1_PARSE_C */
332    }
333
334exit:
335    mbedtls_free(data.output);
336#if defined(MBEDTLS_ASN1_PARSE_C)
337    mbedtls_free(buf_complete);
338#endif /* MBEDTLS_ASN1_PARSE_C */
339}
340/* END_CASE */
341
342/* BEGIN_CASE depends_on:MBEDTLS_ASN1_PARSE_C */
343void mbedtls_asn1_write_len(int len, data_t *asn1, int buf_len,
344                            int result)
345{
346    int ret;
347    unsigned char buf[150];
348    unsigned char *p;
349    size_t i;
350    size_t read_len;
351
352    memset(buf, GUARD_VAL, sizeof(buf));
353
354    p = buf + GUARD_LEN + buf_len;
355
356    ret = mbedtls_asn1_write_len(&p, buf + GUARD_LEN, (size_t) len);
357
358    TEST_ASSERT(ret == result);
359
360    /* Check for buffer overwrite on both sides */
361    for (i = 0; i < GUARD_LEN; i++) {
362        TEST_ASSERT(buf[i] == GUARD_VAL);
363        TEST_ASSERT(buf[GUARD_LEN + buf_len + i] == GUARD_VAL);
364    }
365
366    if (result >= 0) {
367        TEST_ASSERT(p + asn1->len == buf + GUARD_LEN + buf_len);
368
369        TEST_ASSERT(memcmp(p, asn1->x, asn1->len) == 0);
370
371        /* Read back with mbedtls_asn1_get_len() to check */
372        ret = mbedtls_asn1_get_len(&p, buf + GUARD_LEN + buf_len, &read_len);
373
374        if (len == 0) {
375            TEST_ASSERT(ret == 0);
376        } else {
377            /* Return will be MBEDTLS_ERR_ASN1_OUT_OF_DATA because the rest of
378             * the buffer is missing
379             */
380            TEST_ASSERT(ret == MBEDTLS_ERR_ASN1_OUT_OF_DATA);
381        }
382        TEST_ASSERT(read_len == (size_t) len);
383        TEST_ASSERT(p == buf + GUARD_LEN + buf_len);
384    }
385}
386/* END_CASE */
387
388/* BEGIN_CASE */
389void test_asn1_write_bitstrings(data_t *bitstring, int bits,
390                                data_t *expected, int is_named)
391{
392    generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 };
393    int ret;
394    int (*func)(unsigned char **p, const unsigned char *start,
395                const unsigned char *buf, size_t bits) =
396        (is_named ? mbedtls_asn1_write_named_bitstring :
397         mbedtls_asn1_write_bitstring);
398#if defined(MBEDTLS_ASN1_PARSE_C)
399    unsigned char *masked_bitstring = NULL;
400#endif /* MBEDTLS_ASN1_PARSE_C */
401
402    /* The API expects `bitstring->x` to contain `bits` bits. */
403    size_t byte_length = (bits + 7) / 8;
404    TEST_ASSERT(bitstring->len >= byte_length);
405
406#if defined(MBEDTLS_ASN1_PARSE_C)
407    TEST_CALLOC(masked_bitstring, byte_length);
408    if (byte_length != 0) {
409        memcpy(masked_bitstring, bitstring->x, byte_length);
410        if (bits % 8 != 0) {
411            masked_bitstring[byte_length - 1] &= ~(0xff >> (bits % 8));
412        }
413    }
414    size_t value_bits = bits;
415    if (is_named) {
416        /* In a named bit string, all trailing 0 bits are removed. */
417        while (byte_length > 0 && masked_bitstring[byte_length - 1] == 0) {
418            --byte_length;
419        }
420        value_bits = 8 * byte_length;
421        if (byte_length > 0) {
422            unsigned char last_byte = masked_bitstring[byte_length - 1];
423            for (unsigned b = 1; b < 0xff && (last_byte & b) == 0; b <<= 1) {
424                --value_bits;
425            }
426        }
427    }
428#endif /* MBEDTLS_ASN1_PARSE_C */
429
430    for (data.size = 0; data.size <= expected->len + 1; data.size++) {
431        if (!generic_write_start_step(&data)) {
432            goto exit;
433        }
434        ret = (*func)(&data.p, data.start, bitstring->x, bits);
435        if (!generic_write_finish_step(&data, expected, ret)) {
436            goto exit;
437        }
438#if defined(MBEDTLS_ASN1_PARSE_C)
439        if (ret >= 0) {
440            mbedtls_asn1_bitstring read = { 0, 0, NULL };
441            TEST_EQUAL(mbedtls_asn1_get_bitstring(&data.p, data.end,
442                                                  &read), 0);
443            TEST_MEMORY_COMPARE(read.p, read.len,
444                                masked_bitstring, byte_length);
445            TEST_EQUAL(read.unused_bits, 8 * byte_length - value_bits);
446        }
447#endif /* MBEDTLS_ASN1_PARSE_C */
448    }
449
450exit:
451    mbedtls_free(data.output);
452#if defined(MBEDTLS_ASN1_PARSE_C)
453    mbedtls_free(masked_bitstring);
454#endif /* MBEDTLS_ASN1_PARSE_C */
455}
456/* END_CASE */
457
458/* BEGIN_CASE */
459void store_named_data_find(data_t *oid0, data_t *oid1,
460                           data_t *oid2, data_t *oid3,
461                           data_t *needle, int from, int position)
462{
463    data_t *oid[4] = { oid0, oid1, oid2, oid3 };
464    mbedtls_asn1_named_data nd[] = {
465        { { 0x06, 0, NULL }, { 0, 0, NULL }, NULL, 0 },
466        { { 0x06, 0, NULL }, { 0, 0, NULL }, NULL, 0 },
467        { { 0x06, 0, NULL }, { 0, 0, NULL }, NULL, 0 },
468        { { 0x06, 0, NULL }, { 0, 0, NULL }, NULL, 0 },
469    };
470    mbedtls_asn1_named_data *pointers[ARRAY_LENGTH(nd) + 1];
471    size_t i;
472    mbedtls_asn1_named_data *head = NULL;
473    mbedtls_asn1_named_data *found = NULL;
474
475    for (i = 0; i < ARRAY_LENGTH(nd); i++) {
476        pointers[i] = &nd[i];
477    }
478    pointers[ARRAY_LENGTH(nd)] = NULL;
479    for (i = 0; i < ARRAY_LENGTH(nd); i++) {
480        TEST_CALLOC(nd[i].oid.p, oid[i]->len);
481        memcpy(nd[i].oid.p, oid[i]->x, oid[i]->len);
482        nd[i].oid.len = oid[i]->len;
483        nd[i].next = pointers[i+1];
484    }
485
486    head = pointers[from];
487    found = mbedtls_asn1_store_named_data(&head,
488                                          (const char *) needle->x,
489                                          needle->len,
490                                          NULL, 0);
491
492    /* In any case, the existing list structure must be unchanged. */
493    for (i = 0; i < ARRAY_LENGTH(nd); i++) {
494        TEST_ASSERT(nd[i].next == pointers[i+1]);
495    }
496
497    if (position >= 0) {
498        /* position should have been found and modified. */
499        TEST_ASSERT(head == pointers[from]);
500        TEST_ASSERT(found == pointers[position]);
501    } else {
502        /* A new entry should have been created. */
503        TEST_ASSERT(found == head);
504        TEST_ASSERT(head->next == pointers[from]);
505        for (i = 0; i < ARRAY_LENGTH(nd); i++) {
506            TEST_ASSERT(found != &nd[i]);
507        }
508    }
509
510exit:
511    if (found != NULL && found == head && found != pointers[from]) {
512        mbedtls_free(found->oid.p);
513        mbedtls_free(found);
514    }
515    for (i = 0; i < ARRAY_LENGTH(nd); i++) {
516        mbedtls_free(nd[i].oid.p);
517    }
518}
519/* END_CASE */
520
521/* BEGIN_CASE */
522void store_named_data_val_found(int old_len, int new_len)
523{
524    mbedtls_asn1_named_data nd =
525    { { 0x06, 3, (unsigned char *) "OID" }, { 0, 0, NULL }, NULL, 0 };
526    mbedtls_asn1_named_data *head = &nd;
527    mbedtls_asn1_named_data *found = NULL;
528    unsigned char *old_val = NULL;
529    unsigned char *new_val = (unsigned char *) "new value";
530
531    if (old_len != 0) {
532        TEST_CALLOC(nd.val.p, (size_t) old_len);
533        old_val = nd.val.p;
534        nd.val.len = old_len;
535        memset(old_val, 'x', old_len);
536    }
537    if (new_len <= 0) {
538        new_len = -new_len;
539        new_val = NULL;
540    }
541
542    found = mbedtls_asn1_store_named_data(&head, "OID", 3,
543                                          new_val, new_len);
544    TEST_ASSERT(head == &nd);
545    TEST_ASSERT(found == head);
546
547    if (new_val != NULL) {
548        TEST_MEMORY_COMPARE(found->val.p, found->val.len,
549                            new_val, (size_t) new_len);
550    }
551    if (new_len == 0) {
552        TEST_ASSERT(found->val.p == NULL);
553    } else if (new_len == old_len) {
554        TEST_ASSERT(found->val.p == old_val);
555    } else {
556        TEST_ASSERT(found->val.p != old_val);
557    }
558
559exit:
560    mbedtls_free(nd.val.p);
561}
562/* END_CASE */
563
564/* BEGIN_CASE */
565void store_named_data_val_new(int new_len, int set_new_val)
566{
567    mbedtls_asn1_named_data *head = NULL;
568    mbedtls_asn1_named_data *found = NULL;
569    const unsigned char *oid = (unsigned char *) "OID";
570    size_t oid_len = strlen((const char *) oid);
571    const unsigned char *new_val = (unsigned char *) "new value";
572
573    if (set_new_val == 0) {
574        new_val = NULL;
575    }
576
577    found = mbedtls_asn1_store_named_data(&head,
578                                          (const char *) oid, oid_len,
579                                          new_val, (size_t) new_len);
580    TEST_ASSERT(found != NULL);
581    TEST_ASSERT(found == head);
582    TEST_ASSERT(found->oid.p != oid);
583    TEST_MEMORY_COMPARE(found->oid.p, found->oid.len, oid, oid_len);
584    if (new_len == 0) {
585        TEST_ASSERT(found->val.p == NULL);
586    } else if (new_val == NULL) {
587        TEST_ASSERT(found->val.p != NULL);
588    } else {
589        TEST_ASSERT(found->val.p != new_val);
590        TEST_MEMORY_COMPARE(found->val.p, found->val.len,
591                            new_val, (size_t) new_len);
592    }
593
594exit:
595    if (found != NULL) {
596        mbedtls_free(found->oid.p);
597        mbedtls_free(found->val.p);
598    }
599    mbedtls_free(found);
600}
601/* END_CASE */
602