AuroraMiddleware/mbedtls
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
a120146afe
mbedtls/tests/suites/test_suite_asn1write.function

474 lines
14 KiB
Plaintext
Raw Normal View History

Add tests for asn1_write_octet_string()
2014-05-29 12:26:03 +00:00
/* BEGIN_HEADER */
Rename include directory to mbedtls
2015-03-09 17:05:11 +00:00
#include "mbedtls/asn1write.h"
Add tests for asn1_write_octet_string()
2014-05-29 12:26:03 +00:00
#define GUARD_LEN 4
#define GUARD_VAL 0x2a
Add test cases for BOOLEANs and INTEGERs Omit negative integers and MPIs that would result in values that look like negative INTEGERs, since the library doesn't respect the specifications there, but fixing it has a serious risk of breaking interoperability when ASN.1 is used in X.509 and other cryptography-related applications.
2019-03-01 17:13:36 +00:00
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 );
}
Add tests for asn1_write_octet_string()
2014-05-29 12:26:03 +00:00
/* END_HEADER */
/* BEGIN_DEPENDENCIES
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
* depends_on:MBEDTLS_ASN1_WRITE_C
Add tests for asn1_write_octet_string()
2014-05-29 12:26:03 +00:00
* END_DEPENDENCIES
*/
asn1write: test NULL, OID and AlgorithmIdentifier
2019-03-01 19:05:05 +00:00
/* 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 */
Add test cases for BOOLEANs and INTEGERs Omit negative integers and MPIs that would result in values that look like negative INTEGERs, since the library doesn't respect the specifications there, but fixing it has a serious risk of breaking interoperability when ASN.1 is used in X.509 and other cryptography-related applications.
2019-03-01 17:13:36 +00:00
/* 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 */
Add test cases for ASN.1 ENUMERATED tag Add test cases for writing and parsing ASN.1 ENUMERATED tag values. Signed-off-by: Mykhailo Sopiha <mykhailo.sopiha@linaro.org>
2019-10-31 13:55:16 +00:00
/* 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 */
Add test cases for BOOLEANs and INTEGERs Omit negative integers and MPIs that would result in values that look like negative INTEGERs, since the library doesn't respect the specifications there, but fixing it has a serious risk of breaking interoperability when ASN.1 is used in X.509 and other cryptography-related applications.
2019-03-01 17:13:36 +00:00
/* 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;
asn1write: Test short and large buffers more systematically 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).
2019-03-01 18:30:20 +00:00
if( expected->len > 10 && data.size == 8 )
data.size = expected->len - 2;
Add test cases for BOOLEANs and INTEGERs Omit negative integers and MPIs that would result in values that look like negative INTEGERs, since the library doesn't respect the specifications there, but fixing it has a serious risk of breaking interoperability when ASN.1 is used in X.509 and other cryptography-related applications.
2019-03-01 17:13:36 +00:00
}
exit:
mbedtls_mpi_free( &mpi );
mbedtls_free( data.output );
}
/* END_CASE */
Add tests for asn1_write_octet_string()
2014-05-29 12:26:03 +00:00
/* BEGIN_CASE */
asn1write: Test short and large buffers more systematically 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).
2019-03-01 18:30:20 +00:00
void mbedtls_asn1_write_string( int tag, data_t *content, data_t *expected )
Add tests for asn1_write_ia5_string()
2014-05-29 15:16:45 +00:00
{
asn1write: Test short and large buffers more systematically 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).
2019-03-01 18:30:20 +00:00
generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 };
Add tests for asn1_write_ia5_string()
2014-05-29 15:16:45 +00:00
int ret;
asn1write: Test short and large buffers more systematically 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).
2019-03-01 18:30:20 +00:00
for( data.size = 0; data.size < expected->len + 1; data.size++ )
Add tests for asn1_write_ia5_string()
2014-05-29 15:16:45 +00:00
{
asn1write: Test short and large buffers more systematically 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).
2019-03-01 18:30:20 +00:00
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;
asn1write: test NULL, OID and AlgorithmIdentifier
2019-03-01 19:05:05 +00:00
case MBEDTLS_ASN1_OID:
ret = mbedtls_asn1_write_oid(
&data.p, data.start,
(const char *) content->x, content->len );
break;
asn1write: Test short and large buffers more systematically 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).
2019-03-01 18:30:20 +00:00
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;
Add tests for asn1_write_ia5_string()
2014-05-29 15:16:45 +00:00
}
asn1write: Test short and large buffers more systematically 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).
2019-03-01 18:30:20 +00:00
exit:
mbedtls_free( data.output );
Add tests for asn1_write_ia5_string()
2014-05-29 15:16:45 +00:00
}
/* END_CASE */
Add explicit test coverage for mbedtls_asn1_write_len()
2016-07-14 09:27:36 +00:00
asn1write: test NULL, OID and AlgorithmIdentifier
2019-03-01 19:05:05 +00:00
/* 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 */
Fix typo that prevented mbedtls_asn1_write_len tests from running
2019-03-01 18:34:24 +00:00
/* BEGIN_CASE depends_on:MBEDTLS_ASN1_PARSE_C */
Rename HexParam_t -> data_t for consistent coding style
2018-06-29 10:05:32 +00:00
void mbedtls_asn1_write_len( int len, data_t * asn1, int buf_len,
Combine hex parameters in a struct
2017-06-09 03:32:58 +00:00
int result )
Add explicit test coverage for mbedtls_asn1_write_len()
2016-07-14 09:27:36 +00:00
{
int ret;
unsigned char buf[150];
unsigned char *p;
Adapt code for scripting out hexify/unhexify code
2017-05-29 23:57:11 +00:00
size_t i;
size_t read_len;
Add explicit test coverage for mbedtls_asn1_write_len()
2016-07-14 09:27:36 +00:00
memset( buf, GUARD_VAL, sizeof( buf ) );
Add buffer length tests for mbedtls_asn1_write_len()
2016-07-14 10:02:31 +00:00
p = buf + GUARD_LEN + buf_len;
Add explicit test coverage for mbedtls_asn1_write_len()
2016-07-14 09:27:36 +00:00
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 );
Add buffer length tests for mbedtls_asn1_write_len()
2016-07-14 10:02:31 +00:00
TEST_ASSERT( buf[GUARD_LEN + buf_len + i] == GUARD_VAL );
Add explicit test coverage for mbedtls_asn1_write_len()
2016-07-14 09:27:36 +00:00
}
if( result >= 0 )
{
Combine hex parameters in a struct
2017-06-09 03:32:58 +00:00
TEST_ASSERT( p + asn1->len == buf + GUARD_LEN + buf_len );
Add explicit test coverage for mbedtls_asn1_write_len()
2016-07-14 09:27:36 +00:00
Combine hex parameters in a struct
2017-06-09 03:32:58 +00:00
TEST_ASSERT( memcmp( p, asn1->x, asn1->len ) == 0 );
Test result of mbedtls_asn1_write_len() through mbedtls_asn1_get_len()
2016-07-14 10:14:54 +00:00
/* 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 );
Add explicit test coverage for mbedtls_asn1_write_len()
2016-07-14 09:27:36 +00:00
}
}
/* END_CASE */
Add tests for (named) bitstring to suite_asn1write
2018-09-26 09:51:16 +00:00
/* BEGIN_CASE */
void test_asn1_write_bitstrings( data_t *bitstring, int bits,
asn1write: Test short and large buffers more systematically 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).
2019-03-01 18:30:20 +00:00
data_t *expected, int is_named )
Add tests for (named) bitstring to suite_asn1write
2018-09-26 09:51:16 +00:00
{
asn1write: Test short and large buffers more systematically 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).
2019-03-01 18:30:20 +00:00
generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 };
Add tests for (named) bitstring to suite_asn1write
2018-09-26 09:51:16 +00:00
int ret;
asn1write: Test short and large buffers more systematically 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).
2019-03-01 18:30:20 +00:00
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 );
Add tests for (named) bitstring to suite_asn1write
2018-09-26 09:51:16 +00:00
asn1write: Test short and large buffers more systematically 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).
2019-03-01 18:30:20 +00:00
for( data.size = 0; data.size < expected->len + 1; data.size++ )
Add tests for (named) bitstring to suite_asn1write
2018-09-26 09:51:16 +00:00
{
asn1write: Test short and large buffers more systematically 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).
2019-03-01 18:30:20 +00:00
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;
Add tests for (named) bitstring to suite_asn1write
2018-09-26 09:51:16 +00:00
}
asn1write: Test short and large buffers more systematically 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).
2019-03-01 18:30:20 +00:00
exit:
mbedtls_free( data.output );
Add tests for (named) bitstring to suite_asn1write
2018-09-26 09:51:16 +00:00
}
/* END_CASE */
Test mbedtls_asn1_store_named_data
2019-03-01 22:26:05 +00:00
/* 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 */
Reference in New Issue Copy Permalink