third_party/mbedtls/repo/tests/suites/test_suite_asn1write.function

   1 /* BEGIN_HEADER */
   2 #include "mbedtls/asn1write.h"
   3
   4 #define GUARD_LEN 4
   5 #define GUARD_VAL 0x2a
   6 /* END_HEADER */
   7
   8 /* BEGIN_DEPENDENCIES
   9  * depends_on:MBEDTLS_ASN1_WRITE_C
  10  * END_DEPENDENCIES
  11  */
  12
  13 /* BEGIN_CASE */
  14 void mbedtls_asn1_write_octet_string( data_t * str, data_t * asn1,
  15                                       int buf_len, int result )
  16 {
  17     int ret;
  18     unsigned char buf[150];
  19     size_t i;
  20     unsigned char *p;
  21
  22     memset( buf, GUARD_VAL, sizeof( buf ) );
  23
  24
  25     p = buf + GUARD_LEN + buf_len;
  26
  27     ret = mbedtls_asn1_write_octet_string( &p, buf + GUARD_LEN, str->x, str->len );
  28
  29     /* Check for buffer overwrite on both sides */
  30     for( i = 0; i < GUARD_LEN; i++ )
  31     {
  32         TEST_ASSERT( buf[i] == GUARD_VAL );
  33         TEST_ASSERT( buf[GUARD_LEN + buf_len + i] == GUARD_VAL );
  34     }
  35
  36     if( result >= 0 )
  37     {
  38         TEST_ASSERT( (size_t) ret == asn1->len );
  39         TEST_ASSERT( p + asn1->len == buf + GUARD_LEN + buf_len );
  40
  41         TEST_ASSERT( memcmp( p, asn1->x, asn1->len ) == 0 );
  42     }
  43 }
  44 /* END_CASE */
  45
  46 /* BEGIN_CASE */
  47 void mbedtls_asn1_write_ia5_string( char * str, data_t * asn1,
  48                                     int buf_len, int result )
  49 {
  50     int ret;
  51     unsigned char buf[150];
  52     size_t str_len;
  53     size_t i;
  54     unsigned char *p;
  55
  56     memset( buf, GUARD_VAL, sizeof( buf ) );
  57
  58     str_len = strlen( str );
  59
  60     p = buf + GUARD_LEN + buf_len;
  61
  62     ret = mbedtls_asn1_write_ia5_string( &p, buf + GUARD_LEN, str, str_len );
  63
  64     /* Check for buffer overwrite on both sides */
  65     for( i = 0; i < GUARD_LEN; i++ )
  66     {
  67         TEST_ASSERT( buf[i] == GUARD_VAL );
  68         TEST_ASSERT( buf[GUARD_LEN + buf_len + i] == GUARD_VAL );
  69     }
  70
  71     if( result >= 0 )
  72     {
  73         TEST_ASSERT( (size_t) ret == asn1->len );
  74         TEST_ASSERT( p + asn1->len == buf + GUARD_LEN + buf_len );
  75
  76         TEST_ASSERT( memcmp( p, asn1->x, asn1->len ) == 0 );
  77     }
  78 }
  79 /* END_CASE */
  80
  81 /* BEGIN_CASE depends_on:MBEDTLS_ASN1PARSE_C */
  82 void mbedtls_asn1_write_len( int len, data_t * asn1, int buf_len,
  83                              int result )
  84 {
  85     int ret;
  86     unsigned char buf[150];
  87     unsigned char *p;
  88     size_t i;
  89     size_t read_len;
  90
  91     memset( buf, GUARD_VAL, sizeof( buf ) );
  92
  93     p = buf + GUARD_LEN + buf_len;
  94
  95     ret = mbedtls_asn1_write_len( &p, buf + GUARD_LEN, (size_t) len );
  96
  97     TEST_ASSERT( ret == result );
  98
  99     /* Check for buffer overwrite on both sides */
 100     for( i = 0; i < GUARD_LEN; i++ )
 101     {
 102         TEST_ASSERT( buf[i] == GUARD_VAL );
 103         TEST_ASSERT( buf[GUARD_LEN + buf_len + i] == GUARD_VAL );
 104     }
 105
 106     if( result >= 0 )
 107     {
 108         TEST_ASSERT( p + asn1->len == buf + GUARD_LEN + buf_len );
 109
 110         TEST_ASSERT( memcmp( p, asn1->x, asn1->len ) == 0 );
 111
 112         /* Read back with mbedtls_asn1_get_len() to check */
 113         ret = mbedtls_asn1_get_len( &p, buf + GUARD_LEN + buf_len, &read_len );
 114
 115         if( len == 0 )
 116         {
 117             TEST_ASSERT( ret == 0 );
 118         }
 119         else
 120         {
 121             /* Return will be MBEDTLS_ERR_ASN1_OUT_OF_DATA because the rest of
 122              * the buffer is missing
 123              */
 124             TEST_ASSERT( ret == MBEDTLS_ERR_ASN1_OUT_OF_DATA );
 125         }
 126         TEST_ASSERT( read_len == (size_t) len );
 127         TEST_ASSERT( p == buf + GUARD_LEN + buf_len );
 128     }
 129 }
 130 /* END_CASE */
 131
 132 /* BEGIN_CASE */
 133 void test_asn1_write_bitstrings( data_t *bitstring, int bits,
 134                                  data_t *expected_asn1, int result,
 135                                  int is_named )
 136 {
 137     int ret;
 138     size_t i;
 139     unsigned char buf[150];
 140     unsigned char *p;
 141
 142     memset( buf, GUARD_VAL, sizeof( buf ) );
 143
 144     p = buf + GUARD_LEN + expected_asn1->len;
 145
 146     if ( is_named == 0 )
 147     {
 148         ret = mbedtls_asn1_write_bitstring( &p,
 149                                             buf,
 150                                             (unsigned char *)bitstring->x,
 151                                             (size_t) bits );
 152     }
 153     else
 154     {
 155         ret = mbedtls_asn1_write_named_bitstring( &p,
 156                                                   buf,
 157                                                   (unsigned char *)bitstring->x,
 158                                                   (size_t) bits );
 159     }
 160     TEST_ASSERT( ret == result );
 161
 162     /* Check for buffer overwrite on both sides */
 163     for( i = 0; i < GUARD_LEN; i++ )
 164     {
 165         TEST_ASSERT( buf[i] == GUARD_VAL );
 166         TEST_ASSERT( buf[GUARD_LEN + expected_asn1->len + i] == GUARD_VAL );
 167     }
 168
 169     if ( result >= 0 )
 170     {
 171         TEST_ASSERT( memcmp( p, expected_asn1->x, expected_asn1->len ) == 0 );
 172     }
 173 }
 174 /* END_CASE */