mbedtls/programs/test/benchmark.c

947 lines
33 KiB
C
Raw Normal View History

/*
* Benchmark demonstration program
*
* Copyright (C) 2006-2016, ARM Limited, All Rights Reserved
2015-09-04 14:21:07 +02:00
* SPDX-License-Identifier: Apache-2.0
2010-07-18 22:36:00 +02:00
*
2015-09-04 14:21:07 +02:00
* Licensed under the Apache License, Version 2.0 (the "License"); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
2010-07-18 22:36:00 +02:00
*
2015-09-04 14:21:07 +02:00
* http://www.apache.org/licenses/LICENSE-2.0
*
2015-09-04 14:21:07 +02:00
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
2015-09-04 14:21:07 +02:00
* This file is part of mbed TLS (https://tls.mbed.org)
*/
#if !defined(MBEDTLS_CONFIG_FILE)
2015-03-09 18:05:11 +01:00
#include "mbedtls/config.h"
#else
#include MBEDTLS_CONFIG_FILE
#endif
#if defined(MBEDTLS_PLATFORM_C)
2015-03-09 18:05:11 +01:00
#include "mbedtls/platform.h"
#else
#include <stdio.h>
#define mbedtls_exit exit
#define mbedtls_printf printf
#define mbedtls_snprintf snprintf
#define mbedtls_free free
#endif
#if !defined(MBEDTLS_TIMING_C)
2015-02-16 18:32:47 +01:00
int main( void )
{
mbedtls_printf("MBEDTLS_TIMING_C not defined.\n");
2015-02-16 18:32:47 +01:00
return( 0 );
}
#else
2014-12-19 12:10:37 +01:00
2015-02-16 18:32:47 +01:00
#include <string.h>
#include <stdlib.h>
2014-12-19 12:10:37 +01:00
2015-03-09 18:05:11 +01:00
#include "mbedtls/timing.h"
2015-03-09 18:05:11 +01:00
#include "mbedtls/md4.h"
#include "mbedtls/md5.h"
#include "mbedtls/ripemd160.h"
#include "mbedtls/sha1.h"
#include "mbedtls/sha256.h"
#include "mbedtls/sha512.h"
#include "mbedtls/arc4.h"
#include "mbedtls/des.h"
#include "mbedtls/aes.h"
#include "mbedtls/blowfish.h"
#include "mbedtls/camellia.h"
2016-05-15 22:28:08 +02:00
#include "mbedtls/chacha20.h"
2015-03-09 18:05:11 +01:00
#include "mbedtls/gcm.h"
#include "mbedtls/ccm.h"
2018-05-09 10:21:28 +02:00
#include "mbedtls/chachapoly.h"
#include "mbedtls/cmac.h"
#include "mbedtls/poly1305.h"
2015-03-09 18:05:11 +01:00
#include "mbedtls/havege.h"
#include "mbedtls/ctr_drbg.h"
#include "mbedtls/hmac_drbg.h"
#include "mbedtls/rsa.h"
#include "mbedtls/dhm.h"
#include "mbedtls/ecdsa.h"
#include "mbedtls/ecdh.h"
#include "mbedtls/error.h"
#if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C)
2015-03-09 18:05:11 +01:00
#include "mbedtls/memory_buffer_alloc.h"
#endif
2015-02-16 18:32:47 +01:00
/*
* For heap usage estimates, we need an estimate of the overhead per allocated
* block. ptmalloc2/3 (used in gnu libc for instance) uses 2 size_t per block,
* so use that as our baseline.
*/
#define MEM_BLOCK_OVERHEAD ( 2 * sizeof( size_t ) )
/*
* Size to use for the alloc buffer if MEMORY_BUFFER_ALLOC_C is defined.
2015-02-16 18:32:47 +01:00
*/
#define HEAP_SIZE (1u << 16) // 64k
2011-11-29 12:23:58 +01:00
#define BUFSIZE 1024
2014-01-30 20:59:00 +01:00
#define HEADER_FORMAT " %-24s : "
#define TITLE_LEN 25
2015-02-13 15:12:07 +01:00
#define OPTIONS \
2015-05-11 19:21:39 +02:00
"md4, md5, ripemd160, sha1, sha256, sha512,\n" \
2016-05-15 22:28:08 +02:00
"arc4, des3, des, camellia, blowfish, chacha20,\n" \
2018-06-04 12:30:04 +02:00
"aes_cbc, aes_gcm, aes_ccm, chachapoly,\n" \
"aes_cmac, des3_cmac, poly1305\n" \
"havege, ctr_drbg, hmac_drbg\n" \
"rsa, dhm, ecdsa, ecdh.\n"
#if defined(MBEDTLS_ERROR_C)
#define PRINT_ERROR \
mbedtls_strerror( ret, ( char * )tmp, sizeof( tmp ) ); \
mbedtls_printf( "FAILED: %s\n", tmp );
#else
#define PRINT_ERROR \
mbedtls_printf( "FAILED: -0x%04x\n", -ret );
#endif
#define TIME_AND_TSC( TITLE, CODE ) \
do { \
unsigned long ii, jj, tsc; \
\
mbedtls_printf( HEADER_FORMAT, TITLE ); \
fflush( stdout ); \
\
mbedtls_set_alarm( 1 ); \
for( ii = 1; ! mbedtls_timing_alarmed; ii++ ) \
{ \
CODE; \
} \
\
tsc = mbedtls_timing_hardclock(); \
for( jj = 0; jj < 1024; jj++ ) \
{ \
CODE; \
} \
\
mbedtls_printf( "%9lu KiB/s, %9lu cycles/byte\n", \
ii * BUFSIZE / 1024, \
( mbedtls_timing_hardclock() - tsc ) / ( jj * BUFSIZE ) ); \
} while( 0 )
#if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C) && defined(MBEDTLS_MEMORY_DEBUG)
2014-12-19 12:10:37 +01:00
#define MEMORY_MEASURE_INIT \
size_t max_used, max_blocks, max_bytes; \
size_t prv_used, prv_blocks; \
mbedtls_memory_buffer_alloc_cur_get( &prv_used, &prv_blocks ); \
mbedtls_memory_buffer_alloc_max_reset( );
2014-12-19 12:10:37 +01:00
#define MEMORY_MEASURE_PRINT( title_len ) \
mbedtls_memory_buffer_alloc_max_get( &max_used, &max_blocks ); \
for( ii = 12 - title_len; ii != 0; ii-- ) mbedtls_printf( " " ); \
2014-12-19 12:10:37 +01:00
max_used -= prv_used; \
max_blocks -= prv_blocks; \
max_bytes = max_used + MEM_BLOCK_OVERHEAD * max_blocks; \
mbedtls_printf( "%6u heap bytes", (unsigned) max_bytes );
2014-12-19 12:10:37 +01:00
#else
#define MEMORY_MEASURE_INIT
#define MEMORY_MEASURE_PRINT( title_len )
2014-12-19 12:10:37 +01:00
#endif
#define TIME_PUBLIC( TITLE, TYPE, CODE ) \
do { \
unsigned long ii; \
int ret; \
2014-12-19 12:10:37 +01:00
MEMORY_MEASURE_INIT; \
\
mbedtls_printf( HEADER_FORMAT, TITLE ); \
fflush( stdout ); \
mbedtls_set_alarm( 3 ); \
\
ret = 0; \
for( ii = 1; ! mbedtls_timing_alarmed && ! ret ; ii++ ) \
{ \
CODE; \
} \
\
if( ret != 0 ) \
{ \
2014-12-19 12:10:37 +01:00
PRINT_ERROR; \
} \
else \
2014-12-19 12:10:37 +01:00
{ \
mbedtls_printf( "%6lu " TYPE "/s", ii / 3 ); \
2014-12-19 12:10:37 +01:00
MEMORY_MEASURE_PRINT( sizeof( TYPE ) + 1 ); \
mbedtls_printf( "\n" ); \
2014-12-19 12:10:37 +01:00
} \
} while( 0 )
static int myrand( void *rng_state, unsigned char *output, size_t len )
{
size_t use_len;
int rnd;
if( rng_state != NULL )
rng_state = NULL;
while( len > 0 )
{
use_len = len;
if( use_len > sizeof(int) )
use_len = sizeof(int);
rnd = rand();
memcpy( output, &rnd, use_len );
output += use_len;
len -= use_len;
}
return( 0 );
}
2014-12-19 12:10:37 +01:00
/*
* Clear some memory that was used to prepare the context
*/
#if defined(MBEDTLS_ECP_C)
void ecp_clear_precomputed( mbedtls_ecp_group *grp )
2014-12-19 12:10:37 +01:00
{
if( grp->T != NULL )
{
size_t i;
for( i = 0; i < grp->T_size; i++ )
mbedtls_ecp_point_free( &grp->T[i] );
mbedtls_free( grp->T );
2014-12-19 12:10:37 +01:00
}
grp->T = NULL;
grp->T_size = 0;
}
#else
#define ecp_clear_precomputed( g )
#endif
unsigned char buf[BUFSIZE];
2013-09-17 15:30:51 +02:00
typedef struct {
2015-05-11 19:21:39 +02:00
char md4, md5, ripemd160, sha1, sha256, sha512,
arc4, des3, des,
2018-05-09 10:21:28 +02:00
aes_cbc, aes_gcm, aes_ccm, chachapoly,
aes_cmac, des3_cmac,
2016-05-15 22:28:08 +02:00
camellia, blowfish, chacha20,
poly1305,
2014-01-30 20:59:00 +01:00
havege, ctr_drbg, hmac_drbg,
2013-09-17 16:04:08 +02:00
rsa, dhm, ecdsa, ecdh;
2013-09-17 15:30:51 +02:00
} todo_list;
int main( int argc, char *argv[] )
{
int i;
2013-09-17 16:04:08 +02:00
unsigned char tmp[200];
char title[TITLE_LEN];
2013-09-17 15:30:51 +02:00
todo_list todo;
#if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C)
unsigned char alloc_buf[HEAP_SIZE] = { 0 };
#endif
if( argc <= 1 )
{
2013-09-17 15:30:51 +02:00
memset( &todo, 1, sizeof( todo ) );
}
2013-09-17 15:30:51 +02:00
else
{
memset( &todo, 0, sizeof( todo ) );
for( i = 1; i < argc; i++ )
{
2015-05-11 19:21:39 +02:00
if( strcmp( argv[i], "md4" ) == 0 )
todo.md4 = 1;
else if( strcmp( argv[i], "md5" ) == 0 )
todo.md5 = 1;
else if( strcmp( argv[i], "ripemd160" ) == 0 )
todo.ripemd160 = 1;
else if( strcmp( argv[i], "sha1" ) == 0 )
todo.sha1 = 1;
else if( strcmp( argv[i], "sha256" ) == 0 )
todo.sha256 = 1;
else if( strcmp( argv[i], "sha512" ) == 0 )
todo.sha512 = 1;
2013-09-17 15:30:51 +02:00
else if( strcmp( argv[i], "arc4" ) == 0 )
todo.arc4 = 1;
else if( strcmp( argv[i], "des3" ) == 0 )
todo.des3 = 1;
else if( strcmp( argv[i], "des" ) == 0 )
todo.des = 1;
else if( strcmp( argv[i], "aes_cbc" ) == 0 )
todo.aes_cbc = 1;
else if( strcmp( argv[i], "aes_gcm" ) == 0 )
todo.aes_gcm = 1;
2014-05-07 12:03:02 +02:00
else if( strcmp( argv[i], "aes_ccm" ) == 0 )
todo.aes_ccm = 1;
2018-05-09 10:21:28 +02:00
else if( strcmp( argv[i], "chachapoly" ) == 0 )
todo.chachapoly = 1;
else if( strcmp( argv[i], "aes_cmac" ) == 0 )
todo.aes_cmac = 1;
else if( strcmp( argv[i], "des3_cmac" ) == 0 )
todo.des3_cmac = 1;
2013-09-17 15:30:51 +02:00
else if( strcmp( argv[i], "camellia" ) == 0 )
todo.camellia = 1;
else if( strcmp( argv[i], "blowfish" ) == 0 )
todo.blowfish = 1;
2016-05-15 22:28:08 +02:00
else if( strcmp( argv[i], "chacha20" ) == 0 )
todo.chacha20 = 1;
else if( strcmp( argv[i], "poly1305" ) == 0 )
todo.poly1305 = 1;
2013-09-17 15:30:51 +02:00
else if( strcmp( argv[i], "havege" ) == 0 )
todo.havege = 1;
else if( strcmp( argv[i], "ctr_drbg" ) == 0 )
todo.ctr_drbg = 1;
2014-01-30 20:59:00 +01:00
else if( strcmp( argv[i], "hmac_drbg" ) == 0 )
todo.hmac_drbg = 1;
2013-09-17 15:30:51 +02:00
else if( strcmp( argv[i], "rsa" ) == 0 )
todo.rsa = 1;
else if( strcmp( argv[i], "dhm" ) == 0 )
todo.dhm = 1;
2013-09-17 16:04:08 +02:00
else if( strcmp( argv[i], "ecdsa" ) == 0 )
todo.ecdsa = 1;
else if( strcmp( argv[i], "ecdh" ) == 0 )
todo.ecdh = 1;
2013-09-17 15:30:51 +02:00
else
{
mbedtls_printf( "Unrecognized option: %s\n", argv[i] );
mbedtls_printf( "Available options: " OPTIONS );
2013-09-17 15:30:51 +02:00
}
}
}
mbedtls_printf( "\n" );
#if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C)
mbedtls_memory_buffer_alloc_init( alloc_buf, sizeof( alloc_buf ) );
#endif
2013-09-17 15:30:51 +02:00
memset( buf, 0xAA, sizeof( buf ) );
memset( tmp, 0xBB, sizeof( tmp ) );
2013-09-17 15:30:51 +02:00
#if defined(MBEDTLS_MD4_C)
2015-05-11 19:21:39 +02:00
if( todo.md4 )
TIME_AND_TSC( "MD4", mbedtls_md4_ret( buf, BUFSIZE, tmp ) );
#endif
#if defined(MBEDTLS_MD5_C)
2015-05-11 19:21:39 +02:00
if( todo.md5 )
TIME_AND_TSC( "MD5", mbedtls_md5_ret( buf, BUFSIZE, tmp ) );
#endif
#if defined(MBEDTLS_RIPEMD160_C)
2015-05-11 19:21:39 +02:00
if( todo.ripemd160 )
TIME_AND_TSC( "RIPEMD160", mbedtls_ripemd160_ret( buf, BUFSIZE, tmp ) );
2014-01-17 14:29:46 +01:00
#endif
#if defined(MBEDTLS_SHA1_C)
2015-05-11 19:21:39 +02:00
if( todo.sha1 )
TIME_AND_TSC( "SHA-1", mbedtls_sha1_ret( buf, BUFSIZE, tmp ) );
#endif
#if defined(MBEDTLS_SHA256_C)
2015-05-11 19:21:39 +02:00
if( todo.sha256 )
TIME_AND_TSC( "SHA-256", mbedtls_sha256_ret( buf, BUFSIZE, tmp, 0 ) );
#endif
#if defined(MBEDTLS_SHA512_C)
2015-05-11 19:21:39 +02:00
if( todo.sha512 )
TIME_AND_TSC( "SHA-512", mbedtls_sha512_ret( buf, BUFSIZE, tmp, 0 ) );
2009-02-09 23:33:30 +01:00
#endif
#if defined(MBEDTLS_ARC4_C)
2013-09-17 15:30:51 +02:00
if( todo.arc4 )
{
mbedtls_arc4_context arc4;
mbedtls_arc4_init( &arc4 );
mbedtls_arc4_setup( &arc4, tmp, 32 );
TIME_AND_TSC( "ARC4", mbedtls_arc4_crypt( &arc4, BUFSIZE, buf, buf ) );
mbedtls_arc4_free( &arc4 );
}
#endif
#if defined(MBEDTLS_DES_C)
#if defined(MBEDTLS_CIPHER_MODE_CBC)
2013-09-17 15:30:51 +02:00
if( todo.des3 )
{
mbedtls_des3_context des3;
mbedtls_des3_init( &des3 );
mbedtls_des3_set3key_enc( &des3, tmp );
TIME_AND_TSC( "3DES",
mbedtls_des3_crypt_cbc( &des3, MBEDTLS_DES_ENCRYPT, BUFSIZE, tmp, buf, buf ) );
mbedtls_des3_free( &des3 );
}
2013-09-17 15:30:51 +02:00
if( todo.des )
{
mbedtls_des_context des;
mbedtls_des_init( &des );
mbedtls_des_setkey_enc( &des, tmp );
TIME_AND_TSC( "DES",
mbedtls_des_crypt_cbc( &des, MBEDTLS_DES_ENCRYPT, BUFSIZE, tmp, buf, buf ) );
mbedtls_des_free( &des );
}
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#if defined(MBEDTLS_CMAC_C)
if( todo.des3_cmac )
{
unsigned char output[8];
const mbedtls_cipher_info_t *cipher_info;
memset( buf, 0, sizeof( buf ) );
memset( tmp, 0, sizeof( tmp ) );
cipher_info = mbedtls_cipher_info_from_type( MBEDTLS_CIPHER_DES_EDE3_ECB );
TIME_AND_TSC( "3DES-CMAC",
mbedtls_cipher_cmac( cipher_info, tmp, 192, buf,
BUFSIZE, output ) );
}
#endif /* MBEDTLS_CMAC_C */
#endif /* MBEDTLS_DES_C */
#if defined(MBEDTLS_AES_C)
#if defined(MBEDTLS_CIPHER_MODE_CBC)
2013-09-17 15:30:51 +02:00
if( todo.aes_cbc )
{
int keysize;
mbedtls_aes_context aes;
mbedtls_aes_init( &aes );
for( keysize = 128; keysize <= 256; keysize += 64 )
{
mbedtls_snprintf( title, sizeof( title ), "AES-CBC-%d", keysize );
memset( buf, 0, sizeof( buf ) );
memset( tmp, 0, sizeof( tmp ) );
mbedtls_aes_setkey_enc( &aes, tmp, keysize );
TIME_AND_TSC( title,
mbedtls_aes_crypt_cbc( &aes, MBEDTLS_AES_ENCRYPT, BUFSIZE, tmp, buf, buf ) );
}
mbedtls_aes_free( &aes );
}
#endif
#if defined(MBEDTLS_GCM_C)
2013-09-17 15:30:51 +02:00
if( todo.aes_gcm )
{
int keysize;
mbedtls_gcm_context gcm;
mbedtls_gcm_init( &gcm );
for( keysize = 128; keysize <= 256; keysize += 64 )
{
mbedtls_snprintf( title, sizeof( title ), "AES-GCM-%d", keysize );
memset( buf, 0, sizeof( buf ) );
memset( tmp, 0, sizeof( tmp ) );
mbedtls_gcm_setkey( &gcm, MBEDTLS_CIPHER_ID_AES, tmp, keysize );
TIME_AND_TSC( title,
mbedtls_gcm_crypt_and_tag( &gcm, MBEDTLS_GCM_ENCRYPT, BUFSIZE, tmp,
12, NULL, 0, buf, buf, 16, tmp ) );
mbedtls_gcm_free( &gcm );
}
}
#endif
#if defined(MBEDTLS_CCM_C)
2014-05-07 12:03:02 +02:00
if( todo.aes_ccm )
{
int keysize;
mbedtls_ccm_context ccm;
2015-04-28 18:02:54 +02:00
mbedtls_ccm_init( &ccm );
2014-05-07 12:03:02 +02:00
for( keysize = 128; keysize <= 256; keysize += 64 )
{
mbedtls_snprintf( title, sizeof( title ), "AES-CCM-%d", keysize );
2014-05-07 12:03:02 +02:00
memset( buf, 0, sizeof( buf ) );
memset( tmp, 0, sizeof( tmp ) );
2015-04-28 18:02:54 +02:00
mbedtls_ccm_setkey( &ccm, MBEDTLS_CIPHER_ID_AES, tmp, keysize );
2014-05-07 12:03:02 +02:00
TIME_AND_TSC( title,
mbedtls_ccm_encrypt_and_tag( &ccm, BUFSIZE, tmp,
2014-05-07 12:03:02 +02:00
12, NULL, 0, buf, buf, tmp, 16 ) );
mbedtls_ccm_free( &ccm );
2014-05-07 12:03:02 +02:00
}
}
#endif
2018-05-09 10:21:28 +02:00
#if defined(MBEDTLS_CHACHAPOLY_C)
if( todo.chachapoly )
{
mbedtls_chachapoly_context chachapoly;
mbedtls_chachapoly_init( &chachapoly );
memset( buf, 0, sizeof( buf ) );
memset( tmp, 0, sizeof( tmp ) );
mbedtls_snprintf( title, sizeof( title ), "ChaCha20-Poly1305" );
mbedtls_chachapoly_setkey( &chachapoly, tmp );
TIME_AND_TSC( title,
mbedtls_chachapoly_encrypt_and_tag( &chachapoly,
BUFSIZE, tmp, NULL, 0, buf, buf, tmp ) );
2018-05-09 10:21:28 +02:00
mbedtls_chachapoly_free( &chachapoly );
}
#endif
#if defined(MBEDTLS_CMAC_C)
if( todo.aes_cmac )
{
unsigned char output[16];
const mbedtls_cipher_info_t *cipher_info;
mbedtls_cipher_type_t cipher_type;
int keysize;
for( keysize = 128, cipher_type = MBEDTLS_CIPHER_AES_128_ECB;
keysize <= 256;
keysize += 64, cipher_type++ )
{
mbedtls_snprintf( title, sizeof( title ), "AES-CMAC-%d", keysize );
memset( buf, 0, sizeof( buf ) );
memset( tmp, 0, sizeof( tmp ) );
cipher_info = mbedtls_cipher_info_from_type( cipher_type );
TIME_AND_TSC( title,
mbedtls_cipher_cmac( cipher_info, tmp, keysize,
buf, BUFSIZE, output ) );
}
memset( buf, 0, sizeof( buf ) );
memset( tmp, 0, sizeof( tmp ) );
TIME_AND_TSC( "AES-CMAC-PRF-128",
mbedtls_aes_cmac_prf_128( tmp, 16, buf, BUFSIZE,
output ) );
}
#endif /* MBEDTLS_CMAC_C */
#endif /* MBEDTLS_AES_C */
#if defined(MBEDTLS_CAMELLIA_C) && defined(MBEDTLS_CIPHER_MODE_CBC)
2013-09-17 15:30:51 +02:00
if( todo.camellia )
2009-01-11 00:31:23 +01:00
{
int keysize;
mbedtls_camellia_context camellia;
mbedtls_camellia_init( &camellia );
for( keysize = 128; keysize <= 256; keysize += 64 )
{
mbedtls_snprintf( title, sizeof( title ), "CAMELLIA-CBC-%d", keysize );
memset( buf, 0, sizeof( buf ) );
memset( tmp, 0, sizeof( tmp ) );
mbedtls_camellia_setkey_enc( &camellia, tmp, keysize );
TIME_AND_TSC( title,
mbedtls_camellia_crypt_cbc( &camellia, MBEDTLS_CAMELLIA_ENCRYPT,
BUFSIZE, tmp, buf, buf ) );
}
mbedtls_camellia_free( &camellia );
2009-01-11 00:31:23 +01:00
}
#endif
2016-05-15 22:28:08 +02:00
#if defined(MBEDTLS_CHACHA20_C)
if ( todo.chacha20 )
{
TIME_AND_TSC( "ChaCha20", mbedtls_chacha20_crypt( buf, buf, 0U, BUFSIZE, buf, buf ) );
}
#endif
#if defined(MBEDTLS_POLY1305_C)
if ( todo.poly1305 )
{
TIME_AND_TSC( "Poly1305", mbedtls_poly1305_mac( buf, buf, BUFSIZE, buf ) );
}
#endif
#if defined(MBEDTLS_BLOWFISH_C) && defined(MBEDTLS_CIPHER_MODE_CBC)
2013-09-17 15:30:51 +02:00
if( todo.blowfish )
2012-07-04 19:15:31 +02:00
{
int keysize;
mbedtls_blowfish_context blowfish;
mbedtls_blowfish_init( &blowfish );
for( keysize = 128; keysize <= 256; keysize += 64 )
{
mbedtls_snprintf( title, sizeof( title ), "BLOWFISH-CBC-%d", keysize );
memset( buf, 0, sizeof( buf ) );
memset( tmp, 0, sizeof( tmp ) );
mbedtls_blowfish_setkey( &blowfish, tmp, keysize );
TIME_AND_TSC( title,
mbedtls_blowfish_crypt_cbc( &blowfish, MBEDTLS_BLOWFISH_ENCRYPT, BUFSIZE,
tmp, buf, buf ) );
}
mbedtls_blowfish_free( &blowfish );
2012-07-04 19:15:31 +02:00
}
#endif
#if defined(MBEDTLS_HAVEGE_C)
2013-09-17 15:30:51 +02:00
if( todo.havege )
{
mbedtls_havege_state hs;
mbedtls_havege_init( &hs );
TIME_AND_TSC( "HAVEGE", mbedtls_havege_random( &hs, buf, BUFSIZE ) );
mbedtls_havege_free( &hs );
}
2011-11-29 12:23:58 +01:00
#endif
#if defined(MBEDTLS_CTR_DRBG_C)
2013-09-17 15:30:51 +02:00
if( todo.ctr_drbg )
{
mbedtls_ctr_drbg_context ctr_drbg;
2011-11-29 12:23:58 +01:00
mbedtls_ctr_drbg_init( &ctr_drbg );
if( mbedtls_ctr_drbg_seed( &ctr_drbg, myrand, NULL, NULL, 0 ) != 0 )
mbedtls_exit(1);
TIME_AND_TSC( "CTR_DRBG (NOPR)",
if( mbedtls_ctr_drbg_random( &ctr_drbg, buf, BUFSIZE ) != 0 )
mbedtls_exit(1) );
2011-11-29 12:23:58 +01:00
if( mbedtls_ctr_drbg_seed( &ctr_drbg, myrand, NULL, NULL, 0 ) != 0 )
mbedtls_exit(1);
mbedtls_ctr_drbg_set_prediction_resistance( &ctr_drbg, MBEDTLS_CTR_DRBG_PR_ON );
TIME_AND_TSC( "CTR_DRBG (PR)",
if( mbedtls_ctr_drbg_random( &ctr_drbg, buf, BUFSIZE ) != 0 )
mbedtls_exit(1) );
mbedtls_ctr_drbg_free( &ctr_drbg );
}
#endif
#if defined(MBEDTLS_HMAC_DRBG_C)
2014-01-30 20:59:00 +01:00
if( todo.hmac_drbg )
{
mbedtls_hmac_drbg_context hmac_drbg;
const mbedtls_md_info_t *md_info;
2014-01-30 20:59:00 +01:00
mbedtls_hmac_drbg_init( &hmac_drbg );
#if defined(MBEDTLS_SHA1_C)
if( ( md_info = mbedtls_md_info_from_type( MBEDTLS_MD_SHA1 ) ) == NULL )
mbedtls_exit(1);
2014-01-30 20:59:00 +01:00
if( mbedtls_hmac_drbg_seed( &hmac_drbg, md_info, myrand, NULL, NULL, 0 ) != 0 )
mbedtls_exit(1);
2014-01-30 20:59:00 +01:00
TIME_AND_TSC( "HMAC_DRBG SHA-1 (NOPR)",
if( mbedtls_hmac_drbg_random( &hmac_drbg, buf, BUFSIZE ) != 0 )
mbedtls_exit(1) );
mbedtls_hmac_drbg_free( &hmac_drbg );
if( mbedtls_hmac_drbg_seed( &hmac_drbg, md_info, myrand, NULL, NULL, 0 ) != 0 )
mbedtls_exit(1);
mbedtls_hmac_drbg_set_prediction_resistance( &hmac_drbg,
MBEDTLS_HMAC_DRBG_PR_ON );
2014-01-30 20:59:00 +01:00
TIME_AND_TSC( "HMAC_DRBG SHA-1 (PR)",
if( mbedtls_hmac_drbg_random( &hmac_drbg, buf, BUFSIZE ) != 0 )
mbedtls_exit(1) );
mbedtls_hmac_drbg_free( &hmac_drbg );
2014-01-30 20:59:00 +01:00
#endif
#if defined(MBEDTLS_SHA256_C)
if( ( md_info = mbedtls_md_info_from_type( MBEDTLS_MD_SHA256 ) ) == NULL )
mbedtls_exit(1);
2014-01-30 20:59:00 +01:00
if( mbedtls_hmac_drbg_seed( &hmac_drbg, md_info, myrand, NULL, NULL, 0 ) != 0 )
mbedtls_exit(1);
2014-01-30 20:59:00 +01:00
TIME_AND_TSC( "HMAC_DRBG SHA-256 (NOPR)",
if( mbedtls_hmac_drbg_random( &hmac_drbg, buf, BUFSIZE ) != 0 )
mbedtls_exit(1) );
mbedtls_hmac_drbg_free( &hmac_drbg );
if( mbedtls_hmac_drbg_seed( &hmac_drbg, md_info, myrand, NULL, NULL, 0 ) != 0 )
mbedtls_exit(1);
mbedtls_hmac_drbg_set_prediction_resistance( &hmac_drbg,
MBEDTLS_HMAC_DRBG_PR_ON );
2014-01-30 20:59:00 +01:00
TIME_AND_TSC( "HMAC_DRBG SHA-256 (PR)",
if( mbedtls_hmac_drbg_random( &hmac_drbg, buf, BUFSIZE ) != 0 )
mbedtls_exit(1) );
mbedtls_hmac_drbg_free( &hmac_drbg );
2014-01-30 20:59:00 +01:00
#endif
}
#endif
#if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_GENPRIME)
2013-09-17 15:30:51 +02:00
if( todo.rsa )
{
int keysize;
mbedtls_rsa_context rsa;
for( keysize = 2048; keysize <= 4096; keysize *= 2 )
{
mbedtls_snprintf( title, sizeof( title ), "RSA-%d", keysize );
mbedtls_rsa_init( &rsa, MBEDTLS_RSA_PKCS_V15, 0 );
mbedtls_rsa_gen_key( &rsa, myrand, NULL, keysize, 65537 );
TIME_PUBLIC( title, " public",
buf[0] = 0;
ret = mbedtls_rsa_public( &rsa, buf, buf ) );
TIME_PUBLIC( title, "private",
buf[0] = 0;
ret = mbedtls_rsa_private( &rsa, myrand, NULL, buf, buf ) );
mbedtls_rsa_free( &rsa );
}
}
#endif
#if defined(MBEDTLS_DHM_C) && defined(MBEDTLS_BIGNUM_C)
2013-09-17 15:30:51 +02:00
if( todo.dhm )
{
2015-07-19 15:01:28 +02:00
int dhm_sizes[] = { 2048, 3072 };
static const unsigned char dhm_P_2048[] =
MBEDTLS_DHM_RFC3526_MODP_2048_P_BIN;
static const unsigned char dhm_P_3072[] =
MBEDTLS_DHM_RFC3526_MODP_3072_P_BIN;
static const unsigned char dhm_G_2048[] =
MBEDTLS_DHM_RFC3526_MODP_2048_G_BIN;
static const unsigned char dhm_G_3072[] =
MBEDTLS_DHM_RFC3526_MODP_3072_G_BIN;
const unsigned char *dhm_P[] = { dhm_P_2048, dhm_P_3072 };
const size_t dhm_P_size[] = { sizeof( dhm_P_2048 ),
sizeof( dhm_P_3072 ) };
const unsigned char *dhm_G[] = { dhm_G_2048, dhm_G_3072 };
const size_t dhm_G_size[] = { sizeof( dhm_G_2048 ),
sizeof( dhm_G_3072 ) };
mbedtls_dhm_context dhm;
size_t olen;
2015-07-19 15:01:28 +02:00
for( i = 0; (size_t) i < sizeof( dhm_sizes ) / sizeof( dhm_sizes[0] ); i++ )
{
mbedtls_dhm_init( &dhm );
if( mbedtls_mpi_read_binary( &dhm.P, dhm_P[i],
dhm_P_size[i] ) != 0 ||
mbedtls_mpi_read_binary( &dhm.G, dhm_G[i],
dhm_G_size[i] ) != 0 )
{
mbedtls_exit( 1 );
}
dhm.len = mbedtls_mpi_size( &dhm.P );
mbedtls_dhm_make_public( &dhm, (int) dhm.len, buf, dhm.len, myrand, NULL );
if( mbedtls_mpi_copy( &dhm.GY, &dhm.GX ) != 0 )
mbedtls_exit( 1 );
mbedtls_snprintf( title, sizeof( title ), "DHE-%d", dhm_sizes[i] );
TIME_PUBLIC( title, "handshake",
ret |= mbedtls_dhm_make_public( &dhm, (int) dhm.len, buf, dhm.len,
myrand, NULL );
ret |= mbedtls_dhm_calc_secret( &dhm, buf, sizeof( buf ), &olen, myrand, NULL ) );
mbedtls_snprintf( title, sizeof( title ), "DH-%d", dhm_sizes[i] );
TIME_PUBLIC( title, "handshake",
ret |= mbedtls_dhm_calc_secret( &dhm, buf, sizeof( buf ), &olen, myrand, NULL ) );
mbedtls_dhm_free( &dhm );
}
2012-11-08 11:31:48 +01:00
}
#endif
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_SHA256_C)
2013-09-17 16:04:08 +02:00
if( todo.ecdsa )
{
mbedtls_ecdsa_context ecdsa;
const mbedtls_ecp_curve_info *curve_info;
2013-09-17 16:04:08 +02:00
size_t sig_len;
memset( buf, 0x2A, sizeof( buf ) );
for( curve_info = mbedtls_ecp_curve_list();
curve_info->grp_id != MBEDTLS_ECP_DP_NONE;
2013-09-17 16:04:08 +02:00
curve_info++ )
{
mbedtls_ecdsa_init( &ecdsa );
2013-09-17 16:04:08 +02:00
if( mbedtls_ecdsa_genkey( &ecdsa, curve_info->grp_id, myrand, NULL ) != 0 )
mbedtls_exit( 1 );
2014-12-19 12:10:37 +01:00
ecp_clear_precomputed( &ecdsa.grp );
2013-09-17 16:04:08 +02:00
mbedtls_snprintf( title, sizeof( title ), "ECDSA-%s",
curve_info->name );
2013-09-17 16:04:08 +02:00
TIME_PUBLIC( title, "sign",
2015-06-18 15:45:05 +02:00
ret = mbedtls_ecdsa_write_signature( &ecdsa, MBEDTLS_MD_SHA256, buf, curve_info->bit_size,
tmp, &sig_len, myrand, NULL ) );
mbedtls_ecdsa_free( &ecdsa );
2014-12-19 12:10:37 +01:00
}
for( curve_info = mbedtls_ecp_curve_list();
curve_info->grp_id != MBEDTLS_ECP_DP_NONE;
2014-12-19 12:10:37 +01:00
curve_info++ )
{
mbedtls_ecdsa_init( &ecdsa );
2014-12-19 12:10:37 +01:00
if( mbedtls_ecdsa_genkey( &ecdsa, curve_info->grp_id, myrand, NULL ) != 0 ||
2015-06-18 15:45:05 +02:00
mbedtls_ecdsa_write_signature( &ecdsa, MBEDTLS_MD_SHA256, buf, curve_info->bit_size,
2014-12-19 12:10:37 +01:00
tmp, &sig_len, myrand, NULL ) != 0 )
{
mbedtls_exit( 1 );
2014-12-19 12:10:37 +01:00
}
ecp_clear_precomputed( &ecdsa.grp );
mbedtls_snprintf( title, sizeof( title ), "ECDSA-%s",
2014-12-19 12:10:37 +01:00
curve_info->name );
TIME_PUBLIC( title, "verify",
2015-06-18 15:45:05 +02:00
ret = mbedtls_ecdsa_read_signature( &ecdsa, buf, curve_info->bit_size,
tmp, sig_len ) );
2013-09-17 16:04:08 +02:00
mbedtls_ecdsa_free( &ecdsa );
2013-09-17 16:04:08 +02:00
}
}
#endif
#if defined(MBEDTLS_ECDH_C)
2013-09-17 16:04:08 +02:00
if( todo.ecdh )
{
mbedtls_ecdh_context ecdh;
mbedtls_mpi z;
const mbedtls_ecp_curve_info montgomery_curve_list[] = {
#if defined(MBEDTLS_ECP_DP_CURVE25519_ENABLED)
{ MBEDTLS_ECP_DP_CURVE25519, 0, 0, "Curve25519" },
#endif
#if defined(MBEDTLS_ECP_DP_CURVE448_ENABLED)
{ MBEDTLS_ECP_DP_CURVE448, 0, 0, "Curve448" },
#endif
{ MBEDTLS_ECP_DP_NONE, 0, 0, 0 }
};
const mbedtls_ecp_curve_info *curve_info;
2013-09-17 16:04:08 +02:00
size_t olen;
for( curve_info = mbedtls_ecp_curve_list();
curve_info->grp_id != MBEDTLS_ECP_DP_NONE;
2013-09-17 16:04:08 +02:00
curve_info++ )
{
mbedtls_ecdh_init( &ecdh );
2013-09-17 16:04:08 +02:00
if( mbedtls_ecp_group_load( &ecdh.grp, curve_info->grp_id ) != 0 ||
mbedtls_ecdh_make_public( &ecdh, &olen, buf, sizeof( buf),
2013-09-17 16:04:08 +02:00
myrand, NULL ) != 0 ||
mbedtls_ecp_copy( &ecdh.Qp, &ecdh.Q ) != 0 )
2013-09-17 16:04:08 +02:00
{
mbedtls_exit( 1 );
2013-09-17 16:04:08 +02:00
}
2014-12-19 12:10:37 +01:00
ecp_clear_precomputed( &ecdh.grp );
2013-09-17 16:04:08 +02:00
mbedtls_snprintf( title, sizeof( title ), "ECDHE-%s",
curve_info->name );
2013-09-17 16:04:08 +02:00
TIME_PUBLIC( title, "handshake",
ret |= mbedtls_ecdh_make_public( &ecdh, &olen, buf, sizeof( buf),
2013-09-17 16:04:08 +02:00
myrand, NULL );
ret |= mbedtls_ecdh_calc_secret( &ecdh, &olen, buf, sizeof( buf ),
2013-09-17 16:04:08 +02:00
myrand, NULL ) );
mbedtls_ecdh_free( &ecdh );
2014-12-19 12:10:37 +01:00
}
/* Montgomery curves need to be handled separately */
for ( curve_info = montgomery_curve_list;
curve_info->grp_id != MBEDTLS_ECP_DP_NONE;
curve_info++ )
{
mbedtls_ecdh_init( &ecdh );
mbedtls_mpi_init( &z );
if( mbedtls_ecp_group_load( &ecdh.grp, curve_info->grp_id ) != 0 ||
mbedtls_ecdh_gen_public( &ecdh.grp, &ecdh.d, &ecdh.Qp, myrand, NULL ) != 0 )
{
mbedtls_exit( 1 );
}
mbedtls_snprintf( title, sizeof(title), "ECDHE-%s",
curve_info->name );
TIME_PUBLIC( title, "handshake",
ret |= mbedtls_ecdh_gen_public( &ecdh.grp, &ecdh.d, &ecdh.Q,
myrand, NULL );
ret |= mbedtls_ecdh_compute_shared( &ecdh.grp, &z, &ecdh.Qp, &ecdh.d,
myrand, NULL ) );
mbedtls_ecdh_free( &ecdh );
mbedtls_mpi_free( &z );
}
for( curve_info = mbedtls_ecp_curve_list();
curve_info->grp_id != MBEDTLS_ECP_DP_NONE;
2014-12-19 12:10:37 +01:00
curve_info++ )
{
mbedtls_ecdh_init( &ecdh );
2014-12-19 12:10:37 +01:00
if( mbedtls_ecp_group_load( &ecdh.grp, curve_info->grp_id ) != 0 ||
mbedtls_ecdh_make_public( &ecdh, &olen, buf, sizeof( buf),
2014-12-19 12:10:37 +01:00
myrand, NULL ) != 0 ||
mbedtls_ecp_copy( &ecdh.Qp, &ecdh.Q ) != 0 ||
mbedtls_ecdh_make_public( &ecdh, &olen, buf, sizeof( buf),
2014-12-19 12:10:37 +01:00
myrand, NULL ) != 0 )
{
mbedtls_exit( 1 );
2014-12-19 12:10:37 +01:00
}
ecp_clear_precomputed( &ecdh.grp );
2013-09-17 16:04:08 +02:00
mbedtls_snprintf( title, sizeof( title ), "ECDH-%s",
curve_info->name );
2013-09-17 16:04:08 +02:00
TIME_PUBLIC( title, "handshake",
ret |= mbedtls_ecdh_calc_secret( &ecdh, &olen, buf, sizeof( buf ),
2013-09-17 16:04:08 +02:00
myrand, NULL ) );
mbedtls_ecdh_free( &ecdh );
2013-09-17 16:04:08 +02:00
}
/* Montgomery curves need to be handled separately */
for ( curve_info = montgomery_curve_list;
curve_info->grp_id != MBEDTLS_ECP_DP_NONE;
curve_info++)
{
mbedtls_ecdh_init( &ecdh );
mbedtls_mpi_init( &z );
if( mbedtls_ecp_group_load( &ecdh.grp, curve_info->grp_id ) != 0 ||
mbedtls_ecdh_gen_public( &ecdh.grp, &ecdh.d, &ecdh.Qp,
myrand, NULL ) != 0 ||
mbedtls_ecdh_gen_public( &ecdh.grp, &ecdh.d, &ecdh.Q, myrand, NULL ) != 0 )
{
mbedtls_exit( 1 );
}
mbedtls_snprintf( title, sizeof(title), "ECDH-%s",
curve_info->name );
TIME_PUBLIC( title, "handshake",
ret |= mbedtls_ecdh_compute_shared( &ecdh.grp, &z, &ecdh.Qp, &ecdh.d,
myrand, NULL ) );
mbedtls_ecdh_free( &ecdh );
mbedtls_mpi_free( &z );
}
2013-09-17 16:04:08 +02:00
}
#endif
2014-12-19 12:10:37 +01:00
mbedtls_printf( "\n" );
#if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C)
mbedtls_memory_buffer_alloc_free();
#endif
#if defined(_WIN32)
mbedtls_printf( " Press Enter to exit this program.\n" );
fflush( stdout ); getchar();
#endif
return( 0 );
}
#endif /* MBEDTLS_TIMING_C */