tests/suites/test_suite_asn1write.function - mirror/mbed-tls.git - TrustedFirmware Git Browser

 /* BEGIN_HEADER */
 #include "mbedtls/asn1write.h"

 #define GUARD_LEN 4
 #define GUARD_VAL 0x2a

 typedef struct
 {
     unsigned char *output;
     unsigned char *start;
     unsigned char *end;
     unsigned char *p;
     size_t size;
 } generic_write_data_t;

 int generic_write_start_step( generic_write_data_t *data )
 {
     mbedtls_test_set_step( data->size );
     ASSERT_ALLOC( data->output, data->size == 0 ? 1 : data->size );
     data->end = data->output + data->size;
     data->p = data->end;
     data->start = data->end - data->size;
     return( 1 );
 exit:
     return( 0 );
 }

 int generic_write_finish_step( generic_write_data_t *data,
                                const data_t *expected, int ret )
 {
     int ok = 0;

     if( data->size < expected->len )
     {
         TEST_EQUAL( ret, MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
     }
     else
     {
         TEST_EQUAL( ret, data->end - data->p );
         TEST_ASSERT( data->p >= data->start );
         TEST_ASSERT( data->p <= data->end );
         ASSERT_COMPARE( data->p, (size_t)( data->end - data->p ),
                         expected->x, expected->len );
     }
     ok = 1;

 exit:
     mbedtls_free( data->output );
     data->output = NULL;
     return( ok );
 }

 /* END_HEADER */

 /* BEGIN_DEPENDENCIES
  * depends_on:MBEDTLS_ASN1_WRITE_C
  * END_DEPENDENCIES
  */

 /* BEGIN_CASE */
 void mbedtls_asn1_write_null( data_t *expected )
 {
     generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 };
     int ret;

     for( data.size = 0; data.size < expected->len + 1; data.size++ )
     {
         if( ! generic_write_start_step( &data ) )
             goto exit;
         ret = mbedtls_asn1_write_null( &data.p, data.start );
         if( ! generic_write_finish_step( &data, expected, ret ) )
             goto exit;
     }

 exit:
     mbedtls_free( data.output );
 }
 /* END_CASE */

 /* BEGIN_CASE */
 void mbedtls_asn1_write_bool( int val, data_t *expected )
 {
     generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 };
     int ret;

     for( data.size = 0; data.size < expected->len + 1; data.size++ )
     {
         if( ! generic_write_start_step( &data ) )
             goto exit;
         ret = mbedtls_asn1_write_bool( &data.p, data.start, val );
         if( ! generic_write_finish_step( &data, expected, ret ) )
             goto exit;
     }

 exit:
     mbedtls_free( data.output );
 }
 /* END_CASE */

 /* BEGIN_CASE */
 void mbedtls_asn1_write_int( int val, data_t *expected )
 {
     generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 };
     int ret;

     for( data.size = 0; data.size < expected->len + 1; data.size++ )
     {
         if( ! generic_write_start_step( &data ) )
             goto exit;
         ret = mbedtls_asn1_write_int( &data.p, data.start, val );
         if( ! generic_write_finish_step( &data, expected, ret ) )
             goto exit;
     }

 exit:
     mbedtls_free( data.output );
 }
 /* END_CASE */


 /* BEGIN_CASE */
 void mbedtls_asn1_write_enum( int val, data_t *expected )
 {
     generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 };
     int ret;

     for( data.size = 0; data.size < expected->len + 1; data.size++ )
     {
         if( ! generic_write_start_step( &data ) )
             goto exit;
         ret = mbedtls_asn1_write_enum( &data.p, data.start, val );
         if( ! generic_write_finish_step( &data, expected, ret ) )
             goto exit;
     }

 exit:
     mbedtls_free( data.output );
 }
 /* END_CASE */

 /* BEGIN_CASE depends_on:MBEDTLS_BIGNUM_C */
 void mbedtls_asn1_write_mpi( data_t *val, data_t *expected )
 {
     generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 };
     mbedtls_mpi mpi;
     int ret;

     mbedtls_mpi_init( &mpi );
     TEST_ASSERT( mbedtls_mpi_read_binary( &mpi, val->x, val->len ) == 0 );

     for( data.size = 0; data.size < expected->len + 1; data.size++ )
     {
         if( ! generic_write_start_step( &data ) )
             goto exit;
         ret = mbedtls_asn1_write_mpi( &data.p, data.start, &mpi );
         if( ! generic_write_finish_step( &data, expected, ret ) )
             goto exit;
         if( expected->len > 10 && data.size == 8 )
             data.size = expected->len - 2;
     }

 exit:
     mbedtls_mpi_free( &mpi );
     mbedtls_free( data.output );
 }
 /* END_CASE */

 /* BEGIN_CASE */
 void mbedtls_asn1_write_string( int tag, data_t *content, data_t *expected )
 {
     generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 };
     int ret;

     for( data.size = 0; data.size < expected->len + 1; data.size++ )
     {
         if( ! generic_write_start_step( &data ) )
             goto exit;
         switch( tag )
         {
             case MBEDTLS_ASN1_OCTET_STRING:
                 ret = mbedtls_asn1_write_octet_string(
                     &data.p, data.start, content->x, content->len );
                 break;
             case MBEDTLS_ASN1_OID:
                 ret = mbedtls_asn1_write_oid(
                     &data.p, data.start,
                     (const char *) content->x, content->len );
                 break;
             case MBEDTLS_ASN1_UTF8_STRING:
                 ret = mbedtls_asn1_write_utf8_string(
                     &data.p, data.start,
                     (const char *) content->x, content->len );
                 break;
             case MBEDTLS_ASN1_PRINTABLE_STRING:
                 ret = mbedtls_asn1_write_printable_string(
                     &data.p, data.start,
                     (const char *) content->x, content->len );
                 break;
             case MBEDTLS_ASN1_IA5_STRING:
                 ret = mbedtls_asn1_write_ia5_string(
                     &data.p, data.start,
                     (const char *) content->x, content->len );
                 break;
             default:
                 ret = mbedtls_asn1_write_tagged_string(
                     &data.p, data.start, tag,
                     (const char *) content->x, content->len );
         }
         if( ! generic_write_finish_step( &data, expected, ret ) )
             goto exit;
         if( expected->len > 10 && data.size == 8 )
             data.size = expected->len - 2;
     }

 exit:
     mbedtls_free( data.output );
 }
 /* END_CASE */

 /* BEGIN_CASE */
 void mbedtls_asn1_write_algorithm_identifier( data_t *oid,
                                               int par_len,
                                               data_t *expected )
 {
     generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 };
     int ret;

     for( data.size = 0; data.size < expected->len + 1; data.size++ )
     {
         if( ! generic_write_start_step( &data ) )
             goto exit;
         ret = mbedtls_asn1_write_algorithm_identifier(
             &data.p, data.start,
             (const char *) oid->x, oid->len, par_len );
         /* If params_len != 0, mbedtls_asn1_write_algorithm_identifier()
          * assumes that the parameters are already present in the buffer
          * and returns a length that accounts for this, but our test
          * data omits the parameters. */
         if( ret >= 0 )
             ret -= par_len;
         if( ! generic_write_finish_step( &data, expected, ret ) )
             goto exit;
     }

 exit:
     mbedtls_free( data.output );
 }
 /* END_CASE */

 /* BEGIN_CASE depends_on:MBEDTLS_ASN1_PARSE_C */
 void mbedtls_asn1_write_len( int len, data_t * asn1, int buf_len,
                              int result )
 {
     int ret;
     unsigned char buf[150];
     unsigned char *p;
     size_t i;
     size_t read_len;

     memset( buf, GUARD_VAL, sizeof( buf ) );

     p = buf + GUARD_LEN + buf_len;

     ret = mbedtls_asn1_write_len( &p, buf + GUARD_LEN, (size_t) len );

     TEST_ASSERT( ret == result );

     /* Check for buffer overwrite on both sides */
     for( i = 0; i < GUARD_LEN; i++ )
     {
         TEST_ASSERT( buf[i] == GUARD_VAL );
         TEST_ASSERT( buf[GUARD_LEN + buf_len + i] == GUARD_VAL );
     }

     if( result >= 0 )
     {
         TEST_ASSERT( p + asn1->len == buf + GUARD_LEN + buf_len );

         TEST_ASSERT( memcmp( p, asn1->x, asn1->len ) == 0 );

         /* Read back with mbedtls_asn1_get_len() to check */
         ret = mbedtls_asn1_get_len( &p, buf + GUARD_LEN + buf_len, &read_len );

         if( len == 0 )
         {
             TEST_ASSERT( ret == 0 );
         }
         else
         {
             /* Return will be MBEDTLS_ERR_ASN1_OUT_OF_DATA because the rest of
              * the buffer is missing
              */
             TEST_ASSERT( ret == MBEDTLS_ERR_ASN1_OUT_OF_DATA );
         }
         TEST_ASSERT( read_len == (size_t) len );
         TEST_ASSERT( p == buf + GUARD_LEN + buf_len );
     }
 }
 /* END_CASE */

 /* BEGIN_CASE */
 void test_asn1_write_bitstrings( data_t *bitstring, int bits,
                                  data_t *expected, int is_named )
 {
     generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 };
     int ret;
     int ( *func )( unsigned char **p, unsigned char *start,
                    const unsigned char *buf, size_t bits ) =
         ( is_named ? mbedtls_asn1_write_named_bitstring :
           mbedtls_asn1_write_bitstring );

     for( data.size = 0; data.size < expected->len + 1; data.size++ )
     {
         if( ! generic_write_start_step( &data ) )
             goto exit;
         ret = ( *func )( &data.p, data.start, bitstring->x, bits );
         if( ! generic_write_finish_step( &data, expected, ret ) )
             goto exit;
     }

 exit:
     mbedtls_free( data.output );
 }
 /* END_CASE */

 /* BEGIN_CASE */
 void store_named_data_find( data_t *oid0, data_t *oid1,
                             data_t *oid2, data_t *oid3,
                             data_t *needle, int from, int position )
 {
     data_t *oid[4] = {oid0, oid1, oid2, oid3};
     mbedtls_asn1_named_data nd[] ={
         { {0x06, 0, NULL}, {0, 0, NULL}, NULL, 0 },
         { {0x06, 0, NULL}, {0, 0, NULL}, NULL, 0 },
         { {0x06, 0, NULL}, {0, 0, NULL}, NULL, 0 },
         { {0x06, 0, NULL}, {0, 0, NULL}, NULL, 0 },
     };
     mbedtls_asn1_named_data *pointers[ARRAY_LENGTH( nd ) + 1];
     size_t i;
     mbedtls_asn1_named_data *head = NULL;
     mbedtls_asn1_named_data *found = NULL;

     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++ )
     {
         ASSERT_ALLOC( nd[i].oid.p, oid[i]->len );
         memcpy( nd[i].oid.p, oid[i]->x, oid[i]->len );
         nd[i].oid.len = oid[i]->len;
         nd[i].next = pointers[i+1];
     }

     head = pointers[from];
     found = mbedtls_asn1_store_named_data( &head,
                                            (const char *) needle->x,
                                            needle->len,
                                            NULL, 0 );

     /* In any case, the existing list structure must be unchanged. */
     for( i = 0; i < ARRAY_LENGTH( nd ); i++ )
         TEST_ASSERT( nd[i].next == pointers[i+1] );

     if( position >= 0 )
     {
         /* position should have been found and modified. */
         TEST_ASSERT( head == pointers[from] );
         TEST_ASSERT( found == pointers[position] );
     }
     else
     {
         /* A new entry should have been created. */
         TEST_ASSERT( found == head );
         TEST_ASSERT( head->next == pointers[from] );
         for( i = 0; i < ARRAY_LENGTH( nd ); i++ )
             TEST_ASSERT( found != &nd[i] );
     }

 exit:
     if( found != NULL && found == head && found != pointers[from] )
     {
         mbedtls_free( found->oid.p );
         mbedtls_free( found );
     }
     for( i = 0; i < ARRAY_LENGTH( nd ); i++ )
         mbedtls_free( nd[i].oid.p );
 }
 /* END_CASE */

 /* BEGIN_CASE */
 void store_named_data_val_found( int old_len, int new_len )
 {
     mbedtls_asn1_named_data nd =
         { {0x06, 3, (unsigned char *) "OID"}, {0, 0, NULL}, NULL, 0 };
     mbedtls_asn1_named_data *head = &nd;
     mbedtls_asn1_named_data *found = NULL;
     unsigned char *old_val = NULL;
     unsigned char *new_val = (unsigned char *) "new value";

     if( old_len != 0 )
     {
         ASSERT_ALLOC( nd.val.p, (size_t) old_len );
         old_val = nd.val.p;
         nd.val.len = old_len;
         memset( old_val, 'x', old_len );
     }
     if( new_len <= 0 )
     {
         new_len = - new_len;
         new_val = NULL;
     }

     found = mbedtls_asn1_store_named_data( &head, "OID", 3,
                                            new_val, new_len );
     TEST_ASSERT( head == &nd );
     TEST_ASSERT( found == head );

     if( new_val != NULL)
         ASSERT_COMPARE( found->val.p, found->val.len,
                         new_val, (size_t) new_len );
     if( new_len == 0)
         TEST_ASSERT( found->val.p == NULL );
     else if( new_len == old_len )
         TEST_ASSERT( found->val.p == old_val );
     else
         TEST_ASSERT( found->val.p != old_val );

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

 /* BEGIN_CASE */
 void store_named_data_val_new( int new_len )
 {
     mbedtls_asn1_named_data *head = NULL;
     mbedtls_asn1_named_data *found = NULL;
     const unsigned char *oid = (unsigned char *) "OID";
     size_t oid_len = strlen( (const char *) oid );
     const unsigned char *new_val = (unsigned char *) "new value";

     if( new_len <= 0 )
         new_val = NULL;
     if( new_len < 0 )
         new_len = - new_len;

     found = mbedtls_asn1_store_named_data( &head,
                                            (const char *) oid, oid_len,
                                            new_val, (size_t) new_len );
     TEST_ASSERT( found != NULL );
     TEST_ASSERT( found == head );
     TEST_ASSERT( found->oid.p != oid );
     ASSERT_COMPARE( found->oid.p, found->oid.len, oid, oid_len );
     if( new_len == 0 )
         TEST_ASSERT( found->val.p == NULL );
     else if( new_val == NULL )
         TEST_ASSERT( found->val.p != NULL );
     else
     {
         TEST_ASSERT( found->val.p != new_val );
         ASSERT_COMPARE( found->val.p, found->val.len,
                         new_val, (size_t) new_len );
     }

 exit:
     if( found != NULL )
     {
         mbedtls_free( found->oid.p );
         mbedtls_free( found->val.p );
     }
     mbedtls_free( found );
 }
 /* END_CASE */
	/* BEGIN_HEADER */
	#include "mbedtls/asn1write.h"

	#define GUARD_LEN 4
	#define GUARD_VAL 0x2a

	typedef struct
	{
	unsigned char *output;
	unsigned char *start;
	unsigned char *end;
	unsigned char *p;
	size_t size;
	} generic_write_data_t;

	int generic_write_start_step( generic_write_data_t *data )
	{
	mbedtls_test_set_step( data->size );
	ASSERT_ALLOC( data->output, data->size == 0 ? 1 : data->size );
	data->end = data->output + data->size;
	data->p = data->end;
	data->start = data->end - data->size;
	return( 1 );
	exit:
	return( 0 );
	}

	int generic_write_finish_step( generic_write_data_t *data,
	const data_t *expected, int ret )
	{
	int ok = 0;

	if( data->size < expected->len )
	{
	TEST_EQUAL( ret, MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
	}
	else
	{
	TEST_EQUAL( ret, data->end - data->p );
	TEST_ASSERT( data->p >= data->start );
	TEST_ASSERT( data->p <= data->end );
	ASSERT_COMPARE( data->p, (size_t)( data->end - data->p ),
	expected->x, expected->len );
	}
	ok = 1;

	exit:
	mbedtls_free( data->output );
	data->output = NULL;
	return( ok );
	}

	/* END_HEADER */

	/* BEGIN_DEPENDENCIES
	* depends_on:MBEDTLS_ASN1_WRITE_C
	* END_DEPENDENCIES
	*/

	/* BEGIN_CASE */
	void mbedtls_asn1_write_null( data_t *expected )
	{
	generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 };
	int ret;

	for( data.size = 0; data.size < expected->len + 1; data.size++ )
	{
	if( ! generic_write_start_step( &data ) )
	goto exit;
	ret = mbedtls_asn1_write_null( &data.p, data.start );
	if( ! generic_write_finish_step( &data, expected, ret ) )
	goto exit;
	}

	exit:
	mbedtls_free( data.output );
	}
	/* END_CASE */

	/* BEGIN_CASE */
	void mbedtls_asn1_write_bool( int val, data_t *expected )
	{
	generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 };
	int ret;

	for( data.size = 0; data.size < expected->len + 1; data.size++ )
	{
	if( ! generic_write_start_step( &data ) )
	goto exit;
	ret = mbedtls_asn1_write_bool( &data.p, data.start, val );
	if( ! generic_write_finish_step( &data, expected, ret ) )
	goto exit;
	}

	exit:
	mbedtls_free( data.output );
	}
	/* END_CASE */

	/* BEGIN_CASE */
	void mbedtls_asn1_write_int( int val, data_t *expected )
	{
	generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 };
	int ret;

	for( data.size = 0; data.size < expected->len + 1; data.size++ )
	{
	if( ! generic_write_start_step( &data ) )
	goto exit;
	ret = mbedtls_asn1_write_int( &data.p, data.start, val );
	if( ! generic_write_finish_step( &data, expected, ret ) )
	goto exit;
	}

	exit:
	mbedtls_free( data.output );
	}
	/* END_CASE */


	/* BEGIN_CASE */
	void mbedtls_asn1_write_enum( int val, data_t *expected )
	{
	generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 };
	int ret;

	for( data.size = 0; data.size < expected->len + 1; data.size++ )
	{
	if( ! generic_write_start_step( &data ) )
	goto exit;
	ret = mbedtls_asn1_write_enum( &data.p, data.start, val );
	if( ! generic_write_finish_step( &data, expected, ret ) )
	goto exit;
	}

	exit:
	mbedtls_free( data.output );
	}
	/* END_CASE */

	/* BEGIN_CASE depends_on:MBEDTLS_BIGNUM_C */
	void mbedtls_asn1_write_mpi( data_t val, data_t expected )
	{
	generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 };
	mbedtls_mpi mpi;
	int ret;

	mbedtls_mpi_init( &mpi );
	TEST_ASSERT( mbedtls_mpi_read_binary( &mpi, val->x, val->len ) == 0 );

	for( data.size = 0; data.size < expected->len + 1; data.size++ )
	{
	if( ! generic_write_start_step( &data ) )
	goto exit;
	ret = mbedtls_asn1_write_mpi( &data.p, data.start, &mpi );
	if( ! generic_write_finish_step( &data, expected, ret ) )
	goto exit;
	if( expected->len > 10 && data.size == 8 )
	data.size = expected->len - 2;
	}

	exit:
	mbedtls_mpi_free( &mpi );
	mbedtls_free( data.output );
	}
	/* END_CASE */

	/* BEGIN_CASE */
	void mbedtls_asn1_write_string( int tag, data_t content, data_t expected )
	{
	generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 };
	int ret;

	for( data.size = 0; data.size < expected->len + 1; data.size++ )
	{
	if( ! generic_write_start_step( &data ) )
	goto exit;
	switch( tag )
	{
	case MBEDTLS_ASN1_OCTET_STRING:
	ret = mbedtls_asn1_write_octet_string(
	&data.p, data.start, content->x, content->len );
	break;
	case MBEDTLS_ASN1_OID:
	ret = mbedtls_asn1_write_oid(
	&data.p, data.start,
	(const char *) content->x, content->len );
	break;
	case MBEDTLS_ASN1_UTF8_STRING:
	ret = mbedtls_asn1_write_utf8_string(
	&data.p, data.start,
	(const char *) content->x, content->len );
	break;
	case MBEDTLS_ASN1_PRINTABLE_STRING:
	ret = mbedtls_asn1_write_printable_string(
	&data.p, data.start,
	(const char *) content->x, content->len );
	break;
	case MBEDTLS_ASN1_IA5_STRING:
	ret = mbedtls_asn1_write_ia5_string(
	&data.p, data.start,
	(const char *) content->x, content->len );
	break;
	default:
	ret = mbedtls_asn1_write_tagged_string(
	&data.p, data.start, tag,
	(const char *) content->x, content->len );
	}
	if( ! generic_write_finish_step( &data, expected, ret ) )
	goto exit;
	if( expected->len > 10 && data.size == 8 )
	data.size = expected->len - 2;
	}

	exit:
	mbedtls_free( data.output );
	}
	/* END_CASE */

	/* BEGIN_CASE */
	void mbedtls_asn1_write_algorithm_identifier( data_t *oid,
	int par_len,
	data_t *expected )
	{
	generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 };
	int ret;

	for( data.size = 0; data.size < expected->len + 1; data.size++ )
	{
	if( ! generic_write_start_step( &data ) )
	goto exit;
	ret = mbedtls_asn1_write_algorithm_identifier(
	&data.p, data.start,
	(const char *) oid->x, oid->len, par_len );
	/* If params_len != 0, mbedtls_asn1_write_algorithm_identifier()
	* assumes that the parameters are already present in the buffer
	* and returns a length that accounts for this, but our test
	* data omits the parameters. */
	if( ret >= 0 )
	ret -= par_len;
	if( ! generic_write_finish_step( &data, expected, ret ) )
	goto exit;
	}

	exit:
	mbedtls_free( data.output );
	}
	/* END_CASE */

	/* BEGIN_CASE depends_on:MBEDTLS_ASN1_PARSE_C */
	void mbedtls_asn1_write_len( int len, data_t * asn1, int buf_len,
	int result )
	{
	int ret;
	unsigned char buf[150];
	unsigned char *p;
	size_t i;
	size_t read_len;

	memset( buf, GUARD_VAL, sizeof( buf ) );

	p = buf + GUARD_LEN + buf_len;

	ret = mbedtls_asn1_write_len( &p, buf + GUARD_LEN, (size_t) len );

	TEST_ASSERT( ret == result );

	/* Check for buffer overwrite on both sides */
	for( i = 0; i < GUARD_LEN; i++ )
	{
	TEST_ASSERT( buf[i] == GUARD_VAL );
	TEST_ASSERT( buf[GUARD_LEN + buf_len + i] == GUARD_VAL );
	}

	if( result >= 0 )
	{
	TEST_ASSERT( p + asn1->len == buf + GUARD_LEN + buf_len );

	TEST_ASSERT( memcmp( p, asn1->x, asn1->len ) == 0 );

	/* Read back with mbedtls_asn1_get_len() to check */
	ret = mbedtls_asn1_get_len( &p, buf + GUARD_LEN + buf_len, &read_len );

	if( len == 0 )
	{
	TEST_ASSERT( ret == 0 );
	}
	else
	{
	/* Return will be MBEDTLS_ERR_ASN1_OUT_OF_DATA because the rest of
	* the buffer is missing
	*/
	TEST_ASSERT( ret == MBEDTLS_ERR_ASN1_OUT_OF_DATA );
	}
	TEST_ASSERT( read_len == (size_t) len );
	TEST_ASSERT( p == buf + GUARD_LEN + buf_len );
	}
	}
	/* END_CASE */

	/* BEGIN_CASE */
	void test_asn1_write_bitstrings( data_t *bitstring, int bits,
	data_t *expected, int is_named )
	{
	generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 };
	int ret;
	int ( func )( unsigned char p, unsigned char start,
	const unsigned char *buf, size_t bits ) =
	( is_named ? mbedtls_asn1_write_named_bitstring :
	mbedtls_asn1_write_bitstring );

	for( data.size = 0; data.size < expected->len + 1; data.size++ )
	{
	if( ! generic_write_start_step( &data ) )
	goto exit;
	ret = ( *func )( &data.p, data.start, bitstring->x, bits );
	if( ! generic_write_finish_step( &data, expected, ret ) )
	goto exit;
	}

	exit:
	mbedtls_free( data.output );
	}
	/* END_CASE */

	/* BEGIN_CASE */
	void store_named_data_find( data_t oid0, data_t oid1,
	data_t oid2, data_t oid3,
	data_t *needle, int from, int position )
	{
	data_t *oid[4] = {oid0, oid1, oid2, oid3};
	mbedtls_asn1_named_data nd[] ={
	{ {0x06, 0, NULL}, {0, 0, NULL}, NULL, 0 },
	{ {0x06, 0, NULL}, {0, 0, NULL}, NULL, 0 },
	{ {0x06, 0, NULL}, {0, 0, NULL}, NULL, 0 },
	{ {0x06, 0, NULL}, {0, 0, NULL}, NULL, 0 },
	};
	mbedtls_asn1_named_data *pointers[ARRAY_LENGTH( nd ) + 1];
	size_t i;
	mbedtls_asn1_named_data *head = NULL;
	mbedtls_asn1_named_data *found = NULL;

	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++ )
	{
	ASSERT_ALLOC( nd[i].oid.p, oid[i]->len );
	memcpy( nd[i].oid.p, oid[i]->x, oid[i]->len );
	nd[i].oid.len = oid[i]->len;
	nd[i].next = pointers[i+1];
	}

	head = pointers[from];
	found = mbedtls_asn1_store_named_data( &head,
	(const char *) needle->x,
	needle->len,
	NULL, 0 );

	/* In any case, the existing list structure must be unchanged. */
	for( i = 0; i < ARRAY_LENGTH( nd ); i++ )
	TEST_ASSERT( nd[i].next == pointers[i+1] );

	if( position >= 0 )
	{
	/* position should have been found and modified. */
	TEST_ASSERT( head == pointers[from] );
	TEST_ASSERT( found == pointers[position] );
	}
	else
	{
	/* A new entry should have been created. */
	TEST_ASSERT( found == head );
	TEST_ASSERT( head->next == pointers[from] );
	for( i = 0; i < ARRAY_LENGTH( nd ); i++ )
	TEST_ASSERT( found != &nd[i] );
	}

	exit:
	if( found != NULL && found == head && found != pointers[from] )
	{
	mbedtls_free( found->oid.p );
	mbedtls_free( found );
	}
	for( i = 0; i < ARRAY_LENGTH( nd ); i++ )
	mbedtls_free( nd[i].oid.p );
	}
	/* END_CASE */

	/* BEGIN_CASE */
	void store_named_data_val_found( int old_len, int new_len )
	{
	mbedtls_asn1_named_data nd =
	{ {0x06, 3, (unsigned char *) "OID"}, {0, 0, NULL}, NULL, 0 };
	mbedtls_asn1_named_data *head = &nd;
	mbedtls_asn1_named_data *found = NULL;
	unsigned char *old_val = NULL;
	unsigned char new_val = (unsigned char ) "new value";

	if( old_len != 0 )
	{
	ASSERT_ALLOC( nd.val.p, (size_t) old_len );
	old_val = nd.val.p;
	nd.val.len = old_len;
	memset( old_val, 'x', old_len );
	}
	if( new_len <= 0 )
	{
	new_len = - new_len;
	new_val = NULL;
	}

	found = mbedtls_asn1_store_named_data( &head, "OID", 3,
	new_val, new_len );
	TEST_ASSERT( head == &nd );
	TEST_ASSERT( found == head );

	if( new_val != NULL)
	ASSERT_COMPARE( found->val.p, found->val.len,
	new_val, (size_t) new_len );
	if( new_len == 0)
	TEST_ASSERT( found->val.p == NULL );
	else if( new_len == old_len )
	TEST_ASSERT( found->val.p == old_val );
	else
	TEST_ASSERT( found->val.p != old_val );

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

	/* BEGIN_CASE */
	void store_named_data_val_new( int new_len )
	{
	mbedtls_asn1_named_data *head = NULL;
	mbedtls_asn1_named_data *found = NULL;
	const unsigned char oid = (unsigned char ) "OID";
	size_t oid_len = strlen( (const char *) oid );
	const unsigned char new_val = (unsigned char ) "new value";

	if( new_len <= 0 )
	new_val = NULL;
	if( new_len < 0 )
	new_len = - new_len;

	found = mbedtls_asn1_store_named_data( &head,
	(const char *) oid, oid_len,
	new_val, (size_t) new_len );
	TEST_ASSERT( found != NULL );
	TEST_ASSERT( found == head );
	TEST_ASSERT( found->oid.p != oid );
	ASSERT_COMPARE( found->oid.p, found->oid.len, oid, oid_len );
	if( new_len == 0 )
	TEST_ASSERT( found->val.p == NULL );
	else if( new_val == NULL )
	TEST_ASSERT( found->val.p != NULL );
	else
	{
	TEST_ASSERT( found->val.p != new_val );
	ASSERT_COMPARE( found->val.p, found->val.len,
	new_val, (size_t) new_len );
	}

	exit:
	if( found != NULL )
	{
	mbedtls_free( found->oid.p );
	mbedtls_free( found->val.p );
	}
	mbedtls_free( found );
	}
	/* END_CASE */