mbedtls/tests/suites/test_suite_asn1parse.function

/* BEGIN_HEADER */
#include <errno.h>
#include <stdlib.h>
#include <limits.h>

#include "mbedtls/bignum.h"
#include "mbedtls/asn1.h"
#if defined(MBEDTLS_ASN1_WRITE_C)
#include "mbedtls/asn1write.h"
#endif

#define ERR_PARSE_INCONSISTENCY INT_MAX

static int nested_parse( unsigned char **const p,
                         const unsigned char *const end )
{
    int ret;
    size_t len = 0;
    size_t len2 = 0;
    unsigned char *const start = *p;
    unsigned char *content_start;
    unsigned char tag;

    /* First get the length, skipping over the tag. */
    content_start = start + 1;
    ret = mbedtls_asn1_get_len( &content_start, end, &len );
    TEST_ASSERT( content_start <= end );
    if( ret != 0 )
        return( ret );

    /* Since we have a valid element start (tag and length), retrieve and
     * check the tag. */
    tag = start[0];
    TEST_EQUAL( mbedtls_asn1_get_tag( p, end, &len2, tag ^ 1 ),
                MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
    *p = start;
    TEST_EQUAL( mbedtls_asn1_get_tag( p, end, &len2, tag ), 0 );
    TEST_EQUAL( len, len2 );
    TEST_ASSERT( *p == content_start );
    *p = content_start;

    switch( tag & 0x1f )
    {
        case MBEDTLS_ASN1_BOOLEAN:
        {
            int val = -257;
            *p = start;
            ret = mbedtls_asn1_get_bool( p, end, &val );
            if( ret == 0 )
                TEST_ASSERT( val == 0 || val == 1 );
            break;
        }

        case MBEDTLS_ASN1_INTEGER:
        {
#if defined(MBEDTLS_BIGNUM_C)
            mbedtls_mpi mpi;
            mbedtls_mpi_init( &mpi );
            *p = start;
            ret = mbedtls_asn1_get_mpi( p, end, &mpi );
            mbedtls_mpi_free( &mpi );
#else
            *p = start + 1;
            ret = mbedtls_asn1_get_len( p, end, &len );
            *p += len;
#endif
            /* If we're sure that the number fits in an int, also
             * call mbedtls_asn1_get_int(). */
            if( ret == 0 && len < sizeof( int ) )
            {
                int val = -257;
                unsigned char *q = start;
                ret = mbedtls_asn1_get_int( &q, end, &val );
                TEST_ASSERT( *p == q );
            }
            break;
        }

        case MBEDTLS_ASN1_BIT_STRING:
        {
            mbedtls_asn1_bitstring bs;
            *p = start;
            ret = mbedtls_asn1_get_bitstring( p, end, &bs );
            break;
        }

        case MBEDTLS_ASN1_SEQUENCE:
        {
            while( *p <= end && *p < content_start + len && ret == 0 )
                ret = nested_parse( p, content_start + len );
            break;
        }

        case MBEDTLS_ASN1_OCTET_STRING:
        case MBEDTLS_ASN1_NULL:
        case MBEDTLS_ASN1_OID:
        case MBEDTLS_ASN1_UTF8_STRING:
        case MBEDTLS_ASN1_SET:
        case MBEDTLS_ASN1_PRINTABLE_STRING:
        case MBEDTLS_ASN1_T61_STRING:
        case MBEDTLS_ASN1_IA5_STRING:
        case MBEDTLS_ASN1_UTC_TIME:
        case MBEDTLS_ASN1_GENERALIZED_TIME:
        case MBEDTLS_ASN1_UNIVERSAL_STRING:
        case MBEDTLS_ASN1_BMP_STRING:
        default:
            /* No further testing implemented for this tag. */
            *p += len;
            return( 0 );
    }

    TEST_ASSERT( *p <= end );
    return( ret );

exit:
    return( ERR_PARSE_INCONSISTENCY );
}

int get_len_step( const data_t *input, size_t buffer_size,
                  size_t actual_length )
{
    unsigned char *buf = NULL;
    unsigned char *p = NULL;
    size_t parsed_length;
    int ret;

    test_set_step( buffer_size );
    /* Allocate a new buffer of exactly the length to parse each time.
     * This gives memory sanitizers a chance to catch buffer overreads. */
    if( buffer_size == 0 )
    {
        ASSERT_ALLOC( buf, 1 );
        p = buf + 1;
    }
    else
    {
        ASSERT_ALLOC_WEAK( buf, buffer_size );
        if( buffer_size > input->len )
        {
            memcpy( buf, input->x, input->len );
            memset( buf + input->len, 'A', buffer_size - input->len );
        }
        else
        {
            memcpy( buf, input->x, buffer_size );
        }
        p = buf;
    }

    ret = mbedtls_asn1_get_len( &p, buf + buffer_size, &parsed_length );

    if( buffer_size >= input->len + actual_length )
    {
        TEST_EQUAL( ret, 0 );
        TEST_ASSERT( p == buf + input->len );
        TEST_EQUAL( parsed_length, actual_length );
    }
    else
    {
        TEST_EQUAL( ret, MBEDTLS_ERR_ASN1_OUT_OF_DATA );
    }
    mbedtls_free( buf );
    return( 1 );

exit:
    mbedtls_free( buf );
    return( 0 );
}

/* END_HEADER */

/* BEGIN_DEPENDENCIES
 * depends_on:MBEDTLS_ASN1_PARSE_C
 * END_DEPENDENCIES
 */

/* BEGIN_CASE */
void parse_prefixes( const data_t *input,
                     int actual_length_arg,
                     int last_result )
{
    size_t actual_length = actual_length_arg;
    unsigned char *buf = NULL;
    unsigned char *p = NULL;
    size_t buffer_size;
    int ret;

    /* Test every prefix of the input, except the empty string.
     * The first byte of the string is the tag. Without a tag byte,
     * we wouldn't know what to parse the input as.
     */
    for( buffer_size = 1; buffer_size <= input->len; buffer_size++ )
    {
        test_set_step( buffer_size );
        /* Allocate a new buffer of exactly the length to parse each time.
         * This gives memory sanitizers a chance to catch buffer overreads. */
        ASSERT_ALLOC( buf, buffer_size );
        memcpy( buf, input->x, buffer_size );
        p = buf;
        ret = nested_parse( &p, buf + buffer_size );
        if( ret == ERR_PARSE_INCONSISTENCY )
            goto exit;
        if( actual_length > 0 && buffer_size >= actual_length )
        {
            TEST_EQUAL( ret, last_result );
            if( ret == 0 )
                TEST_ASSERT( p == buf + actual_length );
        }
        else
        {
            TEST_EQUAL( ret, MBEDTLS_ERR_ASN1_OUT_OF_DATA );
        }
        mbedtls_free( buf );
        buf = NULL;
    }

exit:
    mbedtls_free( buf );
}
/* END_CASE */

/* BEGIN_CASE */
void get_len( const data_t *input, int actual_length_arg )
{
    size_t actual_length = actual_length_arg;
    size_t buffer_size;

    /* Test prefixes of a buffer containing the given length string
     * followed by `actual_length` bytes of payload. To save a bit of
     * time, we skip some "boring" prefixes: we don't test prefixes where
     * the payload is truncated more than one byte away from either end,
     * and we only test the empty string on a 1-byte input.
     */
    for( buffer_size = 1; buffer_size <= input->len + 1; buffer_size++ )
    {
        if( ! get_len_step( input, buffer_size, actual_length ) )
            goto exit;
    }
    if( ! get_len_step( input, input->len + actual_length - 1, actual_length ) )
        goto exit;
    if( ! get_len_step( input, input->len + actual_length, actual_length ) )
        goto exit;
}
/* END_CASE */

/* BEGIN_CASE */
void get_boolean( const data_t *input,
                  int expected_value, int expected_result )
{
    unsigned char *p = input->x;
    int val;
    int ret;
    ret = mbedtls_asn1_get_bool( &p, input->x + input->len, &val );
    TEST_EQUAL( ret, expected_result );
    if( expected_result == 0 )
    {
        TEST_EQUAL( val, expected_value );
        TEST_ASSERT( p == input->x + input->len );
    }
}
/* END_CASE */

/* BEGIN_CASE */
void empty_integer( const data_t *input )
{
    unsigned char *p;
#if defined(MBEDTLS_BIGNUM_C)
    mbedtls_mpi actual_mpi;
#endif
    int val;

#if defined(MBEDTLS_BIGNUM_C)
    mbedtls_mpi_init( & actual_mpi );
#endif

    /* An INTEGER with no content is not valid. */
    p = input->x;
    TEST_EQUAL( mbedtls_asn1_get_int( &p, input->x + input->len, &val ),
                MBEDTLS_ERR_ASN1_INVALID_LENGTH );

#if defined(MBEDTLS_BIGNUM_C)
    /* INTEGERs are sometimes abused as bitstrings, so the library accepts
     * an INTEGER with empty content and gives it the value 0. */
    p = input->x;
    TEST_EQUAL( mbedtls_asn1_get_mpi( &p, input->x + input->len, &actual_mpi ),
                0 );
    TEST_EQUAL( mbedtls_mpi_cmp_int( &actual_mpi, 0 ), 0 );
#endif

exit:
#if defined(MBEDTLS_BIGNUM_C)
    mbedtls_mpi_free( &actual_mpi );
#endif
    /*empty cleanup in some configurations*/ ;
}
/* END_CASE */

/* BEGIN_CASE */
void get_integer( const data_t *input,
                  const char *expected_hex, int expected_result )
{
    unsigned char *p;
#if defined(MBEDTLS_BIGNUM_C)
    mbedtls_mpi expected_mpi;
    mbedtls_mpi actual_mpi;
    mbedtls_mpi complement;
    int expected_result_for_mpi = expected_result;
#endif
    long expected_value;
    int expected_result_for_int = expected_result;
    int val;
    int ret;

#if defined(MBEDTLS_BIGNUM_C)
    mbedtls_mpi_init( &expected_mpi );
    mbedtls_mpi_init( &actual_mpi );
    mbedtls_mpi_init( &complement );
#endif

    errno = 0;
    expected_value = strtol( expected_hex, NULL, 16 );
    if( expected_result == 0 &&
        ( errno == ERANGE
#if LONG_MAX > INT_MAX
          || expected_value > INT_MAX || expected_value < INT_MIN
#endif
            ) )
    {
        /* The library returns the dubious error code INVALID_LENGTH
         * for integers that are out of range. */
        expected_result_for_int = MBEDTLS_ERR_ASN1_INVALID_LENGTH;
    }
    if( expected_result == 0 && expected_value < 0 )
    {
        /* The library does not support negative INTEGERs and
         * returns the dubious error code INVALID_LENGTH.
         * Test that we preserve the historical behavior. If we
         * decide to change the behavior, we'll also change this test. */
        expected_result_for_int = MBEDTLS_ERR_ASN1_INVALID_LENGTH;
    }

    p = input->x;
    ret = mbedtls_asn1_get_int( &p, input->x + input->len, &val );
    TEST_EQUAL( ret, expected_result_for_int );
    if( ret == 0 )
    {
        TEST_EQUAL( val, expected_value );
        TEST_ASSERT( p == input->x + input->len );
    }

#if defined(MBEDTLS_BIGNUM_C)
    ret = mbedtls_mpi_read_string( &expected_mpi, 16, expected_hex );
    TEST_ASSERT( ret == 0 || ret == MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
    if( ret == MBEDTLS_ERR_MPI_BAD_INPUT_DATA )
    {
        /* The data overflows the maximum MPI size. */
        expected_result_for_mpi = MBEDTLS_ERR_MPI_BAD_INPUT_DATA;
    }
    p = input->x;
    ret = mbedtls_asn1_get_mpi( &p, input->x + input->len, &actual_mpi );
    TEST_EQUAL( ret, expected_result_for_mpi );
    if( ret == 0 )
    {
        if( expected_value >= 0 )
        {
            TEST_ASSERT( mbedtls_mpi_cmp_mpi( &actual_mpi,
                                              &expected_mpi ) == 0 );
        }
        else
        {
            /* The library ignores the sign bit in ASN.1 INTEGERs
             * (which makes sense insofar as INTEGERs are sometimes
             * abused as bit strings), so the result of parsing them
             * is a positive integer such that expected_mpi +
             * actual_mpi = 2^n where n is the length of the content
             * of the INTEGER. (Leading ff octets don't matter for the
             * expected value, but they matter for the actual value.)
             * Test that we don't change from this behavior. If we
             * decide to fix the library to change the behavior on
             * negative INTEGERs, we'll fix this test code. */
            unsigned char *q = input->x + 1;
            size_t len;
            TEST_ASSERT( mbedtls_asn1_get_len( &q, input->x + input->len,
                                               &len ) == 0 );
            TEST_ASSERT( mbedtls_mpi_lset( &complement, 1 ) == 0 );
            TEST_ASSERT( mbedtls_mpi_shift_l( &complement, len * 8 ) == 0 );
            TEST_ASSERT( mbedtls_mpi_add_mpi( &complement, &complement,
                                              &expected_mpi ) == 0 );
            TEST_ASSERT( mbedtls_mpi_cmp_mpi( &complement,
                                              &actual_mpi ) == 0 );
        }
        TEST_ASSERT( p == input->x + input->len );
    }
#endif

exit:
#if defined(MBEDTLS_BIGNUM_C)
    mbedtls_mpi_free( &expected_mpi );
    mbedtls_mpi_free( &actual_mpi );
    mbedtls_mpi_free( &complement );
#endif
    /*empty cleanup in some configurations*/ ;
}
/* END_CASE */

/* BEGIN_CASE */
void get_enum( const data_t *input,
               const char *expected_hex, int expected_result )
{
    unsigned char *p;
    long expected_value;
    int expected_result_for_enum = expected_result;
    int val;
    int ret;

    errno = 0;
    expected_value = strtol( expected_hex, NULL, 16 );
    if( expected_result == 0 &&
        ( errno == ERANGE
#if LONG_MAX > INT_MAX
          || expected_value > INT_MAX || expected_value < INT_MIN
#endif
            ) )
    {
        /* The library returns the dubious error code INVALID_LENGTH
         * for integers that are out of range. */
        expected_result_for_enum = MBEDTLS_ERR_ASN1_INVALID_LENGTH;
    }
    if( expected_result == 0 && expected_value < 0 )
    {
        /* The library does not support negative INTEGERs and
         * returns the dubious error code INVALID_LENGTH.
         * Test that we preserve the historical behavior. If we
         * decide to change the behavior, we'll also change this test. */
        expected_result_for_enum = MBEDTLS_ERR_ASN1_INVALID_LENGTH;
    }

    p = input->x;
    ret = mbedtls_asn1_get_enum( &p, input->x + input->len, &val );
    TEST_EQUAL( ret, expected_result_for_enum );
    if( ret == 0 )
    {
        TEST_EQUAL( val, expected_value );
        TEST_ASSERT( p == input->x + input->len );
    }
}
/* END_CASE */

/* BEGIN_CASE depends_on:MBEDTLS_BIGNUM_C */
void get_mpi_too_large( )
{
    unsigned char *buf = NULL;
    unsigned char *p;
    mbedtls_mpi actual_mpi;
    size_t too_many_octets =
        MBEDTLS_MPI_MAX_LIMBS * sizeof(mbedtls_mpi_uint) + 1;
    size_t size = too_many_octets + 6;

    mbedtls_mpi_init( &actual_mpi );

    ASSERT_ALLOC( buf, size );
    buf[0] = 0x02; /* tag: INTEGER */
    buf[1] = 0x84; /* 4-octet length */
    buf[2] = ( too_many_octets >> 24 ) & 0xff;
    buf[3] = ( too_many_octets >> 16 ) & 0xff;
    buf[4] = ( too_many_octets >> 8 ) & 0xff;
    buf[5] = too_many_octets & 0xff;
    buf[6] = 0x01; /* most significant octet */

    p = buf;
    TEST_EQUAL( mbedtls_asn1_get_mpi( &p, buf + size, &actual_mpi ),
                MBEDTLS_ERR_MPI_ALLOC_FAILED );

exit:
    mbedtls_mpi_free( &actual_mpi );
    mbedtls_free( buf );
}
/* END_CASE */

/* BEGIN_CASE */
void get_bitstring( const data_t *input,
                    int expected_length, int expected_unused_bits,
                    int expected_result, int expected_result_null )
{
    mbedtls_asn1_bitstring bs = { 0xdead, 0x21, NULL };
    unsigned char *p = input->x;

    TEST_EQUAL( mbedtls_asn1_get_bitstring( &p, input->x + input->len, &bs ),
                expected_result );
    if( expected_result == 0 )
    {
        TEST_EQUAL( bs.len, (size_t) expected_length );
        TEST_EQUAL( bs.unused_bits, expected_unused_bits );
        TEST_ASSERT( bs.p != NULL );
        TEST_EQUAL( bs.p - input->x + bs.len, input->len );
        TEST_ASSERT( p == input->x + input->len );
    }

    p = input->x;
    TEST_EQUAL( mbedtls_asn1_get_bitstring_null( &p, input->x + input->len,
                                                 &bs.len ),
                expected_result_null );
    if( expected_result_null == 0 )
    {
        TEST_EQUAL( bs.len, (size_t) expected_length );
        if( expected_result == 0 )
            TEST_ASSERT( p == input->x + input->len - bs.len );
    }
}
/* END_CASE */

/* BEGIN_CASE */
void get_sequence_of( const data_t *input, int tag,
                      const char *description,
                      int expected_result )
{
    mbedtls_asn1_sequence head = { { 0, 0, NULL }, NULL };
    mbedtls_asn1_sequence *cur, *next;
    unsigned char *p = input->x;
    const char *rest = description;
    unsigned long n;

    TEST_EQUAL( mbedtls_asn1_get_sequence_of( &p, input->x + input->len,
                                              &head, tag ),
                expected_result );
    if( expected_result == 0 )
    {
        TEST_ASSERT( p == input->x + input->len );

        if( ! *rest )
        {
            TEST_EQUAL( head.buf.tag, 0 );
            TEST_ASSERT( head.buf.p == NULL );
            TEST_EQUAL( head.buf.len, 0 );
            TEST_ASSERT( head.next == NULL );
        }
        else
        {
            cur = &head;
            while( *rest )
            {
                ++test_info.step;
                TEST_ASSERT( cur != NULL );
                TEST_EQUAL( cur->buf.tag, tag );
                n = strtoul( rest, (char **) &rest, 0 );
                TEST_EQUAL( n, (size_t)( cur->buf.p - input->x ) );
                ++rest;
                n = strtoul( rest, (char **) &rest, 0 );
                TEST_EQUAL( n, cur->buf.len );
                if( *rest )
                    ++rest;
                cur = cur->next;
            }
            TEST_ASSERT( cur == NULL );
        }
    }

exit:
    cur = head.next;
    while( cur != NULL )
    {
        next = cur->next;
        mbedtls_free( cur );
        cur = next;
    }
}
/* END_CASE */

/* BEGIN_CASE */
void get_alg( const data_t *input,
              int oid_offset, int oid_length,
              int params_tag, int params_offset, int params_length,
              int total_length,
              int expected_result )
{
    mbedtls_asn1_buf oid = { -1, 0, NULL };
    mbedtls_asn1_buf params = { -1, 0, NULL };
    unsigned char *p = input->x;
    int ret;

    TEST_EQUAL( mbedtls_asn1_get_alg( &p, input->x + input->len,
                                      &oid, &params ),
                expected_result );
    if( expected_result == 0 )
    {
        TEST_EQUAL( oid.tag, MBEDTLS_ASN1_OID );
        TEST_EQUAL( oid.p - input->x, oid_offset );
        TEST_EQUAL( oid.len, (size_t) oid_length );
        TEST_EQUAL( params.tag, params_tag );
        if( params_offset != 0 )
            TEST_EQUAL( params.p - input->x, params_offset );
        else
            TEST_ASSERT( params.p == NULL );
        TEST_EQUAL( params.len, (size_t) params_length );
        TEST_EQUAL( p - input->x, total_length );
    }

    ret = mbedtls_asn1_get_alg_null( &p, input->x + input->len, &oid );
    if( expected_result == 0 && params_offset == 0 )
    {
        TEST_EQUAL( oid.tag, MBEDTLS_ASN1_OID );
        TEST_EQUAL( oid.p - input->x, oid_offset );
        TEST_EQUAL( oid.len, (size_t) oid_length );
        TEST_EQUAL( p - input->x, total_length );
    }
    else
        TEST_ASSERT( ret != 0 );
}
/* END_CASE */

/* BEGIN_CASE */
void find_named_data( data_t *oid0, data_t *oid1, data_t *oid2, data_t *oid3,
                      data_t *needle, int from, int position )
{
    mbedtls_asn1_named_data nd[] ={
        { {0x06, oid0->len, oid0->x}, {0, 0, NULL}, NULL, 0 },
        { {0x06, oid1->len, oid1->x}, {0, 0, NULL}, NULL, 0 },
        { {0x06, oid2->len, oid2->x}, {0, 0, NULL}, NULL, 0 },
        { {0x06, oid3->len, oid3->x}, {0, 0, NULL}, NULL, 0 },
    };
    mbedtls_asn1_named_data *pointers[ARRAY_LENGTH( nd ) + 1];
    size_t i;
    mbedtls_asn1_named_data *found;

    for( i = 0; i < ARRAY_LENGTH( nd ); i++ )
        pointers[i] = &nd[i];
    pointers[ARRAY_LENGTH( nd )] = NULL;
    for( i = 0; i < ARRAY_LENGTH( nd ); i++ )
        nd[i].next = pointers[i+1];

    found = mbedtls_asn1_find_named_data( pointers[from],
                                          (const char *) needle->x,
                                          needle->len );
    TEST_ASSERT( found == pointers[position] );
}
/* END_CASE */

/* BEGIN_CASE */
void free_named_data_null( )
{
    mbedtls_asn1_free_named_data( NULL );
    goto exit; /* Silence unused label warning */
}
/* END_CASE */

/* BEGIN_CASE */
void free_named_data( int with_oid, int with_val, int with_next )
{
    mbedtls_asn1_named_data next =
        { {0x06, 0, NULL}, {0, 0xcafe, NULL}, NULL, 0 };
    mbedtls_asn1_named_data head =
        { {0x06, 0, NULL}, {0, 0, NULL}, NULL, 0 };

    if( with_oid )
        ASSERT_ALLOC( head.oid.p, 1 );
    if( with_val )
        ASSERT_ALLOC( head.val.p, 1 );
    if( with_next )
        head.next = &next;

    mbedtls_asn1_free_named_data( &head );
    TEST_ASSERT( head.oid.p == NULL );
    TEST_ASSERT( head.val.p == NULL );
    TEST_ASSERT( head.next == NULL );
    TEST_ASSERT( next.val.len == 0xcafe );

exit:
    mbedtls_free( head.oid.p );
    mbedtls_free( head.val.p );
}
/* END_CASE */

/* BEGIN_CASE */
void free_named_data_list( int length )
{
    mbedtls_asn1_named_data *head = NULL;
    int i;

    for( i = 0; i < length; i++ )
    {
        mbedtls_asn1_named_data *new = NULL;
        ASSERT_ALLOC( new, sizeof( mbedtls_asn1_named_data ) );
        new->next = head;
        head = new;
    }

    mbedtls_asn1_free_named_data_list( &head );
    TEST_ASSERT( head == NULL );
    /* Most of the point of the test is that it doesn't leak memory.
     * So this test is only really useful under a memory leak detection
     * framework. */
exit:
    mbedtls_asn1_free_named_data_list( &head );
}
/* END_CASE */