mirror of
https://github.com/yuzu-emu/mbedtls.git
synced 2024-11-27 02:54:14 +01:00
3f37dca794
Use the test-many-sizes framework for string writes as well (previously, it was only used for booleans and integers). This way, more edge cases are tested with less test code. This commit removes buffer overwrite checks. Instead of these checks, run the test suite under a memory sanitizer (which we do in our CI).
249 lines
6.9 KiB
Plaintext
249 lines
6.9 KiB
Plaintext
/* 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 )
|
|
{
|
|
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_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 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_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 depends_on:MBEDTLS_ASN1PARSE_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 */
|