eden-emu/mbedtls
14
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Changed mbedtls_platform_memcpy back to memcpy for selftest and test functions

Browse source
This commit is contained in:
Teppo Järvelin 2019-10-04 13:35:55 +03:00
parent 3137fb271a
commit b5c4671a80
11 changed files with 54 additions and 54 deletions
Download patch file Download diff file Expand all files Collapse all files

22
library/aes.c
View file

@ -1992,9 +1992,9 @@ int mbedtls_aes_self_test( int verbose )
{ {
unsigned char tmp[16]; unsigned char tmp[16];
mbedtls_platform_memcpy( tmp, prv, 16 ); memcpy( tmp, prv, 16 );
mbedtls_platform_memcpy( prv, buf, 16 ); memcpy( prv, buf, 16 );
mbedtls_platform_memcpy( buf, tmp, 16 ); memcpy( buf, tmp, 16 );
} }
ret = mbedtls_aes_crypt_cbc( &ctx, mode, 16, iv, buf, buf ); ret = mbedtls_aes_crypt_cbc( &ctx, mode, 16, iv, buf, buf );
@ -2069,12 +2069,12 @@ int mbedtls_aes_self_test( int verbose )
if( mode == MBEDTLS_AES_DECRYPT ) if( mode == MBEDTLS_AES_DECRYPT )
{ {
mbedtls_platform_memcpy( buf, aes_test_cfb128_ct[u], 64 ); memcpy( buf, aes_test_cfb128_ct[u], 64 );
aes_tests = aes_test_cfb128_pt; aes_tests = aes_test_cfb128_pt;
} }
else else
{ {
mbedtls_platform_memcpy( buf, aes_test_cfb128_pt, 64 ); memcpy( buf, aes_test_cfb128_pt, 64 );
aes_tests = aes_test_cfb128_ct[u]; aes_tests = aes_test_cfb128_ct[u];
} }
@ -2148,12 +2148,12 @@ int mbedtls_aes_self_test( int verbose )
if( mode == MBEDTLS_AES_DECRYPT ) if( mode == MBEDTLS_AES_DECRYPT )
{ {
mbedtls_platform_memcpy( buf, aes_test_ofb_ct[u], 64 ); memcpy( buf, aes_test_ofb_ct[u], 64 );
aes_tests = aes_test_ofb_pt; aes_tests = aes_test_ofb_pt;
} }
else else
{ {
mbedtls_platform_memcpy( buf, aes_test_ofb_pt, 64 ); memcpy( buf, aes_test_ofb_pt, 64 );
aes_tests = aes_test_ofb_ct[u]; aes_tests = aes_test_ofb_ct[u];
} }
@ -2215,12 +2215,12 @@ int mbedtls_aes_self_test( int verbose )
if( mode == MBEDTLS_AES_DECRYPT ) if( mode == MBEDTLS_AES_DECRYPT )
{ {
mbedtls_platform_memcpy( buf, aes_test_ctr_ct[u], len ); memcpy( buf, aes_test_ctr_ct[u], len );
aes_tests = aes_test_ctr_pt[u]; aes_tests = aes_test_ctr_pt[u];
} }
else else
{ {
mbedtls_platform_memcpy( buf, aes_test_ctr_pt[u], len ); memcpy( buf, aes_test_ctr_pt[u], len );
aes_tests = aes_test_ctr_ct[u]; aes_tests = aes_test_ctr_ct[u];
} }
@ -2283,7 +2283,7 @@ int mbedtls_aes_self_test( int verbose )
ret = mbedtls_aes_xts_setkey_dec( &ctx_xts, key, 256 ); ret = mbedtls_aes_xts_setkey_dec( &ctx_xts, key, 256 );
if( ret != 0) if( ret != 0)
goto exit; goto exit;
mbedtls_platform_memcpy( buf, aes_test_xts_ct32[u], len ); memcpy( buf, aes_test_xts_ct32[u], len );
aes_tests = aes_test_xts_pt32[u]; aes_tests = aes_test_xts_pt32[u];
} }
else else
@ -2291,7 +2291,7 @@ int mbedtls_aes_self_test( int verbose )
ret = mbedtls_aes_xts_setkey_enc( &ctx_xts, key, 256 ); ret = mbedtls_aes_xts_setkey_enc( &ctx_xts, key, 256 );
if( ret != 0) if( ret != 0)
goto exit; goto exit;
mbedtls_platform_memcpy( buf, aes_test_xts_pt32[u], len ); memcpy( buf, aes_test_xts_pt32[u], len );
aes_tests = aes_test_xts_ct32[u]; aes_tests = aes_test_xts_ct32[u];
} }

2
library/arc4.c
View file

@ -169,7 +169,7 @@ int mbedtls_arc4_self_test( int verbose )
if( verbose != 0 ) if( verbose != 0 )
mbedtls_printf( " ARC4 test #%d: ", i + 1 ); mbedtls_printf( " ARC4 test #%d: ", i + 1 );
mbedtls_platform_memcpy( ibuf, arc4_test_pt[i], 8 ); memcpy( ibuf, arc4_test_pt[i], 8 );
mbedtls_arc4_setup( &ctx, arc4_test_key[i], 8 ); mbedtls_arc4_setup( &ctx, arc4_test_key[i], 8 );
mbedtls_arc4_crypt( &ctx, 8, ibuf, obuf ); mbedtls_arc4_crypt( &ctx, 8, ibuf, obuf );

16
library/aria.c
View file

@ -986,8 +986,8 @@ int mbedtls_aria_self_test( int verbose )
if( verbose ) if( verbose )
mbedtls_printf( " ARIA-CBC-%d (enc): ", 128 + 64 * i ); mbedtls_printf( " ARIA-CBC-%d (enc): ", 128 + 64 * i );
mbedtls_aria_setkey_enc( &ctx, aria_test2_key, 128 + 64 * i ); mbedtls_aria_setkey_enc( &ctx, aria_test2_key, 128 + 64 * i );
mbedtls_platform_memcpy( iv, aria_test2_iv, MBEDTLS_ARIA_BLOCKSIZE ); memcpy( iv, aria_test2_iv, MBEDTLS_ARIA_BLOCKSIZE );
mbedtls_platform_memset( buf, 0x55, sizeof( buf ) ); memset( buf, 0x55, sizeof( buf ) );
mbedtls_aria_crypt_cbc( &ctx, MBEDTLS_ARIA_ENCRYPT, 48, iv, mbedtls_aria_crypt_cbc( &ctx, MBEDTLS_ARIA_ENCRYPT, 48, iv,
aria_test2_pt, buf ); aria_test2_pt, buf );
if( memcmp( buf, aria_test2_cbc_ct[i], 48 ) != 0 ) if( memcmp( buf, aria_test2_cbc_ct[i], 48 ) != 0 )
@ -997,8 +997,8 @@ int mbedtls_aria_self_test( int verbose )
if( verbose ) if( verbose )
mbedtls_printf( " ARIA-CBC-%d (dec): ", 128 + 64 * i ); mbedtls_printf( " ARIA-CBC-%d (dec): ", 128 + 64 * i );
mbedtls_aria_setkey_dec( &ctx, aria_test2_key, 128 + 64 * i ); mbedtls_aria_setkey_dec( &ctx, aria_test2_key, 128 + 64 * i );
mbedtls_platform_memcpy( iv, aria_test2_iv, MBEDTLS_ARIA_BLOCKSIZE ); memcpy( iv, aria_test2_iv, MBEDTLS_ARIA_BLOCKSIZE );
mbedtls_platform_memset( buf, 0xAA, sizeof( buf ) ); memset( buf, 0xAA, sizeof( buf ) );
mbedtls_aria_crypt_cbc( &ctx, MBEDTLS_ARIA_DECRYPT, 48, iv, mbedtls_aria_crypt_cbc( &ctx, MBEDTLS_ARIA_DECRYPT, 48, iv,
aria_test2_cbc_ct[i], buf ); aria_test2_cbc_ct[i], buf );
if( memcmp( buf, aria_test2_pt, 48 ) != 0 ) if( memcmp( buf, aria_test2_pt, 48 ) != 0 )
@ -1016,8 +1016,8 @@ int mbedtls_aria_self_test( int verbose )
if( verbose ) if( verbose )
mbedtls_printf( " ARIA-CFB-%d (enc): ", 128 + 64 * i ); mbedtls_printf( " ARIA-CFB-%d (enc): ", 128 + 64 * i );
mbedtls_aria_setkey_enc( &ctx, aria_test2_key, 128 + 64 * i ); mbedtls_aria_setkey_enc( &ctx, aria_test2_key, 128 + 64 * i );
mbedtls_platform_memcpy( iv, aria_test2_iv, MBEDTLS_ARIA_BLOCKSIZE ); memcpy( iv, aria_test2_iv, MBEDTLS_ARIA_BLOCKSIZE );
mbedtls_platform_memset( buf, 0x55, sizeof( buf ) ); memset( buf, 0x55, sizeof( buf ) );
j = 0; j = 0;
mbedtls_aria_crypt_cfb128( &ctx, MBEDTLS_ARIA_ENCRYPT, 48, &j, iv, mbedtls_aria_crypt_cfb128( &ctx, MBEDTLS_ARIA_ENCRYPT, 48, &j, iv,
aria_test2_pt, buf ); aria_test2_pt, buf );
@ -1028,8 +1028,8 @@ int mbedtls_aria_self_test( int verbose )
if( verbose ) if( verbose )
mbedtls_printf( " ARIA-CFB-%d (dec): ", 128 + 64 * i ); mbedtls_printf( " ARIA-CFB-%d (dec): ", 128 + 64 * i );
mbedtls_aria_setkey_enc( &ctx, aria_test2_key, 128 + 64 * i ); mbedtls_aria_setkey_enc( &ctx, aria_test2_key, 128 + 64 * i );
mbedtls_platform_memcpy( iv, aria_test2_iv, MBEDTLS_ARIA_BLOCKSIZE ); memcpy( iv, aria_test2_iv, MBEDTLS_ARIA_BLOCKSIZE );
mbedtls_platform_memset( buf, 0xAA, sizeof( buf ) ); memset( buf, 0xAA, sizeof( buf ) );
j = 0; j = 0;
mbedtls_aria_crypt_cfb128( &ctx, MBEDTLS_ARIA_DECRYPT, 48, &j, mbedtls_aria_crypt_cfb128( &ctx, MBEDTLS_ARIA_DECRYPT, 48, &j,
iv, aria_test2_cfb_ct[i], buf ); iv, aria_test2_cfb_ct[i], buf );

36
library/camellia.c
View file

@ -962,16 +962,16 @@ int mbedtls_camellia_self_test( int verbose )
(v == MBEDTLS_CAMELLIA_DECRYPT) ? "dec" : "enc"); (v == MBEDTLS_CAMELLIA_DECRYPT) ? "dec" : "enc");
for( i = 0; i < CAMELLIA_TESTS_ECB; i++ ) { for( i = 0; i < CAMELLIA_TESTS_ECB; i++ ) {
mbedtls_platform_memcpy( key, camellia_test_ecb_key[u][i], 16 + 8 * u ); memcpy( key, camellia_test_ecb_key[u][i], 16 + 8 * u );
if( v == MBEDTLS_CAMELLIA_DECRYPT ) { if( v == MBEDTLS_CAMELLIA_DECRYPT ) {
mbedtls_camellia_setkey_dec( &ctx, key, 128 + u * 64 ); mbedtls_camellia_setkey_dec( &ctx, key, 128 + u * 64 );
mbedtls_platform_memcpy( src, camellia_test_ecb_cipher[u][i], 16 ); memcpy( src, camellia_test_ecb_cipher[u][i], 16 );
mbedtls_platform_memcpy( dst, camellia_test_ecb_plain[i], 16 ); memcpy( dst, camellia_test_ecb_plain[i], 16 );
} else { /* MBEDTLS_CAMELLIA_ENCRYPT */ } else { /* MBEDTLS_CAMELLIA_ENCRYPT */
mbedtls_camellia_setkey_enc( &ctx, key, 128 + u * 64 ); mbedtls_camellia_setkey_enc( &ctx, key, 128 + u * 64 );
mbedtls_platform_memcpy( src, camellia_test_ecb_plain[i], 16 ); memcpy( src, camellia_test_ecb_plain[i], 16 );
mbedtls_platform_memcpy( dst, camellia_test_ecb_cipher[u][i], 16 ); memcpy( dst, camellia_test_ecb_cipher[u][i], 16 );
} }
mbedtls_camellia_crypt_ecb( &ctx, v, src, buf ); mbedtls_camellia_crypt_ecb( &ctx, v, src, buf );
@ -1005,9 +1005,9 @@ int mbedtls_camellia_self_test( int verbose )
mbedtls_printf( " CAMELLIA-CBC-%3d (%s): ", 128 + u * 64, mbedtls_printf( " CAMELLIA-CBC-%3d (%s): ", 128 + u * 64,
( v == MBEDTLS_CAMELLIA_DECRYPT ) ? "dec" : "enc" ); ( v == MBEDTLS_CAMELLIA_DECRYPT ) ? "dec" : "enc" );
mbedtls_platform_memcpy( src, camellia_test_cbc_iv, 16 ); memcpy( src, camellia_test_cbc_iv, 16 );
mbedtls_platform_memcpy( dst, camellia_test_cbc_iv, 16 ); memcpy( dst, camellia_test_cbc_iv, 16 );
mbedtls_platform_memcpy( key, camellia_test_cbc_key[u], 16 + 8 * u ); memcpy( key, camellia_test_cbc_key[u], 16 + 8 * u );
if( v == MBEDTLS_CAMELLIA_DECRYPT ) { if( v == MBEDTLS_CAMELLIA_DECRYPT ) {
mbedtls_camellia_setkey_dec( &ctx, key, 128 + u * 64 ); mbedtls_camellia_setkey_dec( &ctx, key, 128 + u * 64 );
@ -1018,13 +1018,13 @@ int mbedtls_camellia_self_test( int verbose )
for( i = 0; i < CAMELLIA_TESTS_CBC; i++ ) { for( i = 0; i < CAMELLIA_TESTS_CBC; i++ ) {
if( v == MBEDTLS_CAMELLIA_DECRYPT ) { if( v == MBEDTLS_CAMELLIA_DECRYPT ) {
mbedtls_platform_memcpy( iv , src, 16 ); memcpy( iv , src, 16 );
mbedtls_platform_memcpy( src, camellia_test_cbc_cipher[u][i], 16 ); memcpy( src, camellia_test_cbc_cipher[u][i], 16 );
mbedtls_platform_memcpy( dst, camellia_test_cbc_plain[i], 16 ); memcpy( dst, camellia_test_cbc_plain[i], 16 );
} else { /* MBEDTLS_CAMELLIA_ENCRYPT */ } else { /* MBEDTLS_CAMELLIA_ENCRYPT */
mbedtls_platform_memcpy( iv , dst, 16 ); memcpy( iv , dst, 16 );
mbedtls_platform_memcpy( src, camellia_test_cbc_plain[i], 16 ); memcpy( src, camellia_test_cbc_plain[i], 16 );
mbedtls_platform_memcpy( dst, camellia_test_cbc_cipher[u][i], 16 ); memcpy( dst, camellia_test_cbc_cipher[u][i], 16 );
} }
mbedtls_camellia_crypt_cbc( &ctx, v, 16, iv, src, buf ); mbedtls_camellia_crypt_cbc( &ctx, v, 16, iv, src, buf );
@ -1059,8 +1059,8 @@ int mbedtls_camellia_self_test( int verbose )
mbedtls_printf( " CAMELLIA-CTR-128 (%s): ", mbedtls_printf( " CAMELLIA-CTR-128 (%s): ",
( v == MBEDTLS_CAMELLIA_DECRYPT ) ? "dec" : "enc" ); ( v == MBEDTLS_CAMELLIA_DECRYPT ) ? "dec" : "enc" );
mbedtls_platform_memcpy( nonce_counter, camellia_test_ctr_nonce_counter[u], 16 ); memcpy( nonce_counter, camellia_test_ctr_nonce_counter[u], 16 );
mbedtls_platform_memcpy( key, camellia_test_ctr_key[u], 16 ); memcpy( key, camellia_test_ctr_key[u], 16 );
offset = 0; offset = 0;
mbedtls_camellia_setkey_enc( &ctx, key, 128 ); mbedtls_camellia_setkey_enc( &ctx, key, 128 );
@ -1068,7 +1068,7 @@ int mbedtls_camellia_self_test( int verbose )
if( v == MBEDTLS_CAMELLIA_DECRYPT ) if( v == MBEDTLS_CAMELLIA_DECRYPT )
{ {
len = camellia_test_ctr_len[u]; len = camellia_test_ctr_len[u];
mbedtls_platform_memcpy( buf, camellia_test_ctr_ct[u], len ); memcpy( buf, camellia_test_ctr_ct[u], len );
mbedtls_camellia_crypt_ctr( &ctx, len, &offset, nonce_counter, stream_block, mbedtls_camellia_crypt_ctr( &ctx, len, &offset, nonce_counter, stream_block,
buf, buf ); buf, buf );
@ -1084,7 +1084,7 @@ int mbedtls_camellia_self_test( int verbose )
else else
{ {
len = camellia_test_ctr_len[u]; len = camellia_test_ctr_len[u];
mbedtls_platform_memcpy( buf, camellia_test_ctr_pt[u], len ); memcpy( buf, camellia_test_ctr_pt[u], len );
mbedtls_camellia_crypt_ctr( &ctx, len, &offset, nonce_counter, stream_block, mbedtls_camellia_crypt_ctr( &ctx, len, &offset, nonce_counter, stream_block,
buf, buf ); buf, buf );

6
library/ccm.c
View file

@ -495,9 +495,9 @@ int mbedtls_ccm_self_test( int verbose )
if( verbose != 0 ) if( verbose != 0 )
mbedtls_printf( " CCM-AES #%u: ", (unsigned int) i + 1 ); mbedtls_printf( " CCM-AES #%u: ", (unsigned int) i + 1 );
mbedtls_platform_memset( plaintext, 0, CCM_SELFTEST_PT_MAX_LEN ); memset( plaintext, 0, CCM_SELFTEST_PT_MAX_LEN );
mbedtls_platform_memset( ciphertext, 0, CCM_SELFTEST_CT_MAX_LEN ); memset( ciphertext, 0, CCM_SELFTEST_CT_MAX_LEN );
mbedtls_platform_memcpy( plaintext, msg, msg_len[i] ); memcpy( plaintext, msg, msg_len[i] );
ret = mbedtls_ccm_encrypt_and_tag( &ctx, msg_len[i], ret = mbedtls_ccm_encrypt_and_tag( &ctx, msg_len[i],
iv, iv_len[i], ad, add_len[i], iv, iv_len[i], ad, add_len[i],

2
library/ctr_drbg.c
View file

@ -649,7 +649,7 @@ static int ctr_drbg_self_test_entropy( void *data, unsigned char *buf,
size_t len ) size_t len )
{ {
const unsigned char *p = data; const unsigned char *p = data;
mbedtls_platform_memcpy( buf, p + test_offset, len ); memcpy( buf, p + test_offset, len );
test_offset += len; test_offset += len;
return( 0 ); return( 0 );
} }

16
library/des.c
View file

@ -896,7 +896,7 @@ int mbedtls_des_self_test( int verbose )
( u == 0 ) ? ' ' : '3', 56 + u * 56, ( u == 0 ) ? ' ' : '3', 56 + u * 56,
( v == MBEDTLS_DES_DECRYPT ) ? "dec" : "enc" ); ( v == MBEDTLS_DES_DECRYPT ) ? "dec" : "enc" );
mbedtls_platform_memcpy( buf, des3_test_buf, 8 ); memcpy( buf, des3_test_buf, 8 );
switch( i ) switch( i )
{ {
@ -969,9 +969,9 @@ int mbedtls_des_self_test( int verbose )
( u == 0 ) ? ' ' : '3', 56 + u * 56, ( u == 0 ) ? ' ' : '3', 56 + u * 56,
( v == MBEDTLS_DES_DECRYPT ) ? "dec" : "enc" ); ( v == MBEDTLS_DES_DECRYPT ) ? "dec" : "enc" );
mbedtls_platform_memcpy( iv, des3_test_iv, 8 ); memcpy( iv, des3_test_iv, 8 );
mbedtls_platform_memcpy( prv, des3_test_iv, 8 ); memcpy( prv, des3_test_iv, 8 );
mbedtls_platform_memcpy( buf, des3_test_buf, 8 ); memcpy( buf, des3_test_buf, 8 );
switch( i ) switch( i )
{ {
@ -1024,12 +1024,12 @@ int mbedtls_des_self_test( int verbose )
else else
mbedtls_des3_crypt_cbc( &ctx3, v, 8, iv, buf, buf ); mbedtls_des3_crypt_cbc( &ctx3, v, 8, iv, buf, buf );
mbedtls_platform_memcpy( tmp, prv, 8 ); memcpy( tmp, prv, 8 );
mbedtls_platform_memcpy( prv, buf, 8 ); memcpy( prv, buf, 8 );
mbedtls_platform_memcpy( buf, tmp, 8 ); memcpy( buf, tmp, 8 );
} }
mbedtls_platform_memcpy( buf, prv, 8 ); memcpy( buf, prv, 8 );
} }
if( ( v == MBEDTLS_DES_DECRYPT && if( ( v == MBEDTLS_DES_DECRYPT &&

2
library/ecjpake.c
View file

@ -983,7 +983,7 @@ static int ecjpake_lgc( void *p, unsigned char *out, size_t len )
{ {
size_t use_len = len > 4 ? 4 : len; size_t use_len = len > 4 ? 4 : len;
x = 1664525 * x + 1013904223; x = 1664525 * x + 1013904223;
mbedtls_platform_memcpy( out, &x, use_len ); memcpy( out, &x, use_len );
out += use_len; out += use_len;
len -= use_len; len -= use_len;
} }

2
library/hmac_drbg.c
View file

@ -547,7 +547,7 @@ static int hmac_drbg_self_test_entropy( void *data,
unsigned char *buf, size_t len ) unsigned char *buf, size_t len )
{ {
const unsigned char *p = data; const unsigned char *p = data;
mbedtls_platform_memcpy( buf, p + test_offset, len ); memcpy( buf, p + test_offset, len );
test_offset += len; test_offset += len;
return( 0 ); return( 0 );
} }

2
library/rsa.c
View file

@ -2623,7 +2623,7 @@ int mbedtls_rsa_self_test( int verbose )
if( verbose != 0 ) if( verbose != 0 )
mbedtls_printf( "passed\n PKCS#1 encryption : " ); mbedtls_printf( "passed\n PKCS#1 encryption : " );
mbedtls_platform_memcpy( rsa_plaintext, RSA_PT, PT_LEN ); memcpy( rsa_plaintext, RSA_PT, PT_LEN );
if( mbedtls_rsa_pkcs1_encrypt( &rsa, myrand, NULL, MBEDTLS_RSA_PUBLIC, if( mbedtls_rsa_pkcs1_encrypt( &rsa, myrand, NULL, MBEDTLS_RSA_PUBLIC,
PT_LEN, rsa_plaintext, PT_LEN, rsa_plaintext,

2
library/xtea.c
View file

@ -245,7 +245,7 @@ int mbedtls_xtea_self_test( int verbose )
if( verbose != 0 ) if( verbose != 0 )
mbedtls_printf( " XTEA test #%d: ", i + 1 ); mbedtls_printf( " XTEA test #%d: ", i + 1 );
mbedtls_platform_memcpy( buf, xtea_test_pt[i], 8 ); memcpy( buf, xtea_test_pt[i], 8 );
mbedtls_xtea_setup( &ctx, xtea_test_key[i] ); mbedtls_xtea_setup( &ctx, xtea_test_key[i] );
mbedtls_xtea_crypt_ecb( &ctx, MBEDTLS_XTEA_ENCRYPT, buf, buf ); mbedtls_xtea_crypt_ecb( &ctx, MBEDTLS_XTEA_ENCRYPT, buf, buf );