1/* BEGIN_HEADER */
2#include <errno.h>
3#include <stdlib.h>
4#include <limits.h>
5
6#include "mbedtls/bignum.h"
7#include "mbedtls/asn1.h"
8#if defined(MBEDTLS_ASN1_WRITE_C)
9#include "mbedtls/asn1write.h"
10#endif
11
12/* Used internally to report an error that indicates a bug in a parsing function. */
13#define ERR_PARSE_INCONSISTENCY INT_MAX
14
15/* Use this magic value in some tests to indicate that the expected result
16 * should not be checked. */
17#define UNPREDICTABLE_RESULT 0x5552
18
19static int nested_parse(unsigned char **const p,
20                        const unsigned char *const end)
21{
22    int ret;
23    size_t len = 0;
24    size_t len2 = 0;
25    unsigned char *const start = *p;
26    unsigned char *content_start;
27    unsigned char tag;
28
29    /* First get the length, skipping over the tag. */
30    content_start = start + 1;
31    ret = mbedtls_asn1_get_len(&content_start, end, &len);
32    TEST_ASSERT(content_start <= end);
33    if (ret != 0) {
34        return ret;
35    }
36
37    /* Since we have a valid element start (tag and length), retrieve and
38     * check the tag. */
39    tag = start[0];
40    TEST_EQUAL(mbedtls_asn1_get_tag(p, end, &len2, tag ^ 1),
41               MBEDTLS_ERR_ASN1_UNEXPECTED_TAG);
42    *p = start;
43    TEST_EQUAL(mbedtls_asn1_get_tag(p, end, &len2, tag), 0);
44    TEST_EQUAL(len, len2);
45    TEST_ASSERT(*p == content_start);
46    *p = content_start;
47
48    switch (tag & 0x1f) {
49        case MBEDTLS_ASN1_BOOLEAN:
50        {
51            int val = -257;
52            *p = start;
53            ret = mbedtls_asn1_get_bool(p, end, &val);
54            if (ret == 0) {
55                TEST_ASSERT(val == 0 || val == 1);
56            }
57            break;
58        }
59
60        case MBEDTLS_ASN1_INTEGER:
61        {
62#if defined(MBEDTLS_BIGNUM_C)
63            mbedtls_mpi mpi;
64            mbedtls_mpi_init(&mpi);
65            *p = start;
66            ret = mbedtls_asn1_get_mpi(p, end, &mpi);
67            mbedtls_mpi_free(&mpi);
68#else
69            *p = start + 1;
70            ret = mbedtls_asn1_get_len(p, end, &len);
71            *p += len;
72#endif
73            /* If we're sure that the number fits in an int, also
74             * call mbedtls_asn1_get_int(). */
75            if (ret == 0 && len < sizeof(int)) {
76                int val = -257;
77                unsigned char *q = start;
78                ret = mbedtls_asn1_get_int(&q, end, &val);
79                TEST_ASSERT(*p == q);
80            }
81            break;
82        }
83
84        case MBEDTLS_ASN1_BIT_STRING:
85        {
86            mbedtls_asn1_bitstring bs;
87            *p = start;
88            ret = mbedtls_asn1_get_bitstring(p, end, &bs);
89            break;
90        }
91
92        case MBEDTLS_ASN1_SEQUENCE:
93        {
94            while (*p <= end && *p < content_start + len && ret == 0) {
95                ret = nested_parse(p, content_start + len);
96            }
97            break;
98        }
99
100        case MBEDTLS_ASN1_OCTET_STRING:
101        case MBEDTLS_ASN1_NULL:
102        case MBEDTLS_ASN1_OID:
103        case MBEDTLS_ASN1_UTF8_STRING:
104        case MBEDTLS_ASN1_SET:
105        case MBEDTLS_ASN1_PRINTABLE_STRING:
106        case MBEDTLS_ASN1_T61_STRING:
107        case MBEDTLS_ASN1_IA5_STRING:
108        case MBEDTLS_ASN1_UTC_TIME:
109        case MBEDTLS_ASN1_GENERALIZED_TIME:
110        case MBEDTLS_ASN1_UNIVERSAL_STRING:
111        case MBEDTLS_ASN1_BMP_STRING:
112        default:
113            /* No further testing implemented for this tag. */
114            *p += len;
115            return 0;
116    }
117
118    TEST_ASSERT(*p <= end);
119    return ret;
120
121exit:
122    return ERR_PARSE_INCONSISTENCY;
123}
124
125int get_len_step(const data_t *input, size_t buffer_size,
126                 size_t actual_length)
127{
128    unsigned char *buf = NULL;
129    unsigned char *p = NULL;
130    unsigned char *end;
131    size_t parsed_length;
132    int ret;
133
134    mbedtls_test_set_step(buffer_size);
135    /* Allocate a new buffer of exactly the length to parse each time.
136     * This gives memory sanitizers a chance to catch buffer overreads. */
137    if (buffer_size == 0) {
138        TEST_CALLOC(buf, 1);
139        end = buf + 1;
140        p = end;
141    } else {
142        TEST_CALLOC_OR_SKIP(buf, buffer_size);
143        if (buffer_size > input->len) {
144            memcpy(buf, input->x, input->len);
145            memset(buf + input->len, 'A', buffer_size - input->len);
146        } else {
147            memcpy(buf, input->x, buffer_size);
148        }
149        p = buf;
150        end = buf + buffer_size;
151    }
152
153    ret = mbedtls_asn1_get_len(&p, end, &parsed_length);
154
155    if (buffer_size >= input->len + actual_length) {
156        TEST_EQUAL(ret, 0);
157        TEST_ASSERT(p == buf + input->len);
158        TEST_EQUAL(parsed_length, actual_length);
159    } else {
160        TEST_EQUAL(ret, MBEDTLS_ERR_ASN1_OUT_OF_DATA);
161    }
162    mbedtls_free(buf);
163    return 1;
164
165exit:
166    mbedtls_free(buf);
167    return 0;
168}
169
170typedef struct {
171    const unsigned char *input_start;
172    const char *description;
173} traverse_state_t;
174
175/* Value returned by traverse_callback if description runs out. */
176#define RET_TRAVERSE_STOP 1
177/* Value returned by traverse_callback if description has an invalid format
178 * (see traverse_sequence_of). */
179#define RET_TRAVERSE_ERROR 2
180
181
182static int traverse_callback(void *ctx, int tag,
183                             unsigned char *content, size_t len)
184{
185    traverse_state_t *state = ctx;
186    size_t offset;
187    const char *rest = state->description;
188    unsigned long n;
189
190    TEST_ASSERT(content > state->input_start);
191    offset = content - state->input_start;
192    mbedtls_test_set_step(offset);
193
194    if (*rest == 0) {
195        return RET_TRAVERSE_STOP;
196    }
197    n = strtoul(rest, (char **) &rest, 0);
198    TEST_EQUAL(n, offset);
199    TEST_EQUAL(*rest, ',');
200    ++rest;
201    n = strtoul(rest, (char **) &rest, 0);
202    TEST_EQUAL(n, (unsigned) tag);
203    TEST_EQUAL(*rest, ',');
204    ++rest;
205    n = strtoul(rest, (char **) &rest, 0);
206    TEST_EQUAL(n, len);
207    if (*rest == ',') {
208        ++rest;
209    }
210
211    state->description = rest;
212    return 0;
213
214exit:
215    return RET_TRAVERSE_ERROR;
216}
217
218/* END_HEADER */
219
220/* BEGIN_DEPENDENCIES
221 * depends_on:MBEDTLS_ASN1_PARSE_C
222 * END_DEPENDENCIES
223 */
224
225/* BEGIN_CASE */
226void parse_prefixes(const data_t *input,
227                    int full_result,
228                    int overfull_result)
229{
230    /* full_result: expected result from parsing the given string. */
231    /* overfull_result: expected_result from parsing the given string plus
232     * some trailing garbage. This may be UNPREDICTABLE_RESULT to accept
233     * any result: use this for invalid inputs that may or may not become
234     * valid depending on what the trailing garbage is. */
235
236    unsigned char *buf = NULL;
237    unsigned char *p = NULL;
238    size_t buffer_size;
239    int ret;
240
241    /* Test every prefix of the input, except the empty string.
242     * The first byte of the string is the tag. Without a tag byte,
243     * we wouldn't know what to parse the input as.
244     * Also test the input followed by an extra byte.
245     */
246    for (buffer_size = 1; buffer_size <= input->len + 1; buffer_size++) {
247        mbedtls_test_set_step(buffer_size);
248        /* Allocate a new buffer of exactly the length to parse each time.
249         * This gives memory sanitizers a chance to catch buffer overreads. */
250        TEST_CALLOC(buf, buffer_size);
251        memcpy(buf, input->x, buffer_size);
252        p = buf;
253        ret = nested_parse(&p, buf + buffer_size);
254
255        if (ret == ERR_PARSE_INCONSISTENCY) {
256            goto exit;
257        }
258        if (buffer_size < input->len) {
259            TEST_EQUAL(ret, MBEDTLS_ERR_ASN1_OUT_OF_DATA);
260        } else if (buffer_size == input->len) {
261            TEST_EQUAL(ret, full_result);
262        } else { /* ( buffer_size > input->len ) */
263            if (overfull_result != UNPREDICTABLE_RESULT) {
264                TEST_EQUAL(ret, overfull_result);
265            }
266        }
267        if (ret == 0) {
268            TEST_ASSERT(p == buf + input->len);
269        }
270
271        mbedtls_free(buf);
272        buf = NULL;
273    }
274
275exit:
276    mbedtls_free(buf);
277}
278/* END_CASE */
279
280/* BEGIN_CASE */
281void get_len(const data_t *input, int actual_length_arg)
282{
283    size_t actual_length = actual_length_arg;
284    size_t buffer_size;
285
286    /* Test prefixes of a buffer containing the given length string
287     * followed by `actual_length` bytes of payload. To save a bit of
288     * time, we skip some "boring" prefixes: we don't test prefixes where
289     * the payload is truncated more than one byte away from either end,
290     * and we only test the empty string on a 1-byte input.
291     */
292    for (buffer_size = 1; buffer_size <= input->len + 1; buffer_size++) {
293        if (!get_len_step(input, buffer_size, actual_length)) {
294            goto exit;
295        }
296    }
297    if (!get_len_step(input, input->len + actual_length - 1, actual_length)) {
298        goto exit;
299    }
300    if (!get_len_step(input, input->len + actual_length, actual_length)) {
301        goto exit;
302    }
303}
304/* END_CASE */
305
306/* BEGIN_CASE */
307void get_boolean(const data_t *input,
308                 int expected_value, int expected_result)
309{
310    unsigned char *p = input->x;
311    int val;
312    int ret;
313    ret = mbedtls_asn1_get_bool(&p, input->x + input->len, &val);
314    TEST_EQUAL(ret, expected_result);
315    if (expected_result == 0) {
316        TEST_EQUAL(val, expected_value);
317        TEST_ASSERT(p == input->x + input->len);
318    }
319}
320/* END_CASE */
321
322/* BEGIN_CASE */
323void empty_integer(const data_t *input)
324{
325    unsigned char *p;
326#if defined(MBEDTLS_BIGNUM_C)
327    mbedtls_mpi actual_mpi;
328#endif
329    int val;
330
331#if defined(MBEDTLS_BIGNUM_C)
332    mbedtls_mpi_init(&actual_mpi);
333#endif
334
335    /* An INTEGER with no content is not valid. */
336    p = input->x;
337    TEST_EQUAL(mbedtls_asn1_get_int(&p, input->x + input->len, &val),
338               MBEDTLS_ERR_ASN1_INVALID_LENGTH);
339
340#if defined(MBEDTLS_BIGNUM_C)
341    /* INTEGERs are sometimes abused as bitstrings, so the library accepts
342     * an INTEGER with empty content and gives it the value 0. */
343    p = input->x;
344    TEST_EQUAL(mbedtls_asn1_get_mpi(&p, input->x + input->len, &actual_mpi),
345               0);
346    TEST_EQUAL(mbedtls_mpi_cmp_int(&actual_mpi, 0), 0);
347#endif
348
349exit:
350#if defined(MBEDTLS_BIGNUM_C)
351    mbedtls_mpi_free(&actual_mpi);
352#endif
353    /*empty cleanup in some configurations*/;
354}
355/* END_CASE */
356
357/* BEGIN_CASE */
358void get_integer(const data_t *input,
359                 const char *expected_hex, int expected_result)
360{
361    unsigned char *p;
362#if defined(MBEDTLS_BIGNUM_C)
363    mbedtls_mpi expected_mpi;
364    mbedtls_mpi actual_mpi;
365    mbedtls_mpi complement;
366    int expected_result_for_mpi = expected_result;
367#endif
368    long expected_value;
369    int expected_result_for_int = expected_result;
370    int val;
371    int ret;
372
373#if defined(MBEDTLS_BIGNUM_C)
374    mbedtls_mpi_init(&expected_mpi);
375    mbedtls_mpi_init(&actual_mpi);
376    mbedtls_mpi_init(&complement);
377#endif
378
379    errno = 0;
380    expected_value = strtol(expected_hex, NULL, 16);
381    if (expected_result == 0 &&
382        (errno == ERANGE
383#if LONG_MAX > INT_MAX
384         || expected_value > INT_MAX || expected_value < INT_MIN
385#endif
386        )) {
387        /* The library returns the dubious error code INVALID_LENGTH
388         * for integers that are out of range. */
389        expected_result_for_int = MBEDTLS_ERR_ASN1_INVALID_LENGTH;
390    }
391    if (expected_result == 0 && expected_value < 0) {
392        /* The library does not support negative INTEGERs and
393         * returns the dubious error code INVALID_LENGTH.
394         * Test that we preserve the historical behavior. If we
395         * decide to change the behavior, we'll also change this test. */
396        expected_result_for_int = MBEDTLS_ERR_ASN1_INVALID_LENGTH;
397    }
398
399    p = input->x;
400    ret = mbedtls_asn1_get_int(&p, input->x + input->len, &val);
401    TEST_EQUAL(ret, expected_result_for_int);
402    if (ret == 0) {
403        TEST_EQUAL(val, expected_value);
404        TEST_ASSERT(p == input->x + input->len);
405    }
406
407#if defined(MBEDTLS_BIGNUM_C)
408    ret = mbedtls_test_read_mpi(&expected_mpi, expected_hex);
409    TEST_ASSERT(ret == 0 || ret == MBEDTLS_ERR_MPI_BAD_INPUT_DATA);
410    if (ret == MBEDTLS_ERR_MPI_BAD_INPUT_DATA) {
411        /* The data overflows the maximum MPI size. */
412        expected_result_for_mpi = MBEDTLS_ERR_MPI_BAD_INPUT_DATA;
413    }
414    p = input->x;
415    ret = mbedtls_asn1_get_mpi(&p, input->x + input->len, &actual_mpi);
416    TEST_EQUAL(ret, expected_result_for_mpi);
417    if (ret == 0) {
418        if (expected_value >= 0) {
419            TEST_ASSERT(mbedtls_mpi_cmp_mpi(&actual_mpi,
420                                            &expected_mpi) == 0);
421        } else {
422            /* The library ignores the sign bit in ASN.1 INTEGERs
423             * (which makes sense insofar as INTEGERs are sometimes
424             * abused as bit strings), so the result of parsing them
425             * is a positive integer such that expected_mpi +
426             * actual_mpi = 2^n where n is the length of the content
427             * of the INTEGER. (Leading ff octets don't matter for the
428             * expected value, but they matter for the actual value.)
429             * Test that we don't change from this behavior. If we
430             * decide to fix the library to change the behavior on
431             * negative INTEGERs, we'll fix this test code. */
432            unsigned char *q = input->x + 1;
433            size_t len;
434            TEST_ASSERT(mbedtls_asn1_get_len(&q, input->x + input->len,
435                                             &len) == 0);
436            TEST_ASSERT(mbedtls_mpi_lset(&complement, 1) == 0);
437            TEST_ASSERT(mbedtls_mpi_shift_l(&complement, len * 8) == 0);
438            TEST_ASSERT(mbedtls_mpi_add_mpi(&complement, &complement,
439                                            &expected_mpi) == 0);
440            TEST_ASSERT(mbedtls_mpi_cmp_mpi(&complement,
441                                            &actual_mpi) == 0);
442        }
443        TEST_ASSERT(p == input->x + input->len);
444    }
445#endif
446
447exit:
448#if defined(MBEDTLS_BIGNUM_C)
449    mbedtls_mpi_free(&expected_mpi);
450    mbedtls_mpi_free(&actual_mpi);
451    mbedtls_mpi_free(&complement);
452#endif
453    /*empty cleanup in some configurations*/;
454}
455/* END_CASE */
456
457/* BEGIN_CASE */
458void get_enum(const data_t *input,
459              const char *expected_hex, int expected_result)
460{
461    unsigned char *p;
462    long expected_value;
463    int expected_result_for_enum = expected_result;
464    int val;
465    int ret;
466
467    errno = 0;
468    expected_value = strtol(expected_hex, NULL, 16);
469    if (expected_result == 0 &&
470        (errno == ERANGE
471#if LONG_MAX > INT_MAX
472         || expected_value > INT_MAX || expected_value < INT_MIN
473#endif
474        )) {
475        /* The library returns the dubious error code INVALID_LENGTH
476         * for integers that are out of range. */
477        expected_result_for_enum = MBEDTLS_ERR_ASN1_INVALID_LENGTH;
478    }
479    if (expected_result == 0 && expected_value < 0) {
480        /* The library does not support negative INTEGERs and
481         * returns the dubious error code INVALID_LENGTH.
482         * Test that we preserve the historical behavior. If we
483         * decide to change the behavior, we'll also change this test. */
484        expected_result_for_enum = MBEDTLS_ERR_ASN1_INVALID_LENGTH;
485    }
486
487    p = input->x;
488    ret = mbedtls_asn1_get_enum(&p, input->x + input->len, &val);
489    TEST_EQUAL(ret, expected_result_for_enum);
490    if (ret == 0) {
491        TEST_EQUAL(val, expected_value);
492        TEST_ASSERT(p == input->x + input->len);
493    }
494}
495/* END_CASE */
496
497/* BEGIN_CASE depends_on:MBEDTLS_BIGNUM_C */
498void get_mpi_too_large()
499{
500    unsigned char *buf = NULL;
501    unsigned char *p;
502    mbedtls_mpi actual_mpi;
503    size_t too_many_octets =
504        MBEDTLS_MPI_MAX_LIMBS * sizeof(mbedtls_mpi_uint) + 1;
505    size_t size = too_many_octets + 6;
506
507    mbedtls_mpi_init(&actual_mpi);
508
509    TEST_CALLOC(buf, size);
510    buf[0] = 0x02; /* tag: INTEGER */
511    buf[1] = 0x84; /* 4-octet length */
512    buf[2] = (too_many_octets >> 24) & 0xff;
513    buf[3] = (too_many_octets >> 16) & 0xff;
514    buf[4] = (too_many_octets >> 8) & 0xff;
515    buf[5] = too_many_octets & 0xff;
516    buf[6] = 0x01; /* most significant octet */
517
518    p = buf;
519    TEST_EQUAL(mbedtls_asn1_get_mpi(&p, buf + size, &actual_mpi),
520               MBEDTLS_ERR_MPI_ALLOC_FAILED);
521
522exit:
523    mbedtls_mpi_free(&actual_mpi);
524    mbedtls_free(buf);
525}
526/* END_CASE */
527
528/* BEGIN_CASE */
529void get_bitstring(const data_t *input,
530                   int expected_length, int expected_unused_bits,
531                   int expected_result, int expected_result_null)
532{
533    mbedtls_asn1_bitstring bs = { 0xdead, 0x21, NULL };
534    unsigned char *p = input->x;
535
536    TEST_EQUAL(mbedtls_asn1_get_bitstring(&p, input->x + input->len, &bs),
537               expected_result);
538    if (expected_result == 0) {
539        TEST_EQUAL(bs.len, (size_t) expected_length);
540        TEST_EQUAL(bs.unused_bits, expected_unused_bits);
541        TEST_ASSERT(bs.p != NULL);
542        TEST_EQUAL(bs.p - input->x + bs.len, input->len);
543        TEST_ASSERT(p == input->x + input->len);
544    }
545
546    p = input->x;
547    TEST_EQUAL(mbedtls_asn1_get_bitstring_null(&p, input->x + input->len,
548                                               &bs.len),
549               expected_result_null);
550    if (expected_result_null == 0) {
551        TEST_EQUAL(bs.len, (size_t) expected_length);
552        if (expected_result == 0) {
553            TEST_ASSERT(p == input->x + input->len - bs.len);
554        }
555    }
556}
557/* END_CASE */
558
559/* BEGIN_CASE */
560void get_sequence_of(const data_t *input, int tag,
561                     const char *description,
562                     int expected_result)
563{
564    /* The description string is a comma-separated list of integers.
565     * For each element in the SEQUENCE in input, description contains
566     * two integers: the offset of the element (offset from the start
567     * of input to the tag of the element) and the length of the
568     * element's contents.
569     * "offset1,length1,..." */
570
571    mbedtls_asn1_sequence head = { { 0, 0, NULL }, NULL };
572    mbedtls_asn1_sequence *cur;
573    unsigned char *p = input->x;
574    const char *rest = description;
575    unsigned long n;
576    unsigned int step = 0;
577
578    TEST_EQUAL(mbedtls_asn1_get_sequence_of(&p, input->x + input->len,
579                                            &head, tag),
580               expected_result);
581    if (expected_result == 0) {
582        TEST_ASSERT(p == input->x + input->len);
583
584        if (!*rest) {
585            TEST_EQUAL(head.buf.tag, 0);
586            TEST_ASSERT(head.buf.p == NULL);
587            TEST_EQUAL(head.buf.len, 0);
588            TEST_ASSERT(head.next == NULL);
589        } else {
590            cur = &head;
591            while (*rest) {
592                mbedtls_test_set_step(step);
593                TEST_ASSERT(cur != NULL);
594                TEST_EQUAL(cur->buf.tag, tag);
595                n = strtoul(rest, (char **) &rest, 0);
596                TEST_EQUAL(n, (size_t) (cur->buf.p - input->x));
597                ++rest;
598                n = strtoul(rest, (char **) &rest, 0);
599                TEST_EQUAL(n, cur->buf.len);
600                if (*rest) {
601                    ++rest;
602                }
603                cur = cur->next;
604                ++step;
605            }
606            TEST_ASSERT(cur == NULL);
607        }
608    }
609
610exit:
611    mbedtls_asn1_sequence_free(head.next);
612}
613/* END_CASE */
614
615/* BEGIN_CASE */
616void traverse_sequence_of(const data_t *input,
617                          int tag_must_mask, int tag_must_val,
618                          int tag_may_mask, int tag_may_val,
619                          const char *description,
620                          int expected_result)
621{
622    /* The description string is a comma-separated list of integers.
623     * For each element in the SEQUENCE in input, description contains
624     * three integers: the offset of the element's content (offset from
625     * the start of input to the content of the element), the element's tag,
626     * and the length of the element's contents.
627     * "offset1,tag1,length1,..." */
628
629    unsigned char *p = input->x;
630    traverse_state_t traverse_state = { input->x, description };
631    int ret;
632
633    ret = mbedtls_asn1_traverse_sequence_of(&p, input->x + input->len,
634                                            (uint8_t) tag_must_mask, (uint8_t) tag_must_val,
635                                            (uint8_t) tag_may_mask, (uint8_t) tag_may_val,
636                                            traverse_callback, &traverse_state);
637    if (ret == RET_TRAVERSE_ERROR) {
638        goto exit;
639    }
640    TEST_EQUAL(ret, expected_result);
641    TEST_EQUAL(*traverse_state.description, 0);
642}
643/* END_CASE */
644
645/* BEGIN_CASE */
646void get_alg(const data_t *input,
647             int oid_offset, int oid_length,
648             int params_tag, int params_offset, int params_length,
649             int total_length,
650             int expected_result)
651{
652    mbedtls_asn1_buf oid = { -1, 0, NULL };
653    mbedtls_asn1_buf params = { -1, 0, NULL };
654    unsigned char *p = input->x;
655    int ret;
656
657    TEST_EQUAL(mbedtls_asn1_get_alg(&p, input->x + input->len,
658                                    &oid, &params),
659               expected_result);
660    if (expected_result == 0) {
661        TEST_EQUAL(oid.tag, MBEDTLS_ASN1_OID);
662        TEST_EQUAL(oid.p - input->x, oid_offset);
663        TEST_EQUAL(oid.len, (size_t) oid_length);
664        TEST_EQUAL(params.tag, params_tag);
665        if (params_offset != 0) {
666            TEST_EQUAL(params.p - input->x, params_offset);
667        } else {
668            TEST_ASSERT(params.p == NULL);
669        }
670        TEST_EQUAL(params.len, (size_t) params_length);
671        TEST_EQUAL(p - input->x, total_length);
672    }
673
674    ret = mbedtls_asn1_get_alg_null(&p, input->x + input->len, &oid);
675    if (expected_result == 0 && params_offset == 0) {
676        TEST_EQUAL(oid.tag, MBEDTLS_ASN1_OID);
677        TEST_EQUAL(oid.p - input->x, oid_offset);
678        TEST_EQUAL(oid.len, (size_t) oid_length);
679        TEST_EQUAL(p - input->x, total_length);
680    } else {
681        TEST_ASSERT(ret != 0);
682    }
683}
684/* END_CASE */
685
686/* BEGIN_CASE */
687void find_named_data(data_t *oid0, data_t *oid1, data_t *oid2, data_t *oid3,
688                     data_t *needle, int from, int position)
689{
690    mbedtls_asn1_named_data nd[] = {
691        { { 0x06, oid0->len, oid0->x }, { 0, 0, NULL }, NULL, 0 },
692        { { 0x06, oid1->len, oid1->x }, { 0, 0, NULL }, NULL, 0 },
693        { { 0x06, oid2->len, oid2->x }, { 0, 0, NULL }, NULL, 0 },
694        { { 0x06, oid3->len, oid3->x }, { 0, 0, NULL }, NULL, 0 },
695    };
696    mbedtls_asn1_named_data *pointers[ARRAY_LENGTH(nd) + 1];
697    size_t i;
698    const mbedtls_asn1_named_data *found;
699
700    for (i = 0; i < ARRAY_LENGTH(nd); i++) {
701        pointers[i] = &nd[i];
702    }
703    pointers[ARRAY_LENGTH(nd)] = NULL;
704    for (i = 0; i < ARRAY_LENGTH(nd); i++) {
705        nd[i].next = pointers[i+1];
706    }
707
708    found = mbedtls_asn1_find_named_data((const mbedtls_asn1_named_data *) pointers[from],
709                                         (const char *) needle->x,
710                                         needle->len);
711    TEST_ASSERT(found == pointers[position]);
712}
713/* END_CASE */
714
715/* BEGIN_CASE depends_on:!MBEDTLS_DEPRECATED_REMOVED:!MBEDTLS_DEPRECATED_WARNING */
716void free_named_data_null()
717{
718    mbedtls_asn1_free_named_data(NULL);
719    goto exit; /* Silence unused label warning */
720}
721/* END_CASE */
722
723/* BEGIN_CASE depends_on:!MBEDTLS_DEPRECATED_REMOVED:!MBEDTLS_DEPRECATED_WARNING */
724void free_named_data(int with_oid, int with_val, int with_next)
725{
726    mbedtls_asn1_named_data next =
727    { { 0x06, 0, NULL }, { 0, 0xcafe, NULL }, NULL, 0 };
728    mbedtls_asn1_named_data head =
729    { { 0x06, 0, NULL }, { 0, 0, NULL }, NULL, 0 };
730
731    if (with_oid) {
732        TEST_CALLOC(head.oid.p, 1);
733    }
734    if (with_val) {
735        TEST_CALLOC(head.val.p, 1);
736    }
737    if (with_next) {
738        head.next = &next;
739    }
740
741    mbedtls_asn1_free_named_data(&head);
742    TEST_ASSERT(head.oid.p == NULL);
743    TEST_ASSERT(head.val.p == NULL);
744    TEST_ASSERT(head.next == NULL);
745    TEST_ASSERT(next.val.len == 0xcafe);
746
747exit:
748    mbedtls_free(head.oid.p);
749    mbedtls_free(head.val.p);
750}
751/* END_CASE */
752
753/* BEGIN_CASE */
754void free_named_data_list(int length)
755{
756    mbedtls_asn1_named_data *head = NULL;
757    int i;
758
759    for (i = 0; i < length; i++) {
760        mbedtls_asn1_named_data *new = NULL;
761        TEST_CALLOC(new, 1);
762        new->next = head;
763        head = new;
764    }
765
766    mbedtls_asn1_free_named_data_list(&head);
767    TEST_ASSERT(head == NULL);
768    /* Most of the point of the test is that it doesn't leak memory.
769     * So this test is only really useful under a memory leak detection
770     * framework. */
771exit:
772    mbedtls_asn1_free_named_data_list(&head);
773}
774/* END_CASE */
775