mirror of
https://github.com/yuzu-emu/mbedtls.git
synced 2024-10-19 09:11:48 +00:00
5b1674e0ba
This test appeared to be passing for the wrong reason, it's actually not appropriate for the current implementation. The serialised data contains values of pointers to heap-allocated buffers. There is no reason these should be identical after a load-save pair. They just happened to be identical when I first ran the test due to the place of session_free() in the test code and the fact that the libc's malloc() reused the same buffers. The test no longer passes if other malloc() implementations are used (for example, when compiling with asan which avoids re-using the buffer, probably for better error detection). So, disable this test for now (we can re-enable it when we changed how sessions are serialised, which will be done in a future PR, hence the name of the dummy macro in depends_on). In the next commit we're going to add a test that save-load is the identity instead - which will be more work in testing as it will require checking each field manually, but at least is reliable.
715 lines
23 KiB
Plaintext
715 lines
23 KiB
Plaintext
/* BEGIN_HEADER */
|
|
#include <mbedtls/ssl.h>
|
|
#include <mbedtls/ssl_internal.h>
|
|
|
|
/*
|
|
* Helper function setting up inverse record transformations
|
|
* using given cipher, hash, EtM mode, authentication tag length,
|
|
* and version.
|
|
*/
|
|
|
|
#define CHK( x ) \
|
|
do \
|
|
{ \
|
|
if( !( x ) ) \
|
|
{ \
|
|
ret = -1; \
|
|
goto cleanup; \
|
|
} \
|
|
} while( 0 )
|
|
|
|
#if MBEDTLS_SSL_CID_OUT_LEN_MAX > MBEDTLS_SSL_CID_IN_LEN_MAX
|
|
#define SSL_CID_LEN_MIN MBEDTLS_SSL_CID_IN_LEN_MAX
|
|
#else
|
|
#define SSL_CID_LEN_MIN MBEDTLS_SSL_CID_OUT_LEN_MAX
|
|
#endif
|
|
|
|
static int build_transforms( mbedtls_ssl_transform *t_in,
|
|
mbedtls_ssl_transform *t_out,
|
|
int cipher_type, int hash_id,
|
|
int etm, int tag_mode, int ver,
|
|
size_t cid0_len,
|
|
size_t cid1_len )
|
|
{
|
|
mbedtls_cipher_info_t const *cipher_info;
|
|
int ret = 0;
|
|
|
|
size_t keylen, maclen, ivlen;
|
|
unsigned char *key0 = NULL, *key1 = NULL;
|
|
unsigned char iv_enc[16], iv_dec[16];
|
|
|
|
#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
|
|
unsigned char cid0[ SSL_CID_LEN_MIN ];
|
|
unsigned char cid1[ SSL_CID_LEN_MIN ];
|
|
|
|
rnd_std_rand( NULL, cid0, sizeof( cid0 ) );
|
|
rnd_std_rand( NULL, cid1, sizeof( cid1 ) );
|
|
#else
|
|
((void) cid0_len);
|
|
((void) cid1_len);
|
|
#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
|
|
|
|
maclen = 0;
|
|
|
|
/* Pick cipher */
|
|
cipher_info = mbedtls_cipher_info_from_type( cipher_type );
|
|
CHK( cipher_info != NULL );
|
|
CHK( cipher_info->iv_size <= 16 );
|
|
CHK( cipher_info->key_bitlen % 8 == 0 );
|
|
|
|
/* Pick keys */
|
|
keylen = cipher_info->key_bitlen / 8;
|
|
/* Allocate `keylen + 1` bytes to ensure that we get
|
|
* a non-NULL pointers from `mbedtls_calloc` even if
|
|
* `keylen == 0` in the case of the NULL cipher. */
|
|
CHK( ( key0 = mbedtls_calloc( 1, keylen + 1 ) ) != NULL );
|
|
CHK( ( key1 = mbedtls_calloc( 1, keylen + 1 ) ) != NULL );
|
|
memset( key0, 0x1, keylen );
|
|
memset( key1, 0x2, keylen );
|
|
|
|
/* Setup cipher contexts */
|
|
CHK( mbedtls_cipher_setup( &t_in->cipher_ctx_enc, cipher_info ) == 0 );
|
|
CHK( mbedtls_cipher_setup( &t_in->cipher_ctx_dec, cipher_info ) == 0 );
|
|
CHK( mbedtls_cipher_setup( &t_out->cipher_ctx_enc, cipher_info ) == 0 );
|
|
CHK( mbedtls_cipher_setup( &t_out->cipher_ctx_dec, cipher_info ) == 0 );
|
|
|
|
#if defined(MBEDTLS_CIPHER_MODE_CBC)
|
|
if( cipher_info->mode == MBEDTLS_MODE_CBC )
|
|
{
|
|
CHK( mbedtls_cipher_set_padding_mode( &t_in->cipher_ctx_enc,
|
|
MBEDTLS_PADDING_NONE ) == 0 );
|
|
CHK( mbedtls_cipher_set_padding_mode( &t_in->cipher_ctx_dec,
|
|
MBEDTLS_PADDING_NONE ) == 0 );
|
|
CHK( mbedtls_cipher_set_padding_mode( &t_out->cipher_ctx_enc,
|
|
MBEDTLS_PADDING_NONE ) == 0 );
|
|
CHK( mbedtls_cipher_set_padding_mode( &t_out->cipher_ctx_dec,
|
|
MBEDTLS_PADDING_NONE ) == 0 );
|
|
}
|
|
#endif /* MBEDTLS_CIPHER_MODE_CBC */
|
|
|
|
CHK( mbedtls_cipher_setkey( &t_in->cipher_ctx_enc, key0,
|
|
keylen << 3, MBEDTLS_ENCRYPT ) == 0 );
|
|
CHK( mbedtls_cipher_setkey( &t_in->cipher_ctx_dec, key1,
|
|
keylen << 3, MBEDTLS_DECRYPT ) == 0 );
|
|
CHK( mbedtls_cipher_setkey( &t_out->cipher_ctx_enc, key1,
|
|
keylen << 3, MBEDTLS_ENCRYPT ) == 0 );
|
|
CHK( mbedtls_cipher_setkey( &t_out->cipher_ctx_dec, key0,
|
|
keylen << 3, MBEDTLS_DECRYPT ) == 0 );
|
|
|
|
/* Setup MAC contexts */
|
|
#if defined(MBEDTLS_SSL_SOME_MODES_USE_MAC)
|
|
if( cipher_info->mode == MBEDTLS_MODE_CBC ||
|
|
cipher_info->mode == MBEDTLS_MODE_STREAM )
|
|
{
|
|
mbedtls_md_info_t const *md_info;
|
|
unsigned char *md0, *md1;
|
|
|
|
/* Pick hash */
|
|
md_info = mbedtls_md_info_from_type( hash_id );
|
|
CHK( md_info != NULL );
|
|
|
|
/* Pick hash keys */
|
|
maclen = mbedtls_md_get_size( md_info );
|
|
CHK( ( md0 = mbedtls_calloc( 1, maclen ) ) != NULL );
|
|
CHK( ( md1 = mbedtls_calloc( 1, maclen ) ) != NULL );
|
|
memset( md0, 0x5, maclen );
|
|
memset( md1, 0x6, maclen );
|
|
|
|
CHK( mbedtls_md_setup( &t_out->md_ctx_enc, md_info, 1 ) == 0 );
|
|
CHK( mbedtls_md_setup( &t_out->md_ctx_dec, md_info, 1 ) == 0 );
|
|
CHK( mbedtls_md_setup( &t_in->md_ctx_enc, md_info, 1 ) == 0 );
|
|
CHK( mbedtls_md_setup( &t_in->md_ctx_dec, md_info, 1 ) == 0 );
|
|
|
|
if( ver > MBEDTLS_SSL_MINOR_VERSION_0 )
|
|
{
|
|
CHK( mbedtls_md_hmac_starts( &t_in->md_ctx_enc,
|
|
md0, maclen ) == 0 );
|
|
CHK( mbedtls_md_hmac_starts( &t_in->md_ctx_dec,
|
|
md1, maclen ) == 0 );
|
|
CHK( mbedtls_md_hmac_starts( &t_out->md_ctx_enc,
|
|
md1, maclen ) == 0 );
|
|
CHK( mbedtls_md_hmac_starts( &t_out->md_ctx_dec,
|
|
md0, maclen ) == 0 );
|
|
}
|
|
#if defined(MBEDTLS_SSL_PROTO_SSL3)
|
|
else
|
|
{
|
|
memcpy( &t_in->mac_enc, md0, maclen );
|
|
memcpy( &t_in->mac_dec, md1, maclen );
|
|
memcpy( &t_out->mac_enc, md1, maclen );
|
|
memcpy( &t_out->mac_dec, md0, maclen );
|
|
}
|
|
#endif
|
|
|
|
mbedtls_free( md0 );
|
|
mbedtls_free( md1 );
|
|
}
|
|
#else
|
|
((void) hash_id);
|
|
#endif /* MBEDTLS_SSL_SOME_MODES_USE_MAC */
|
|
|
|
|
|
/* Pick IV's (regardless of whether they
|
|
* are being used by the transform). */
|
|
ivlen = cipher_info->iv_size;
|
|
memset( iv_enc, 0x3, sizeof( iv_enc ) );
|
|
memset( iv_dec, 0x4, sizeof( iv_dec ) );
|
|
|
|
/*
|
|
* Setup transforms
|
|
*/
|
|
|
|
#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC) && \
|
|
defined(MBEDTLS_SSL_SOME_MODES_USE_MAC)
|
|
t_out->encrypt_then_mac = etm;
|
|
t_in->encrypt_then_mac = etm;
|
|
#else
|
|
((void) etm);
|
|
#endif
|
|
|
|
t_out->minor_ver = ver;
|
|
t_in->minor_ver = ver;
|
|
t_out->ivlen = ivlen;
|
|
t_in->ivlen = ivlen;
|
|
|
|
switch( cipher_info->mode )
|
|
{
|
|
case MBEDTLS_MODE_GCM:
|
|
case MBEDTLS_MODE_CCM:
|
|
t_out->fixed_ivlen = 4;
|
|
t_in->fixed_ivlen = 4;
|
|
t_out->maclen = 0;
|
|
t_in->maclen = 0;
|
|
switch( tag_mode )
|
|
{
|
|
case 0: /* Full tag */
|
|
t_out->taglen = 16;
|
|
t_in->taglen = 16;
|
|
break;
|
|
case 1: /* Partial tag */
|
|
t_out->taglen = 8;
|
|
t_in->taglen = 8;
|
|
break;
|
|
default:
|
|
return( 1 );
|
|
}
|
|
break;
|
|
|
|
case MBEDTLS_MODE_CHACHAPOLY:
|
|
t_out->fixed_ivlen = 12;
|
|
t_in->fixed_ivlen = 12;
|
|
t_out->maclen = 0;
|
|
t_in->maclen = 0;
|
|
switch( tag_mode )
|
|
{
|
|
case 0: /* Full tag */
|
|
t_out->taglen = 16;
|
|
t_in->taglen = 16;
|
|
break;
|
|
case 1: /* Partial tag */
|
|
t_out->taglen = 8;
|
|
t_in->taglen = 8;
|
|
break;
|
|
default:
|
|
return( 1 );
|
|
}
|
|
break;
|
|
|
|
case MBEDTLS_MODE_STREAM:
|
|
case MBEDTLS_MODE_CBC:
|
|
t_out->fixed_ivlen = 0; /* redundant, must be 0 */
|
|
t_in->fixed_ivlen = 0; /* redundant, must be 0 */
|
|
t_out->taglen = 0;
|
|
t_in->taglen = 0;
|
|
switch( tag_mode )
|
|
{
|
|
case 0: /* Full tag */
|
|
t_out->maclen = maclen;
|
|
t_in->maclen = maclen;
|
|
break;
|
|
case 1: /* Partial tag */
|
|
t_out->maclen = 10;
|
|
t_in->maclen = 10;
|
|
break;
|
|
default:
|
|
return( 1 );
|
|
}
|
|
break;
|
|
default:
|
|
return( 1 );
|
|
break;
|
|
}
|
|
|
|
/* Setup IV's */
|
|
|
|
memcpy( &t_in->iv_dec, iv_dec, sizeof( iv_dec ) );
|
|
memcpy( &t_in->iv_enc, iv_enc, sizeof( iv_enc ) );
|
|
memcpy( &t_out->iv_dec, iv_enc, sizeof( iv_enc ) );
|
|
memcpy( &t_out->iv_enc, iv_dec, sizeof( iv_dec ) );
|
|
|
|
#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
|
|
/* Add CID */
|
|
memcpy( &t_in->in_cid, cid0, cid0_len );
|
|
memcpy( &t_in->out_cid, cid1, cid1_len );
|
|
t_in->in_cid_len = cid0_len;
|
|
t_in->out_cid_len = cid1_len;
|
|
memcpy( &t_out->in_cid, cid1, cid1_len );
|
|
memcpy( &t_out->out_cid, cid0, cid0_len );
|
|
t_out->in_cid_len = cid1_len;
|
|
t_out->out_cid_len = cid0_len;
|
|
#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
|
|
|
|
cleanup:
|
|
|
|
mbedtls_free( key0 );
|
|
mbedtls_free( key1 );
|
|
|
|
return( ret );
|
|
}
|
|
|
|
/*
|
|
* Populate a session structure for serialisation tests.
|
|
* Choose dummy values, mostly non-0 to distinguish from the init default.
|
|
*/
|
|
static int ssl_populate_session( mbedtls_ssl_session *session,
|
|
int ticket_len,
|
|
const char *crt_file )
|
|
{
|
|
#if defined(MBEDTLS_HAVE_TIME)
|
|
session->start = mbedtls_time( NULL ) - 42;
|
|
#endif
|
|
session->ciphersuite = 0xabcd;
|
|
session->compression = 1;
|
|
session->id_len = sizeof( session->id );
|
|
memset( session->id, 66, session->id_len );
|
|
memset( session->master, 17, sizeof( session-> master ) );
|
|
|
|
#if defined(MBEDTLS_X509_CRT_PARSE_C)
|
|
if( strlen( crt_file ) != 0 )
|
|
{
|
|
int ret;
|
|
ret = mbedtls_x509_crt_parse_file( session->peer_cert, crt_file );
|
|
if( ret != 0 )
|
|
return( ret );
|
|
}
|
|
#else
|
|
(void) crt_file;
|
|
#endif
|
|
session->verify_result = 0xdeadbeef;
|
|
|
|
#if defined(MBEDTLS_SSL_SESSION_TICKETS) && defined(MBEDTLS_SSL_CLI_C)
|
|
if( ticket_len != 0 )
|
|
{
|
|
session->ticket = mbedtls_calloc( 1, ticket_len );
|
|
if( session-> ticket == NULL )
|
|
return( -1 );
|
|
memset( session->ticket, 33, ticket_len );
|
|
}
|
|
session->ticket_len = ticket_len;
|
|
session->ticket_lifetime = 86401;
|
|
#else
|
|
(void) ticket_len;
|
|
#endif
|
|
|
|
#if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
|
|
session->mfl_code = 1;
|
|
#endif
|
|
#if defined(MBEDTLS_SSL_TRUNCATED_HMAC)
|
|
session->trunc_hmac = 1;
|
|
#endif
|
|
#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
|
|
session->encrypt_then_mac = 1;
|
|
#endif
|
|
|
|
return( 0 );
|
|
}
|
|
|
|
/* END_HEADER */
|
|
|
|
/* BEGIN_DEPENDENCIES
|
|
* depends_on:MBEDTLS_SSL_TLS_C
|
|
* END_DEPENDENCIES
|
|
*/
|
|
|
|
/* BEGIN_CASE depends_on:MBEDTLS_SSL_DTLS_ANTI_REPLAY */
|
|
void ssl_dtls_replay( data_t * prevs, data_t * new, int ret )
|
|
{
|
|
uint32_t len = 0;
|
|
mbedtls_ssl_context ssl;
|
|
mbedtls_ssl_config conf;
|
|
|
|
mbedtls_ssl_init( &ssl );
|
|
mbedtls_ssl_config_init( &conf );
|
|
|
|
TEST_ASSERT( mbedtls_ssl_config_defaults( &conf,
|
|
MBEDTLS_SSL_IS_CLIENT,
|
|
MBEDTLS_SSL_TRANSPORT_DATAGRAM,
|
|
MBEDTLS_SSL_PRESET_DEFAULT ) == 0 );
|
|
TEST_ASSERT( mbedtls_ssl_setup( &ssl, &conf ) == 0 );
|
|
|
|
/* Read previous record numbers */
|
|
for( len = 0; len < prevs->len; len += 6 )
|
|
{
|
|
memcpy( ssl.in_ctr + 2, prevs->x + len, 6 );
|
|
mbedtls_ssl_dtls_replay_update( &ssl );
|
|
}
|
|
|
|
/* Check new number */
|
|
memcpy( ssl.in_ctr + 2, new->x, 6 );
|
|
TEST_ASSERT( mbedtls_ssl_dtls_replay_check( &ssl ) == ret );
|
|
|
|
mbedtls_ssl_free( &ssl );
|
|
mbedtls_ssl_config_free( &conf );
|
|
}
|
|
/* END_CASE */
|
|
|
|
/* BEGIN_CASE depends_on:MBEDTLS_X509_CRT_PARSE_C */
|
|
void ssl_set_hostname_twice( char *hostname0, char *hostname1 )
|
|
{
|
|
mbedtls_ssl_context ssl;
|
|
mbedtls_ssl_init( &ssl );
|
|
|
|
TEST_ASSERT( mbedtls_ssl_set_hostname( &ssl, hostname0 ) == 0 );
|
|
TEST_ASSERT( mbedtls_ssl_set_hostname( &ssl, hostname1 ) == 0 );
|
|
|
|
mbedtls_ssl_free( &ssl );
|
|
}
|
|
/* END_CASE */
|
|
|
|
/* BEGIN_CASE */
|
|
void ssl_crypt_record( int cipher_type, int hash_id,
|
|
int etm, int tag_mode, int ver,
|
|
int cid0_len, int cid1_len )
|
|
{
|
|
/*
|
|
* Test several record encryptions and decryptions
|
|
* with plenty of space before and after the data
|
|
* within the record buffer.
|
|
*/
|
|
|
|
int ret;
|
|
int num_records = 16;
|
|
mbedtls_ssl_context ssl; /* ONLY for debugging */
|
|
|
|
mbedtls_ssl_transform t0, t1;
|
|
unsigned char *buf = NULL;
|
|
size_t const buflen = 512;
|
|
mbedtls_record rec, rec_backup;
|
|
|
|
mbedtls_ssl_init( &ssl );
|
|
mbedtls_ssl_transform_init( &t0 );
|
|
mbedtls_ssl_transform_init( &t1 );
|
|
TEST_ASSERT( build_transforms( &t0, &t1, cipher_type, hash_id,
|
|
etm, tag_mode, ver,
|
|
(size_t) cid0_len,
|
|
(size_t) cid1_len ) == 0 );
|
|
|
|
TEST_ASSERT( ( buf = mbedtls_calloc( 1, buflen ) ) != NULL );
|
|
|
|
while( num_records-- > 0 )
|
|
{
|
|
mbedtls_ssl_transform *t_dec, *t_enc;
|
|
/* Take turns in who's sending and who's receiving. */
|
|
if( num_records % 3 == 0 )
|
|
{
|
|
t_dec = &t0;
|
|
t_enc = &t1;
|
|
}
|
|
else
|
|
{
|
|
t_dec = &t1;
|
|
t_enc = &t0;
|
|
}
|
|
|
|
/*
|
|
* The record header affects the transformation in two ways:
|
|
* 1) It determines the AEAD additional data
|
|
* 2) The record counter sometimes determines the IV.
|
|
*
|
|
* Apart from that, the fields don't have influence.
|
|
* In particular, it is currently not the responsibility
|
|
* of ssl_encrypt/decrypt_buf to check if the transform
|
|
* version matches the record version, or that the
|
|
* type is sensible.
|
|
*/
|
|
|
|
memset( rec.ctr, num_records, sizeof( rec.ctr ) );
|
|
rec.type = 42;
|
|
rec.ver[0] = num_records;
|
|
rec.ver[1] = num_records;
|
|
#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
|
|
rec.cid_len = 0;
|
|
#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
|
|
|
|
rec.buf = buf;
|
|
rec.buf_len = buflen;
|
|
rec.data_offset = 16;
|
|
/* Make sure to vary the length to exercise different
|
|
* paddings. */
|
|
rec.data_len = 1 + num_records;
|
|
|
|
memset( rec.buf + rec.data_offset, 42, rec.data_len );
|
|
|
|
/* Make a copy for later comparison */
|
|
rec_backup = rec;
|
|
|
|
/* Encrypt record */
|
|
ret = mbedtls_ssl_encrypt_buf( &ssl, t_enc, &rec,
|
|
rnd_std_rand, NULL );
|
|
TEST_ASSERT( ret == 0 || ret == MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL );
|
|
if( ret != 0 )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
/* Decrypt record with t_dec */
|
|
ret = mbedtls_ssl_decrypt_buf( &ssl, t_dec, &rec );
|
|
TEST_ASSERT( ret == 0 );
|
|
|
|
/* Compare results */
|
|
TEST_ASSERT( rec.type == rec_backup.type );
|
|
TEST_ASSERT( memcmp( rec.ctr, rec_backup.ctr, 8 ) == 0 );
|
|
TEST_ASSERT( rec.ver[0] == rec_backup.ver[0] );
|
|
TEST_ASSERT( rec.ver[1] == rec_backup.ver[1] );
|
|
TEST_ASSERT( rec.data_len == rec_backup.data_len );
|
|
TEST_ASSERT( rec.data_offset == rec_backup.data_offset );
|
|
TEST_ASSERT( memcmp( rec.buf + rec.data_offset,
|
|
rec_backup.buf + rec_backup.data_offset,
|
|
rec.data_len ) == 0 );
|
|
}
|
|
|
|
exit:
|
|
|
|
/* Cleanup */
|
|
mbedtls_ssl_free( &ssl );
|
|
mbedtls_ssl_transform_free( &t0 );
|
|
mbedtls_ssl_transform_free( &t1 );
|
|
|
|
mbedtls_free( buf );
|
|
}
|
|
/* END_CASE */
|
|
|
|
/* BEGIN_CASE */
|
|
void ssl_crypt_record_small( int cipher_type, int hash_id,
|
|
int etm, int tag_mode, int ver,
|
|
int cid0_len, int cid1_len )
|
|
{
|
|
/*
|
|
* Test pairs of encryption and decryption with an increasing
|
|
* amount of space in the record buffer - in more detail:
|
|
* 1) Try to encrypt with 0, 1, 2, ... bytes available
|
|
* in front of the plaintext, and expect the encryption
|
|
* to succeed starting from some offset. Always keep
|
|
* enough space in the end of the buffer.
|
|
* 2) Try to encrypt with 0, 1, 2, ... bytes available
|
|
* at the end of the plaintext, and expect the encryption
|
|
* to succeed starting from some offset. Always keep
|
|
* enough space at the beginning of the buffer.
|
|
* 3) Try to encrypt with 0, 1, 2, ... bytes available
|
|
* both at the front and end of the plaintext,
|
|
* and expect the encryption to succeed starting from
|
|
* some offset.
|
|
*
|
|
* If encryption succeeds, check that decryption succeeds
|
|
* and yields the original record.
|
|
*/
|
|
|
|
mbedtls_ssl_context ssl; /* ONLY for debugging */
|
|
|
|
mbedtls_ssl_transform t0, t1;
|
|
unsigned char *buf = NULL;
|
|
size_t const buflen = 256;
|
|
mbedtls_record rec, rec_backup;
|
|
|
|
int ret;
|
|
int mode; /* Mode 1, 2 or 3 as explained above */
|
|
size_t offset; /* Available space at beginning/end/both */
|
|
size_t threshold = 96; /* Maximum offset to test against */
|
|
|
|
size_t default_pre_padding = 64; /* Pre-padding to use in mode 2 */
|
|
size_t default_post_padding = 128; /* Post-padding to use in mode 1 */
|
|
|
|
int seen_success; /* Indicates if in the current mode we've
|
|
* already seen a successful test. */
|
|
|
|
mbedtls_ssl_init( &ssl );
|
|
mbedtls_ssl_transform_init( &t0 );
|
|
mbedtls_ssl_transform_init( &t1 );
|
|
TEST_ASSERT( build_transforms( &t0, &t1, cipher_type, hash_id,
|
|
etm, tag_mode, ver,
|
|
(size_t) cid0_len,
|
|
(size_t) cid1_len ) == 0 );
|
|
|
|
TEST_ASSERT( ( buf = mbedtls_calloc( 1, buflen ) ) != NULL );
|
|
|
|
for( mode=1; mode <= 3; mode++ )
|
|
{
|
|
seen_success = 0;
|
|
for( offset=0; offset <= threshold; offset++ )
|
|
{
|
|
mbedtls_ssl_transform *t_dec, *t_enc;
|
|
t_dec = &t0;
|
|
t_enc = &t1;
|
|
|
|
memset( rec.ctr, offset, sizeof( rec.ctr ) );
|
|
rec.type = 42;
|
|
rec.ver[0] = offset;
|
|
rec.ver[1] = offset;
|
|
rec.buf = buf;
|
|
rec.buf_len = buflen;
|
|
#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
|
|
rec.cid_len = 0;
|
|
#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
|
|
|
|
switch( mode )
|
|
{
|
|
case 1: /* Space in the beginning */
|
|
rec.data_offset = offset;
|
|
rec.data_len = buflen - offset - default_post_padding;
|
|
break;
|
|
|
|
case 2: /* Space in the end */
|
|
rec.data_offset = default_pre_padding;
|
|
rec.data_len = buflen - default_pre_padding - offset;
|
|
break;
|
|
|
|
case 3: /* Space in the beginning and end */
|
|
rec.data_offset = offset;
|
|
rec.data_len = buflen - 2 * offset;
|
|
break;
|
|
|
|
default:
|
|
TEST_ASSERT( 0 );
|
|
break;
|
|
}
|
|
|
|
memset( rec.buf + rec.data_offset, 42, rec.data_len );
|
|
|
|
/* Make a copy for later comparison */
|
|
rec_backup = rec;
|
|
|
|
/* Encrypt record */
|
|
ret = mbedtls_ssl_encrypt_buf( &ssl, t_enc, &rec, rnd_std_rand, NULL );
|
|
|
|
if( ( mode == 1 || mode == 2 ) && seen_success )
|
|
{
|
|
TEST_ASSERT( ret == 0 );
|
|
}
|
|
else
|
|
{
|
|
TEST_ASSERT( ret == 0 || ret == MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL );
|
|
if( ret == 0 )
|
|
seen_success = 1;
|
|
}
|
|
|
|
if( ret != 0 )
|
|
continue;
|
|
|
|
/* Decrypt record with t_dec */
|
|
TEST_ASSERT( mbedtls_ssl_decrypt_buf( &ssl, t_dec, &rec ) == 0 );
|
|
|
|
/* Compare results */
|
|
TEST_ASSERT( rec.type == rec_backup.type );
|
|
TEST_ASSERT( memcmp( rec.ctr, rec_backup.ctr, 8 ) == 0 );
|
|
TEST_ASSERT( rec.ver[0] == rec_backup.ver[0] );
|
|
TEST_ASSERT( rec.ver[1] == rec_backup.ver[1] );
|
|
TEST_ASSERT( rec.data_len == rec_backup.data_len );
|
|
TEST_ASSERT( rec.data_offset == rec_backup.data_offset );
|
|
TEST_ASSERT( memcmp( rec.buf + rec.data_offset,
|
|
rec_backup.buf + rec_backup.data_offset,
|
|
rec.data_len ) == 0 );
|
|
}
|
|
|
|
TEST_ASSERT( seen_success == 1 );
|
|
}
|
|
|
|
exit:
|
|
|
|
/* Cleanup */
|
|
mbedtls_ssl_free( &ssl );
|
|
mbedtls_ssl_transform_free( &t0 );
|
|
mbedtls_ssl_transform_free( &t1 );
|
|
|
|
mbedtls_free( buf );
|
|
}
|
|
/* END_CASE */
|
|
|
|
/* BEGIN_CASE */
|
|
void ssl_tls_prf( int type, data_t * secret, data_t * random,
|
|
char *label, data_t *result_hex_str, int exp_ret )
|
|
{
|
|
unsigned char *output;
|
|
|
|
output = mbedtls_calloc( 1, result_hex_str->len );
|
|
if( output == NULL )
|
|
goto exit;
|
|
|
|
#if defined(MBEDTLS_USE_PSA_CRYPTO)
|
|
TEST_ASSERT( psa_crypto_init() == 0 );
|
|
#endif
|
|
|
|
TEST_ASSERT( mbedtls_ssl_tls_prf( type, secret->x, secret->len,
|
|
label, random->x, random->len,
|
|
output, result_hex_str->len ) == exp_ret );
|
|
|
|
if( exp_ret == 0 )
|
|
{
|
|
TEST_ASSERT( hexcmp( output, result_hex_str->x,
|
|
result_hex_str->len, result_hex_str->len ) == 0 );
|
|
}
|
|
exit:
|
|
|
|
mbedtls_free( output );
|
|
}
|
|
/* END_CASE */
|
|
|
|
/* BEGIN_CASE depends_on:MBEDTLS_SEE_FUTURE_PR */
|
|
void ssl_serialise_session_load_save( int ticket_len, char *crt_file )
|
|
{
|
|
mbedtls_ssl_session session;
|
|
unsigned char *buf1 = NULL, *buf2 = NULL;
|
|
size_t len0, len1, len2;
|
|
|
|
/*
|
|
* Test that a load-save pair is the identity
|
|
*/
|
|
|
|
mbedtls_ssl_session_init( &session );
|
|
|
|
/* Prepare a dummy session to work on */
|
|
ssl_populate_session( &session, ticket_len, crt_file );
|
|
|
|
/* Get desired buffer size for serialising */
|
|
TEST_ASSERT( mbedtls_ssl_session_save( &session, NULL, 0, &len0 )
|
|
== MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL );
|
|
|
|
/* Allocate first buffer */
|
|
buf1 = mbedtls_calloc( 1, len0 );
|
|
TEST_ASSERT( buf1 != NULL );
|
|
|
|
/* Serialise to buffer and free session lived session */
|
|
TEST_ASSERT( mbedtls_ssl_session_save( &session, buf1, len0, &len1 )
|
|
== 0 );
|
|
TEST_ASSERT( len0 == len1 );
|
|
mbedtls_ssl_session_free( &session );
|
|
|
|
/* Restore session from serialised data */
|
|
TEST_ASSERT( mbedtls_ssl_session_load( &session, buf1, len1) == 0 );
|
|
|
|
/* Allocate second buffer and serialise to it */
|
|
buf2 = mbedtls_calloc( 1, len0 );
|
|
TEST_ASSERT( buf1 != NULL );
|
|
TEST_ASSERT( mbedtls_ssl_session_save( &session, buf2, len0, &len2 )
|
|
== 0 );
|
|
|
|
/* Make sure both serialised versions are identical */
|
|
TEST_ASSERT( len1 == len2 );
|
|
TEST_ASSERT( memcmp( buf1, buf2, len1 ) == 0 );
|
|
|
|
exit:
|
|
mbedtls_ssl_session_free( &session );
|
|
mbedtls_free( buf1 );
|
|
mbedtls_free( buf2 );
|
|
}
|
|
/* END_CASE */
|