diff --git a/benchmark/CMakeLists.txt b/benchmark/CMakeLists.txt index fab63e2c7..e2b712569 100644 --- a/benchmark/CMakeLists.txt +++ b/benchmark/CMakeLists.txt @@ -22,7 +22,7 @@ target_include_directories(${APP_TARGET} target_sources(${APP_TARGET} PRIVATE - main.cpp + benchmark.c ) target_link_libraries(${APP_TARGET} diff --git a/benchmark/benchmark.c b/benchmark/benchmark.c new file mode 100644 index 000000000..9c5911ba2 --- /dev/null +++ b/benchmark/benchmark.c @@ -0,0 +1,1113 @@ +/* + * Benchmark demonstration program + * + * Copyright The Mbed TLS Contributors + * SPDX-License-Identifier: Apache-2.0 + * + * 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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * 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. + */ + +#if !defined(MBEDTLS_CONFIG_FILE) +#include "mbedtls/config.h" +#else +#include MBEDTLS_CONFIG_FILE +#endif + +#include "mbedtls/platform.h" +#if !defined(MBEDTLS_PLATFORM_C) +#include +#include +#define mbedtls_exit exit +#define mbedtls_printf printf +#define mbedtls_free free +#endif + +#if !defined(MBEDTLS_TIMING_C) +int main( void ) +{ + mbedtls_printf("MBEDTLS_TIMING_C not defined.\n"); + mbedtls_exit( 0 ); +} +#else + +#include +#include + +#include "mbedtls/timing.h" + +#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/aria.h" +#include "mbedtls/blowfish.h" +#include "mbedtls/camellia.h" +#include "mbedtls/chacha20.h" +#include "mbedtls/gcm.h" +#include "mbedtls/ccm.h" +#include "mbedtls/chachapoly.h" +#include "mbedtls/cmac.h" +#include "mbedtls/poly1305.h" + +#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) +#include "mbedtls/memory_buffer_alloc.h" +#endif + +/* + * 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. + */ +#define HEAP_SIZE (1u << 16) /* 64k */ + +#define BUFSIZE 1024 +#define HEADER_FORMAT " %-24s : " +#define TITLE_LEN 25 + +#define OPTIONS \ + "md4, md5, ripemd160, sha1, sha256, sha512,\n" \ + "arc4, des3, des, camellia, blowfish, chacha20,\n" \ + "aes_cbc, aes_gcm, aes_ccm, aes_xts, 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", (unsigned int) -ret ); +#endif + +#define TIME_AND_TSC( TITLE, CODE ) \ +do { \ + unsigned long ii, jj, tsc; \ + int ret = 0; \ + \ + mbedtls_printf( HEADER_FORMAT, TITLE ); \ + fflush( stdout ); \ + \ + mbedtls_set_alarm( 1 ); \ + for( ii = 1; ret == 0 && ! mbedtls_timing_alarmed; ii++ ) \ + { \ + ret = CODE; \ + } \ + \ + tsc = mbedtls_timing_hardclock(); \ + for( jj = 0; ret == 0 && jj < 1024; jj++ ) \ + { \ + ret = CODE; \ + } \ + \ + if( ret != 0 ) \ + { \ + PRINT_ERROR; \ + } \ + else \ + { \ + 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) + +/* How much space to reserve for the title when printing heap usage results. + * Updated manually as the output of the following command: + * + * sed -n 's/.*[T]IME_PUBLIC.*"\(.*\)",/\1/p' programs/test/benchmark.c | + * awk '{print length+2}' | sort -rn | head -n1 + * + * This computes the maximum length of a title +2 (because we appends "/s"). + * (If the value is too small, the only consequence is poor alignement.) */ +#define TITLE_SPACE 16 + +#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( ); + +#define MEMORY_MEASURE_PRINT( title_len ) \ + mbedtls_memory_buffer_alloc_max_get( &max_used, &max_blocks ); \ + ii = TITLE_SPACE > (title_len) ? TITLE_SPACE - (title_len) : 1; \ + while( ii-- ) mbedtls_printf( " " ); \ + 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 ); + +#else +#define MEMORY_MEASURE_INIT +#define MEMORY_MEASURE_PRINT( title_len ) +#endif + +#define TIME_PUBLIC( TITLE, TYPE, CODE ) \ +do { \ + unsigned long ii; \ + int ret; \ + 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 == MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED ) \ + { \ + mbedtls_printf( "Feature Not Supported. Skipping.\n" ); \ + ret = 0; \ + } \ + else if( ret != 0 ) \ + { \ + PRINT_ERROR; \ + } \ + else \ + { \ + mbedtls_printf( "%6lu " TYPE "/s", ii / 3 ); \ + MEMORY_MEASURE_PRINT( sizeof( TYPE ) + 1 ); \ + mbedtls_printf( "\n" ); \ + } \ +} 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 ); +} + +#define CHECK_AND_CONTINUE( R ) \ + { \ + int CHECK_AND_CONTINUE_ret = ( R ); \ + if( CHECK_AND_CONTINUE_ret == MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED ) { \ + mbedtls_printf( "Feature not supported. Skipping.\n" ); \ + continue; \ + } \ + else if( CHECK_AND_CONTINUE_ret != 0 ) { \ + mbedtls_exit( 1 ); \ + } \ + } + +/* + * Clear some memory that was used to prepare the context + */ +#if defined(MBEDTLS_ECP_C) +void ecp_clear_precomputed( mbedtls_ecp_group *grp ) +{ + 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 ); + } + grp->T = NULL; + grp->T_size = 0; +} +#else +#define ecp_clear_precomputed( g ) +#endif + +#if defined(MBEDTLS_ECP_C) +static int set_ecp_curve( const char *string, mbedtls_ecp_curve_info *curve ) +{ + const mbedtls_ecp_curve_info *found = + mbedtls_ecp_curve_info_from_name( string ); + if( found != NULL ) + { + *curve = *found; + return( 1 ); + } + else + return( 0 ); +} +#endif + +unsigned char buf[BUFSIZE]; + +typedef struct { + char md4, md5, ripemd160, sha1, sha256, sha512, + arc4, des3, des, + aes_cbc, aes_gcm, aes_ccm, aes_xts, chachapoly, + aes_cmac, des3_cmac, + aria, camellia, blowfish, chacha20, + poly1305, + havege, ctr_drbg, hmac_drbg, + rsa, dhm, ecdsa, ecdh; +} todo_list; + + +int main( int argc, char *argv[] ) +{ + int i; + unsigned char tmp[200]; + char title[TITLE_LEN]; + todo_list todo; +#if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C) + unsigned char alloc_buf[HEAP_SIZE] = { 0 }; +#endif +#if defined(MBEDTLS_ECP_C) + mbedtls_ecp_curve_info single_curve[2] = { + { MBEDTLS_ECP_DP_NONE, 0, 0, NULL }, + { MBEDTLS_ECP_DP_NONE, 0, 0, NULL }, + }; + const mbedtls_ecp_curve_info *curve_list = mbedtls_ecp_curve_list( ); +#endif + +#if defined(MBEDTLS_ECP_C) + (void) curve_list; /* Unused in some configurations where no benchmark uses ECC */ +#endif + + if( argc <= 1 ) + { + memset( &todo, 1, sizeof( todo ) ); + } + else + { + memset( &todo, 0, sizeof( todo ) ); + + for( i = 1; i < argc; i++ ) + { + 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; + 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_xts" ) == 0 ) + todo.aes_xts = 1; + else if( strcmp( argv[i], "aes_gcm" ) == 0 ) + todo.aes_gcm = 1; + else if( strcmp( argv[i], "aes_ccm" ) == 0 ) + todo.aes_ccm = 1; + 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; + else if( strcmp( argv[i], "aria" ) == 0 ) + todo.aria = 1; + else if( strcmp( argv[i], "camellia" ) == 0 ) + todo.camellia = 1; + else if( strcmp( argv[i], "blowfish" ) == 0 ) + todo.blowfish = 1; + else if( strcmp( argv[i], "chacha20" ) == 0 ) + todo.chacha20 = 1; + else if( strcmp( argv[i], "poly1305" ) == 0 ) + todo.poly1305 = 1; + else if( strcmp( argv[i], "havege" ) == 0 ) + todo.havege = 1; + else if( strcmp( argv[i], "ctr_drbg" ) == 0 ) + todo.ctr_drbg = 1; + else if( strcmp( argv[i], "hmac_drbg" ) == 0 ) + todo.hmac_drbg = 1; + else if( strcmp( argv[i], "rsa" ) == 0 ) + todo.rsa = 1; + else if( strcmp( argv[i], "dhm" ) == 0 ) + todo.dhm = 1; + else if( strcmp( argv[i], "ecdsa" ) == 0 ) + todo.ecdsa = 1; + else if( strcmp( argv[i], "ecdh" ) == 0 ) + todo.ecdh = 1; +#if defined(MBEDTLS_ECP_C) + else if( set_ecp_curve( argv[i], single_curve ) ) + curve_list = single_curve; +#endif + else + { + mbedtls_printf( "Unrecognized option: %s\n", argv[i] ); + mbedtls_printf( "Available options: " OPTIONS ); + } + } + } + + mbedtls_printf( "\n" ); + +#if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C) + mbedtls_memory_buffer_alloc_init( alloc_buf, sizeof( alloc_buf ) ); +#endif + memset( buf, 0xAA, sizeof( buf ) ); + memset( tmp, 0xBB, sizeof( tmp ) ); + +#if defined(MBEDTLS_MD4_C) + if( todo.md4 ) + TIME_AND_TSC( "MD4", mbedtls_md4_ret( buf, BUFSIZE, tmp ) ); +#endif + +#if defined(MBEDTLS_MD5_C) + if( todo.md5 ) + TIME_AND_TSC( "MD5", mbedtls_md5_ret( buf, BUFSIZE, tmp ) ); +#endif + +#if defined(MBEDTLS_RIPEMD160_C) + if( todo.ripemd160 ) + TIME_AND_TSC( "RIPEMD160", mbedtls_ripemd160_ret( buf, BUFSIZE, tmp ) ); +#endif + +#if defined(MBEDTLS_SHA1_C) + if( todo.sha1 ) + TIME_AND_TSC( "SHA-1", mbedtls_sha1_ret( buf, BUFSIZE, tmp ) ); +#endif + +#if defined(MBEDTLS_SHA256_C) + if( todo.sha256 ) + TIME_AND_TSC( "SHA-256", mbedtls_sha256_ret( buf, BUFSIZE, tmp, 0 ) ); +#endif + +#if defined(MBEDTLS_SHA512_C) + if( todo.sha512 ) + TIME_AND_TSC( "SHA-512", mbedtls_sha512_ret( buf, BUFSIZE, tmp, 0 ) ); +#endif + +#if defined(MBEDTLS_ARC4_C) + 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) + 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 ); + } + + 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) + 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_CIPHER_MODE_XTS) + if( todo.aes_xts ) + { + int keysize; + mbedtls_aes_xts_context ctx; + + mbedtls_aes_xts_init( &ctx ); + for( keysize = 128; keysize <= 256; keysize += 128 ) + { + mbedtls_snprintf( title, sizeof( title ), "AES-XTS-%d", keysize ); + + memset( buf, 0, sizeof( buf ) ); + memset( tmp, 0, sizeof( tmp ) ); + mbedtls_aes_xts_setkey_enc( &ctx, tmp, keysize * 2 ); + + TIME_AND_TSC( title, + mbedtls_aes_crypt_xts( &ctx, MBEDTLS_AES_ENCRYPT, BUFSIZE, + tmp, buf, buf ) ); + + mbedtls_aes_xts_free( &ctx ); + } + } +#endif +#if defined(MBEDTLS_GCM_C) + 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) + if( todo.aes_ccm ) + { + int keysize; + mbedtls_ccm_context ccm; + + mbedtls_ccm_init( &ccm ); + for( keysize = 128; keysize <= 256; keysize += 64 ) + { + mbedtls_snprintf( title, sizeof( title ), "AES-CCM-%d", keysize ); + + memset( buf, 0, sizeof( buf ) ); + memset( tmp, 0, sizeof( tmp ) ); + mbedtls_ccm_setkey( &ccm, MBEDTLS_CIPHER_ID_AES, tmp, keysize ); + + TIME_AND_TSC( title, + mbedtls_ccm_encrypt_and_tag( &ccm, BUFSIZE, tmp, + 12, NULL, 0, buf, buf, tmp, 16 ) ); + + mbedtls_ccm_free( &ccm ); + } + } +#endif +#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 ) ); + + 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_ARIA_C) && defined(MBEDTLS_CIPHER_MODE_CBC) + if( todo.aria ) + { + int keysize; + mbedtls_aria_context aria; + mbedtls_aria_init( &aria ); + for( keysize = 128; keysize <= 256; keysize += 64 ) + { + mbedtls_snprintf( title, sizeof( title ), "ARIA-CBC-%d", keysize ); + + memset( buf, 0, sizeof( buf ) ); + memset( tmp, 0, sizeof( tmp ) ); + mbedtls_aria_setkey_enc( &aria, tmp, keysize ); + + TIME_AND_TSC( title, + mbedtls_aria_crypt_cbc( &aria, MBEDTLS_ARIA_ENCRYPT, + BUFSIZE, tmp, buf, buf ) ); + } + mbedtls_aria_free( &aria ); + } +#endif + +#if defined(MBEDTLS_CAMELLIA_C) && defined(MBEDTLS_CIPHER_MODE_CBC) + if( todo.camellia ) + { + 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 ); + } +#endif + +#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) + if( todo.blowfish ) + { + 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 ); + } +#endif + +#if defined(MBEDTLS_HAVEGE_C) + 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 ); + } +#endif + +#if defined(MBEDTLS_CTR_DRBG_C) + if( todo.ctr_drbg ) + { + mbedtls_ctr_drbg_context ctr_drbg; + + 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)", + mbedtls_ctr_drbg_random( &ctr_drbg, buf, BUFSIZE ) ); + mbedtls_ctr_drbg_free( &ctr_drbg ); + + mbedtls_ctr_drbg_init( &ctr_drbg ); + 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)", + mbedtls_ctr_drbg_random( &ctr_drbg, buf, BUFSIZE ) ); + mbedtls_ctr_drbg_free( &ctr_drbg ); + } +#endif + +#if defined(MBEDTLS_HMAC_DRBG_C) + if( todo.hmac_drbg ) + { + mbedtls_hmac_drbg_context hmac_drbg; + const mbedtls_md_info_t *md_info; + + 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); + + if( mbedtls_hmac_drbg_seed( &hmac_drbg, md_info, myrand, NULL, NULL, 0 ) != 0 ) + mbedtls_exit(1); + TIME_AND_TSC( "HMAC_DRBG SHA-1 (NOPR)", + mbedtls_hmac_drbg_random( &hmac_drbg, buf, BUFSIZE ) ); + + 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 ); + TIME_AND_TSC( "HMAC_DRBG SHA-1 (PR)", + mbedtls_hmac_drbg_random( &hmac_drbg, buf, BUFSIZE ) ); +#endif + +#if defined(MBEDTLS_SHA256_C) + if( ( md_info = mbedtls_md_info_from_type( MBEDTLS_MD_SHA256 ) ) == NULL ) + mbedtls_exit(1); + + if( mbedtls_hmac_drbg_seed( &hmac_drbg, md_info, myrand, NULL, NULL, 0 ) != 0 ) + mbedtls_exit(1); + TIME_AND_TSC( "HMAC_DRBG SHA-256 (NOPR)", + mbedtls_hmac_drbg_random( &hmac_drbg, buf, BUFSIZE ) ); + + 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 ); + TIME_AND_TSC( "HMAC_DRBG SHA-256 (PR)", + mbedtls_hmac_drbg_random( &hmac_drbg, buf, BUFSIZE ) ); +#endif + mbedtls_hmac_drbg_free( &hmac_drbg ); + } +#endif + +#if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_GENPRIME) + 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) + if( todo.dhm ) + { + 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; + 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 ); + } + } +#endif + +#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_SHA256_C) + if( todo.ecdsa ) + { + mbedtls_ecdsa_context ecdsa; + const mbedtls_ecp_curve_info *curve_info; + size_t sig_len; + + memset( buf, 0x2A, sizeof( buf ) ); + + for( curve_info = curve_list; + curve_info->grp_id != MBEDTLS_ECP_DP_NONE; + curve_info++ ) + { + if( ! mbedtls_ecdsa_can_do( curve_info->grp_id ) ) + continue; + + mbedtls_ecdsa_init( &ecdsa ); + + if( mbedtls_ecdsa_genkey( &ecdsa, curve_info->grp_id, myrand, NULL ) != 0 ) + mbedtls_exit( 1 ); + ecp_clear_precomputed( &ecdsa.grp ); + + mbedtls_snprintf( title, sizeof( title ), "ECDSA-%s", + curve_info->name ); + TIME_PUBLIC( title, "sign", + ret = mbedtls_ecdsa_write_signature( &ecdsa, MBEDTLS_MD_SHA256, buf, curve_info->bit_size, + tmp, &sig_len, myrand, NULL ) ); + + mbedtls_ecdsa_free( &ecdsa ); + } + + for( curve_info = curve_list; + curve_info->grp_id != MBEDTLS_ECP_DP_NONE; + curve_info++ ) + { + if( ! mbedtls_ecdsa_can_do( curve_info->grp_id ) ) + continue; + + mbedtls_ecdsa_init( &ecdsa ); + + if( mbedtls_ecdsa_genkey( &ecdsa, curve_info->grp_id, myrand, NULL ) != 0 || + mbedtls_ecdsa_write_signature( &ecdsa, MBEDTLS_MD_SHA256, buf, curve_info->bit_size, + tmp, &sig_len, myrand, NULL ) != 0 ) + { + mbedtls_exit( 1 ); + } + ecp_clear_precomputed( &ecdsa.grp ); + + mbedtls_snprintf( title, sizeof( title ), "ECDSA-%s", + curve_info->name ); + TIME_PUBLIC( title, "verify", + ret = mbedtls_ecdsa_read_signature( &ecdsa, buf, curve_info->bit_size, + tmp, sig_len ) ); + + mbedtls_ecdsa_free( &ecdsa ); + } + } +#endif + +#if defined(MBEDTLS_ECDH_C) && defined(MBEDTLS_ECDH_LEGACY_CONTEXT) + 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; + size_t olen; + const mbedtls_ecp_curve_info *selected_montgomery_curve_list = + montgomery_curve_list; + + if( curve_list == (const mbedtls_ecp_curve_info*) &single_curve ) + { + mbedtls_ecp_group grp; + mbedtls_ecp_group_init( &grp ); + if( mbedtls_ecp_group_load( &grp, curve_list->grp_id ) != 0 ) + mbedtls_exit( 1 ); + if( mbedtls_ecp_get_type( &grp ) == MBEDTLS_ECP_TYPE_MONTGOMERY ) + selected_montgomery_curve_list = single_curve; + else /* empty list */ + selected_montgomery_curve_list = single_curve + 1; + mbedtls_ecp_group_free( &grp ); + } + + for( curve_info = curve_list; + curve_info->grp_id != MBEDTLS_ECP_DP_NONE; + curve_info++ ) + { + if( ! mbedtls_ecdh_can_do( curve_info->grp_id ) ) + continue; + + mbedtls_ecdh_init( &ecdh ); + + CHECK_AND_CONTINUE( mbedtls_ecp_group_load( &ecdh.grp, curve_info->grp_id ) ); + CHECK_AND_CONTINUE( mbedtls_ecdh_make_public( &ecdh, &olen, buf, sizeof( buf), + myrand, NULL ) ); + CHECK_AND_CONTINUE( mbedtls_ecp_copy( &ecdh.Qp, &ecdh.Q ) ); + ecp_clear_precomputed( &ecdh.grp ); + + mbedtls_snprintf( title, sizeof( title ), "ECDHE-%s", + curve_info->name ); + TIME_PUBLIC( title, "handshake", + CHECK_AND_CONTINUE( mbedtls_ecdh_make_public( &ecdh, &olen, buf, sizeof( buf), + myrand, NULL ) ); + CHECK_AND_CONTINUE( mbedtls_ecdh_calc_secret( &ecdh, &olen, buf, sizeof( buf ), + myrand, NULL ) ) ); + mbedtls_ecdh_free( &ecdh ); + } + + /* Montgomery curves need to be handled separately */ + for ( curve_info = selected_montgomery_curve_list; + curve_info->grp_id != MBEDTLS_ECP_DP_NONE; + curve_info++ ) + { + mbedtls_ecdh_init( &ecdh ); + mbedtls_mpi_init( &z ); + + CHECK_AND_CONTINUE( mbedtls_ecp_group_load( &ecdh.grp, curve_info->grp_id ) ); + CHECK_AND_CONTINUE( mbedtls_ecdh_gen_public( &ecdh.grp, &ecdh.d, &ecdh.Qp, myrand, NULL ) ); + + mbedtls_snprintf( title, sizeof(title), "ECDHE-%s", + curve_info->name ); + TIME_PUBLIC( title, "handshake", + CHECK_AND_CONTINUE( mbedtls_ecdh_gen_public( &ecdh.grp, &ecdh.d, &ecdh.Q, + myrand, NULL ) ); + CHECK_AND_CONTINUE( mbedtls_ecdh_compute_shared( &ecdh.grp, &z, &ecdh.Qp, &ecdh.d, + myrand, NULL ) ) ); + + mbedtls_ecdh_free( &ecdh ); + mbedtls_mpi_free( &z ); + } + + for( curve_info = curve_list; + curve_info->grp_id != MBEDTLS_ECP_DP_NONE; + curve_info++ ) + { + if( ! mbedtls_ecdh_can_do( curve_info->grp_id ) ) + continue; + + mbedtls_ecdh_init( &ecdh ); + + CHECK_AND_CONTINUE( mbedtls_ecp_group_load( &ecdh.grp, curve_info->grp_id ) ); + CHECK_AND_CONTINUE( mbedtls_ecdh_make_public( &ecdh, &olen, buf, sizeof( buf), + myrand, NULL ) ); + CHECK_AND_CONTINUE( mbedtls_ecp_copy( &ecdh.Qp, &ecdh.Q ) ); + CHECK_AND_CONTINUE( mbedtls_ecdh_make_public( &ecdh, &olen, buf, sizeof( buf), + myrand, NULL ) ); + ecp_clear_precomputed( &ecdh.grp ); + + mbedtls_snprintf( title, sizeof( title ), "ECDH-%s", + curve_info->name ); + TIME_PUBLIC( title, "handshake", + CHECK_AND_CONTINUE( mbedtls_ecdh_calc_secret( &ecdh, &olen, buf, sizeof( buf ), + myrand, NULL ) ) ); + mbedtls_ecdh_free( &ecdh ); + } + + /* Montgomery curves need to be handled separately */ + for ( curve_info = selected_montgomery_curve_list; + curve_info->grp_id != MBEDTLS_ECP_DP_NONE; + curve_info++) + { + mbedtls_ecdh_init( &ecdh ); + mbedtls_mpi_init( &z ); + + CHECK_AND_CONTINUE( mbedtls_ecp_group_load( &ecdh.grp, curve_info->grp_id ) ); + CHECK_AND_CONTINUE( mbedtls_ecdh_gen_public( &ecdh.grp, &ecdh.d, &ecdh.Qp, + myrand, NULL ) ); + CHECK_AND_CONTINUE( mbedtls_ecdh_gen_public( &ecdh.grp, &ecdh.d, &ecdh.Q, myrand, NULL ) ); + + mbedtls_snprintf( title, sizeof(title), "ECDH-%s", + curve_info->name ); + TIME_PUBLIC( title, "handshake", + CHECK_AND_CONTINUE( mbedtls_ecdh_compute_shared( &ecdh.grp, &z, &ecdh.Qp, &ecdh.d, + myrand, NULL ) ) ); + + mbedtls_ecdh_free( &ecdh ); + mbedtls_mpi_free( &z ); + } + } +#endif + +#if defined(MBEDTLS_ECDH_C) + if( todo.ecdh ) + { + mbedtls_ecdh_context ecdh_srv, ecdh_cli; + unsigned char buf_srv[BUFSIZE], buf_cli[BUFSIZE]; + const mbedtls_ecp_curve_info *curve_info; + size_t olen; + + for( curve_info = curve_list; + curve_info->grp_id != MBEDTLS_ECP_DP_NONE; + curve_info++ ) + { + if( ! mbedtls_ecdh_can_do( curve_info->grp_id ) ) + continue; + + mbedtls_ecdh_init( &ecdh_srv ); + mbedtls_ecdh_init( &ecdh_cli ); + + mbedtls_snprintf( title, sizeof( title ), "ECDHE-%s", curve_info->name ); + TIME_PUBLIC( title, "full handshake", + const unsigned char * p_srv = buf_srv; + + CHECK_AND_CONTINUE( mbedtls_ecdh_setup( &ecdh_srv, curve_info->grp_id ) ); + CHECK_AND_CONTINUE( mbedtls_ecdh_make_params( &ecdh_srv, &olen, buf_srv, sizeof( buf_srv ), myrand, NULL ) ); + + CHECK_AND_CONTINUE( mbedtls_ecdh_read_params( &ecdh_cli, &p_srv, p_srv + olen ) ); + CHECK_AND_CONTINUE( mbedtls_ecdh_make_public( &ecdh_cli, &olen, buf_cli, sizeof( buf_cli ), myrand, NULL ) ); + + CHECK_AND_CONTINUE( mbedtls_ecdh_read_public( &ecdh_srv, buf_cli, olen ) ); + CHECK_AND_CONTINUE( mbedtls_ecdh_calc_secret( &ecdh_srv, &olen, buf_srv, sizeof( buf_srv ), myrand, NULL ) ); + + CHECK_AND_CONTINUE( mbedtls_ecdh_calc_secret( &ecdh_cli, &olen, buf_cli, sizeof( buf_cli ), myrand, NULL ) ); + mbedtls_ecdh_free( &ecdh_cli ); + + mbedtls_ecdh_free( &ecdh_srv ); + ); + + } + } +#endif + + 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 + + mbedtls_exit( 0 ); +} + +#endif /* MBEDTLS_TIMING_C */ diff --git a/benchmark/main.cpp b/benchmark/main.cpp deleted file mode 100644 index c148f6a94..000000000 --- a/benchmark/main.cpp +++ /dev/null @@ -1,1595 +0,0 @@ -/* - * Benchmark demonstration program - * - * Copyright (C) 2006-2018, Arm Limited, All Rights Reserved - * SPDX-License-Identifier: Apache-2.0 - * - * 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 - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * 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. - */ - -#include "mbed.h" - -#if !defined(MBEDTLS_CONFIG_FILE) -#include "mbedtls/config.h" -#else -#include MBEDTLS_CONFIG_FILE -#endif /* MBEDTLS_CONFIG_FILE */ - -#include "mbedtls/platform.h" -#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/cmac.h" -#include "mbedtls/blowfish.h" -#include "mbedtls/camellia.h" -#include "mbedtls/gcm.h" -#include "mbedtls/ccm.h" -#include "mbedtls/havege.h" -#include "mbedtls/ctr_drbg.h" -#include "mbedtls/hmac_drbg.h" -#include "mbedtls/rsa.h" -#include "mbedtls/pk.h" -#include "mbedtls/dhm.h" -#include "mbedtls/ecdsa.h" -#include "mbedtls/ecdh.h" -#include "mbedtls/error.h" - -#define RSA_PRIVATE_KEY_2048 \ -"-----BEGIN RSA PRIVATE KEY-----\n" \ -"MIIEogIBAAKCAQEA2dwVr+IMGEtA2/MCP6fA5eb/6B18Bq6e7gw8brNPkm3E6LyR\n" \ -"4DnMJVxZmw3bPDKBDoKzfntkMESi/Yw5UopLtVfjGfWeQWPClqffLZBsZ60BRAsg\n" \ -"/g+ID5tgzxSuxzftypK59uexOVCAm7hCKZHGO3DbI7bLY27j7VAgEP7d/yuaz5Fx\n" \ -"Kl/vu7shqrBoz6ABJVJD3KC8nUiMRUCXRINmxbyUUjA4DnicZv6+xrGKr36r6M8h\n" \ -"VYLa5msKc8WzbnBWzpUsrpb4/r7ML+qp92gdSfVJ8/bLiU7h2C7faDA59uaqrFK9\n" \ -"xmDdx7FaWhGQs3LWW6w1UNgkPS0FDYUslpsnsQIDAQABAoIBAC7IJNwM5V3+IuJY\n" \ -"T35Nzo1PyloUosJokvY5KGz5Ejg2XBdCDu0gXCcVqqQyGIbXrYDpLhQV+RCoXHun\n" \ -"tdN0oQdC5SB47s/J1Uo2qCUHo0+sBd6PqTkFKsl3KxWssk9TQjvCwC412IefMs69\n" \ -"hW+ZvwCanmQP56LleApIr2oW4KLfW8Ry/QfZlua+dizctdN7+H1mWwgZQTY9T27J\n" \ -"6RtGRA5NVkKVPzIHVJfdpKoO7xGg1g06aEbPB/VmGvZaaFWWnaf7uRvFjLZecBLu\n" \ -"QSx2DA/GDjirlDYj99PJb7DtB4xRtKzsyw0o+xapC8w6OtIl/3xFt9moCu2jGrsx\n" \ -"vpjHdfECgYEA7fSACRseIs9gAIVX8wq6gayTpA47DHYWAD6IQfIj35SJ+AgsvbFF\n" \ -"4AmrwDhcJVPmDy1N4nLBfyGAMt/2CfiYkdkW6QFX/ULRMMBL/G7kWV8hYQDICB2g\n" \ -"xaMRN1lPCmFq6BkSWjwIYTnYDFBDWVm1GVT8TMtJoM8Erej9qC0PeFUCgYEA6mF3\n" \ -"bigO3t8f5sig+XepaftEUbkJMzo72TVRnIR2ycdR2ihelPQ+25g9dwV0ZA5XXhBS\n" \ -"DKOABWjMM739Mwmy9v26Dlmu9R01zHQktMvtEAyfz7lk2NF0aMuj8285OJUBf9bz\n" \ -"Cq3MjtMCD+4CZ6iaEqCdUKOuxfpx5cWVJV+qve0CgYBhD1YaYMFOGaBjFgDl1f51\n" \ -"Xltqk5NqZdBbkSYrIAWZ8RDF5y+4wFJsLAWuhk6vuyUgE66tK3nZzWRpXAkT0B8L\n" \ -"fq1lpXKqj1KcvBNCiEkEW1VWJ+dvyAYIF5eyJ++hoFLnETL3M32HivyhKSwPihPg\n" \ -"nVW8TT9fJJIYDe1JZ/fjcQKBgHJfv7UsrR0LSvkG3K8AOtbx+8PZhOjPuRbk0v+L\n" \ -"EKCkuIe5/XW4vtfQMeZb7hFJgk7vrepm+vkoy8VQKDf4urGW3W1VTHBmobM01hi4\n" \ -"DuYvEul+Mf0wMRtWjJolo4m+BO5KiW2jpFfqFm6JmfjVqOIAKOSKC6am8V/MDF0h\n" \ -"kyN9AoGAT9oOiEXMolbkDZw/QCaBiRoAGlGlNYUkJ+58U6OjIZLISw6aFv+Y2uE0\n" \ -"mEImItjuYZtSYKblWikp6ldPoKlt9bwEFe3c6IZ8kJ3+xyEyAGrvjXjEY7PzP6dp\n" \ -"Ajbjp9X9uocEBv9W/KsBLdQ7yizcL/toHwdBO4vQqmqTvAc5IIw=\n" \ -"-----END RSA PRIVATE KEY-----\n" - -#define RSA_PRIVATE_KEY_4096 \ -"-----BEGIN RSA PRIVATE KEY-----\n" \ -"MIIJKgIBAAKCAgEAmkdGjoIshJuOt2NO47qB3Z3yyvmLg2j351isItSNuFQU3qr+\n" \ -"jXHIeANf03yw/K0Zvos8RPd+CqLjoxAQL3QDH4bZAl88bIo29i+SANbNSrKQmc0k\n" \ -"pH+yzw3alDzO0GZaOPZjsbo6AwBrno5msi0vRuC2aY8vGLPsZWSyLai7tneS1j/o\n" \ -"vYW6XIo8Cj61j2Ypy9HhVUW/4Wc+zAT25D/x7jTpkqJLWWT+YzibNbOY48M5eJcB\n" \ -"6/sMyUIeI3/u/wXyMrooNyLiCpedkuHRA0m7u5cWPTUISTunSRlVFij/NHJjuU8e\n" \ -"wA3B29yfZFsUqDEnyc+OxniIueAixTomVszxAaVn8zFEbYhFMPqziiFp99u3jfeG\n" \ -"k1q9mmUi/uCfUC4e2IC5rqq1ZbKSduH7Ug/Vn2bGQahww0sZFRHDXFrnBcotcW+M\n" \ -"bnC290VBDnYgzmdYrIOxuPb2aUwJo4ZlbKh5uBB1PigMuyhLKibQ1a+V5ZJGdpP6\n" \ -"SE9PGIdgYWSmh2QEMuLE6v+wTO2LQ5JgqsvFfi3GIZvkn0s8jTS72Jq2uMkFkMer\n" \ -"UBjPDYaSPy5kpo103KerWs+cMPOJ/3FtZzI++7MoSUTkWVr1ySQFt5i1EIZ/0Thi\n" \ -"jut2jNe8a4AoA3TtC8Rkk/3AIIbg8MVNT4EnT+KHROTMu6gET1oJ3YfBRpUCAwEA\n" \ -"AQKCAgEAhuNSmT7PVZH8kfLOAuYKrY1vvm+4v0iDl048Eqfs0QESziyLK3gUYnnw\n" \ -"yqP2yrU+EQ8Dvvj0xq/sf6GHxTWVlXb9PcmutueRbmXhLcKg83J0Y0StiPXtjIL8\n" \ -"XSddW3Bh6fPi7n14Qy+W6KZwu9AtybanRlvePabyRSRpdOpWVQ7u30w5XZsSed6S\n" \ -"6BI0BBC68m2qqje1sInoqdCdXKtcB31TytUDNEHM+UuAyM8iGeGS2hCNqZlycHTS\n" \ -"jQ9KEsdMH3YLu0lQgRpWtxmg+VL6ROWwmAtKF12EwbDYZ+uoVl69OkQnCpv8pxKa\n" \ -"ec/4m6V+uEA1AOpaAMorHG3fH31IKWC/fTZstovgO/eG2XCtlbcCoWCQ7amFq16l\n" \ -"Gh1UKeBHxMXpDj4oDmIUGUvgzSNnEeSN/v76losWvWYQDjXR/LMDa/CNYsD8BmJR\n" \ -"PZidIjIXdVRlYOhA7ljtySQvp6RBujBfw3tsVMyZw2XzXFwM9O89b1xXC6+M5jf9\n" \ -"DXs/U7Fw+J9qq/YpByABcPCwWdttwdQFRbOxwxaSOKarIqS87TW1JuFcNJ59Ut6G\n" \ -"kMvAg6gC34U+0ktkG/AmI1hgjC+P7ErHCXBR2xARoGzcO/CMZF59S+Z2HFchpTSP\n" \ -"5T2o4mGy3VfHSBidQQrcZRukg8ZP8M1NF3bXjpY6QZpeLHc4oHECggEBAMjdgzzk\n" \ -"xp4mIYFxAEiXYt7tzuUXJk+0UpEJj5uboWLirUZqZmNUPyh6WDnzlREBH++Ms0LO\n" \ -"+AWSfaGPDoMb0NE2j3c4FRWAhe7Vn6lj7nLVpF2RdwRo88yGerZ4uwGMY8NUQCtn\n" \ -"zum3J7eCJ5DojiceRb6uMxTJ8xZmUC4W2f3J/lrR7wlYjyVnnHqH5HcemYUipWSw\n" \ -"sM0/cHp3lrz2VWrbAEu8HVpklvDQpdAgl7cjXt/JHYawY+p426IF/PzQSRROnzgy\n" \ -"4WI8FVYNV2tgu0TOFURbkkEvuj/duDKeooUIF0G0XHzha5oAX/j0iWiHbrOF6wHj\n" \ -"0xeajL9msKBnmD8CggEBAMSgLWmv7G31x4tndJCcXnX4AyVL7KpygAx/ZwCcyTR8\n" \ -"rY1rO07f/ta2noEra/xmEW/BW98qJFCHSU2nSLAQ5FpFSWyuQqrnffrMJnfWyvpr\n" \ -"ceQ0yQ/MiA6/JIOvGAjabcspzZijxzGp+Qk3eTT0yOXLSVOCH9B9XVHLodcy4PQM\n" \ -"KSCxy0vVHhVNl2SdPEwTXRmxk99Q/rw6IHVpQxBq1OhQt05nTKT+rZMD/grSK22e\n" \ -"my2F0DodAJwLo063Zv3RXQZhDYodMmjcp9Hqrtvj9P3HD7J3z6ACiV3SCi8cZumL\n" \ -"bSmnKCcd0bb45+aOWm31ieECJuIcJ9rOREEa/KDYTCsCggEBAMG5WkSVhLWsou37\n" \ -"dUGNuA63nq42SH3gtS0q4nU6gUkkw+dA4ST1cMByVrr1oRQ4WHup4I4TnQOKyF3T\n" \ -"4jQy1I+ipnVeAn+tZ/7zyzwMpEHeqNqRXA9FxbTBEoMAJ6QTqXgOvqDeSqIAQm7r\n" \ -"OYu5rrgtqyh/S8bGCwvUe4ooAfCSKx2ekYMbBVwW9MT8YS09tuS/iHJ3Mt2RTMLg\n" \ -"qeHvVmxrcXqZoFm44Ba7tN/pP0mi9HKyviZT4tmV3IYEbn3JyGGsfkUuVU9wEUfg\n" \ -"MCrgrVxrwfketAzooiHMjkVL2ASjzAJTmEvdAPETYXxzJD9LN0ovY3t8JfAC37IN\n" \ -"sVXS8/MCggEBALByOS59Y4Ktq1rLBQx8djwQyuneP0wZohUVAx7Gk7xZIfklQDyg\n" \ -"v/R4PrcVezstcPpDnykdjScCsGJR+uWc0v667I/ttP/e6utz5hVmmBGu965dPAzE\n" \ -"c1ggaSkOqFfRg/Nr2Qbf+fH0YPnHYSqHe/zSt0OMIvaaeXLcdKhEDSCUBRhE1HWB\n" \ -"kxR046WzgBeYzNQwycz9xwqsctJKGpeR9ute+5ANHPd3X9XtID0fqz8ctI5eZaSw\n" \ -"wApIW01ZQcAF8B+4WkkVuFXnpWW33yCOaRyPVOPHpnclr5WU1fS+3Q85QkW9rkej\n" \ -"97zlkl0QY9AHJqrXnoML1ywAK7ns+MVyNK8CggEAf62xcKZhOb1djeF72Ms+i/i/\n" \ -"WIAq4Q4YpsElgvJTHpNH2v9g4ngSTKe3ws3bGc502sWRlhcoTFMOW2rJNe/iqKkb\n" \ -"3cdeTkseDbpqozmJWz9dJWSVtXas2bZjzBEa//gQ7nHGVeQdqZJQ9rxPsoOAkfpi\n" \ -"qCFrmfUVUqC53e3XMt8+W+aSvKl+JZiB9ozkO9A6Q0vfQLKtjUMdQE3XaCFQT8DI\n" \ -"smaLBlBmeRaBpc02ENeC4ADlWosm1SwgxqMhuh2Alba/GrHOoPlVl4hDs9Fb5a6R\n" \ -"rmpXSt07GAxnG6j9jssA95E4rc1zO0CVKG5bvjVTxwi/sT0/VVX7VsJM4uTAQg==\n" \ -"-----END RSA PRIVATE KEY-----\n" - -#define BUFSIZE 1024 -#define HEADER_FORMAT " %-24s : " -#define TITLE_LEN 25 - -#if defined(MBEDTLS_ERROR_C) -#define PRINT_ERROR(RET, CODE) \ - mbedtls_strerror(RET, err_buf, sizeof(err_buf)); \ - mbedtls_printf("%s returned -0x%04X\n", CODE, -RET); \ - mbedtls_printf(" ! %s\n", err_buf); -#else -#define PRINT_ERROR(RET, CODE) \ - mbedtls_printf("%s returned -0x%04X\n", CODE, -RET); -#endif /* MBEDTLS_ERROR_C */ - -#define BENCHMARK_FUNC_CALL(TITLE, CODE) \ -do { \ - unsigned long i; \ - Timeout t; \ - \ - mbedtls_printf(HEADER_FORMAT, TITLE); \ - fflush(stdout); \ - \ - for (i = 1, alarmed = 0, t.attach(alarm, 1.0); !alarmed; i++) { \ - ret = CODE; \ - if (ret == MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED) { \ - mbedtls_printf("Feature unsupported\n"); \ - break; \ - } else if (ret != 0) { \ - PRINT_ERROR(ret, #CODE); \ - goto exit; \ - } \ - } \ - \ - if (ret == 0) { \ - mbedtls_printf("%9lu KB/s\n", i * BUFSIZE / 1024); \ - } \ -} while(0) - -#define BENCHMARK_PUBLIC(TITLE, TYPE, CODE) \ -do { \ - unsigned long ms; \ - Timer t; \ - \ - mbedtls_printf(HEADER_FORMAT, TITLE); \ - fflush(stdout); \ - \ - t.start(); \ - CODE; \ - t.stop(); \ - ms = t.read_ms(); \ - \ - if (ret == MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED) {\ - mbedtls_printf("Feature unsupported\n"); \ - break; \ - } else if (ret != 0) { \ - PRINT_ERROR(ret, "Public function"); \ - goto exit; \ - } else { \ - mbedtls_printf("%6lu ms/" TYPE, ms); \ - mbedtls_printf("\n"); \ - } \ -} while(0) - -/* Clear some memory that was used to prepare the context */ -#if defined(MBEDTLS_ECP_C) -void ecp_clear_precomputed(mbedtls_ecp_group *grp) -{ - 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); - } - grp->T = NULL; - grp->T_size = 0; -} -#else -#define ecp_clear_precomputed(g) -#endif /* MBEDTLS_ECP_C */ - -static unsigned char buf[BUFSIZE]; -/* - * Buffer used to hold various data such as IV, signatures, keys, etc. ECDSA - * seems to be the benchmark that uses the most memory from this buffer as it - * is holds the output signature - */ -static unsigned char tmp[150]; -/* The longest error message has 134 characters (including \0) */ -static char err_buf[134]; -static char title[TITLE_LEN]; - -static volatile int alarmed; - -static void alarm() -{ - alarmed = 1; -} - -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; -} - -#if defined(MBEDTLS_MD4_C) -MBED_NOINLINE static int benchmark_md4() -{ - int ret; - - BENCHMARK_FUNC_CALL("MD4", mbedtls_md4_ret(buf, BUFSIZE, tmp)); - - ret = 0; - -exit: - - return ret; -} -#endif /* MBEDTLS_MD4_C */ - -#if defined(MBEDTLS_MD5_C) -MBED_NOINLINE static int benchmark_md5() -{ - int ret; - - BENCHMARK_FUNC_CALL("MD5", mbedtls_md5_ret(buf, BUFSIZE, tmp)); - - ret = 0; - -exit: - - return ret; -} -#endif /* MBEDTLS_MD5_C */ - -#if defined(MBEDTLS_RIPEMD160_C) -MBED_NOINLINE static int benchmark_ripemd160() -{ - int ret; - - BENCHMARK_FUNC_CALL("RIPEMD160", mbedtls_ripemd160_ret(buf, BUFSIZE, tmp)); - - ret = 0; - -exit: - - return ret; -} -#endif /* MBEDTLS_RIPEMD160_C */ - -#if defined(MBEDTLS_SHA1_C) -MBED_NOINLINE static int benchmark_sha1() -{ - int ret; - - BENCHMARK_FUNC_CALL("SHA-1", mbedtls_sha1_ret(buf, BUFSIZE, tmp)); - - ret = 0; - -exit: - - return ret; -} -#endif /* MBEDTLS_SHA1_C */ - -#if defined(MBEDTLS_SHA256_C) -MBED_NOINLINE static int benchmark_sha256() -{ - int ret; - - BENCHMARK_FUNC_CALL("SHA-256", mbedtls_sha256_ret(buf, BUFSIZE, tmp, 0)); - - ret = 0; - -exit: - - return ret; -} -#endif /* MBEDTLS_SHA256_C */ - -#if defined(MBEDTLS_SHA512_C) -MBED_NOINLINE static int benchmark_sha512() -{ - int ret; - - BENCHMARK_FUNC_CALL("SHA-512", mbedtls_sha512_ret(buf, BUFSIZE, tmp, 0)); - - ret = 0; - -exit: - - return ret; -} -#endif /* MBEDTLS_SHA512_C */ - -#if defined(MBEDTLS_ARC4_C) -MBED_NOINLINE static int benchmark_arc4() -{ - int ret = 0; - mbedtls_arc4_context arc4; - - mbedtls_arc4_init(&arc4); - - mbedtls_arc4_setup(&arc4, tmp, 32); - BENCHMARK_FUNC_CALL("ARC4", - mbedtls_arc4_crypt(&arc4, BUFSIZE, buf, buf)); - - ret = 0; - -exit: - mbedtls_arc4_free(&arc4); - - return ret; -} -#endif /* MBEDTLS_ARC4_C */ - -#if defined(MBEDTLS_DES_C) && defined(MBEDTLS_CIPHER_MODE_CBC) -MBED_NOINLINE static int benchmark_des3() -{ - int ret = 0; - mbedtls_des3_context des3; - - mbedtls_des3_init(&des3); - - if ((ret = mbedtls_des3_set3key_enc(&des3, tmp)) != 0) { - PRINT_ERROR(ret, "mbedtls_des3_set3key_enc()"); - goto exit; - } - BENCHMARK_FUNC_CALL("3DES", - mbedtls_des3_crypt_cbc(&des3, MBEDTLS_DES_ENCRYPT, - BUFSIZE, tmp, buf, buf)); - - ret = 0; - -exit: - mbedtls_des3_free(&des3); - - return ret; -} -#endif /* MBEDTLS_DES_C && MBEDTLS_CIPHER_MODE_CBC */ - -#if defined(MBEDTLS_DES_C) && defined(MBEDTLS_CIPHER_MODE_CBC) -MBED_NOINLINE static int benchmark_des() -{ - int ret = 0; - mbedtls_des_context des; - - mbedtls_des_init(&des); - - if ((ret = mbedtls_des_setkey_enc(&des, tmp)) != 0) { - PRINT_ERROR(ret, "mbedtls_des_setkey_enc()"); - goto exit; - } - BENCHMARK_FUNC_CALL("DES", - mbedtls_des_crypt_cbc(&des, MBEDTLS_DES_ENCRYPT, - BUFSIZE, tmp, buf, buf)); - - ret = 0; - -exit: - mbedtls_des_free(&des); - - return ret; -} -#endif /* MBEDTLS_DES_C && MBEDTLS_CIPHER_MODE_CBC */ - -#if defined(MBEDTLS_DES_C) && defined(MBEDTLS_CIPHER_MODE_CBC) && \ - defined(MBEDTLS_CMAC_C) -MBED_NOINLINE static int benchmark_des3_cmac() -{ - int ret = 0; - 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); - if (cipher_info == NULL) { - mbedtls_printf("mbedtls_cipher_info_from_type() returned NULL\n"); - return -1; - } - - BENCHMARK_FUNC_CALL("3DES-CMAC", - mbedtls_cipher_cmac(cipher_info, tmp, 192, buf, - BUFSIZE, output)); - - ret = 0; - -exit: - return ret; -} -#endif /* MBEDTLS_DES_C && MBEDTLS_CIPHER_MODE_CBC && MBEDTLS_CMAC_C */ - -#if defined(MBEDTLS_AES_C) && defined(MBEDTLS_CIPHER_MODE_CBC) -MBED_NOINLINE static int benchmark_aes_cbc() -{ - int ret = 0; - int keysize; - mbedtls_aes_context aes; - - mbedtls_aes_init(&aes); - - for (keysize = 128; keysize <= 256; keysize += 64) { - ret = mbedtls_snprintf(title, sizeof(title), "AES-CBC-%d", keysize); - if (ret < 0 || static_cast(ret) >= sizeof(title)) { - mbedtls_printf("Failed to compose title string using " - "mbedtls_snprintf(): %d\n", ret); - goto exit; - } - - memset(buf, 0, sizeof(buf)); - memset(tmp, 0, sizeof(tmp)); - - ret = mbedtls_aes_setkey_enc(&aes, tmp, keysize); - if (ret == MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED) { - /* Do not consider this as a failure */ - mbedtls_printf(HEADER_FORMAT "Feature unsupported\n", title); - continue; - } else if (ret != 0) { - PRINT_ERROR(ret, "mbedtls_aes_setkey_enc()"); - goto exit; - } - - BENCHMARK_FUNC_CALL(title, - mbedtls_aes_crypt_cbc(&aes, - MBEDTLS_AES_ENCRYPT, BUFSIZE, - tmp, buf, buf)); - } - - ret = 0; - -exit: - mbedtls_aes_free(&aes); - - return ret; -} -#endif /* MBEDTLS_AES_C && MBEDTLS_CIPHER_MODE_CBC */ - -#if defined(MBEDTLS_AES_C) && defined(MBEDTLS_CIPHER_MODE_CTR) -MBED_NOINLINE static int benchmark_aes_ctr() -{ - int ret = 0; - int keysize; - size_t nc_offset = 0; - unsigned char stream_block[16]; - mbedtls_aes_context aes; - - mbedtls_aes_init(&aes); - - for (keysize = 128; keysize <= 256; keysize += 64) { - ret = mbedtls_snprintf(title, sizeof(title), "AES-CTR-%d", keysize); - if (ret < 0 || static_cast(ret) >= sizeof(title)) { - mbedtls_printf("Failed to compose title string using " - "mbedtls_snprintf(): %d\n", ret); - goto exit; - } - - memset(buf, 0, sizeof(buf)); - memset(tmp, 0, sizeof(tmp)); - - ret = mbedtls_aes_setkey_enc(&aes, tmp, keysize); - if (ret == MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED) { - /* Do not consider this as a failure */ - mbedtls_printf(HEADER_FORMAT "Feature unsupported\n", title); - continue; - } else if (ret != 0) { - PRINT_ERROR(ret, "mbedtls_aes_setkey_enc()"); - goto exit; - } - - BENCHMARK_FUNC_CALL(title, - mbedtls_aes_crypt_ctr(&aes, BUFSIZE, &nc_offset, - tmp, stream_block, buf, - buf)); - } - - ret = 0; - -exit: - mbedtls_aes_free(&aes); - - return ret; -} -#endif /* MBEDTLS_AES_C && MBEDTLS_CIPHER_MODE_CTR */ - -#if defined(MBEDTLS_AES_C) && defined(MBEDTLS_GCM_C) -MBED_NOINLINE static int benchmark_aes_gcm() -{ - int ret = 0; - int keysize; - mbedtls_gcm_context gcm; - - mbedtls_gcm_init(&gcm); - - for (keysize = 128; keysize <= 256; keysize += 64) { - ret = mbedtls_snprintf(title, sizeof(title), "AES-GCM-%d", keysize); - if (ret < 0 || static_cast(ret) >= sizeof(title)) { - mbedtls_printf("Failed to compose title string using " - "mbedtls_snprintf(): %d\n", ret); - goto exit; - } - - memset(buf, 0, sizeof(buf)); - memset(tmp, 0, sizeof(tmp)); - - ret = mbedtls_gcm_setkey(&gcm, MBEDTLS_CIPHER_ID_AES, tmp, keysize); - if (ret == MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED) { - /* Do not consider this as a failure */ - mbedtls_printf(HEADER_FORMAT "Feature unsupported\n", title); - continue; - } else if (ret != 0) { - PRINT_ERROR(ret, "mbedtls_gcm_setkey()"); - goto exit; - } - - BENCHMARK_FUNC_CALL(title, - mbedtls_gcm_crypt_and_tag(&gcm, - MBEDTLS_GCM_ENCRYPT, - BUFSIZE, tmp, 12, NULL, - 0, buf, buf, 16, tmp)); - } - - ret = 0; - -exit: - mbedtls_gcm_free(&gcm); - - return ret; -} -#endif /* MBEDTLS_AES_C && MBEDTLS_GCM_C */ - -#if defined(MBEDTLS_AES_C) && defined(MBEDTLS_CCM_C) -MBED_NOINLINE static int benchmark_aes_ccm() -{ - int ret = 0; - int keysize; - mbedtls_ccm_context ccm; - - mbedtls_ccm_init(&ccm); - - for (keysize = 128; keysize <= 256; keysize += 64) { - ret = mbedtls_snprintf(title, sizeof(title), "AES-CCM-%d", keysize); - if (ret < 0 || static_cast(ret) >= sizeof(title)) { - mbedtls_printf("Failed to compose title string using " - "mbedtls_snprintf(): %d\n", ret); - goto exit; - } - - memset(buf, 0, sizeof(buf)); - memset(tmp, 0, sizeof(tmp)); - - ret = mbedtls_ccm_setkey(&ccm, MBEDTLS_CIPHER_ID_AES, tmp, keysize); - if (ret == MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED) { - /* Do not consider this as a failure */ - mbedtls_printf(HEADER_FORMAT "Feature unsupported\n", title); - continue; - } else if (ret != 0) { - PRINT_ERROR(ret, "mbedtls_gcm_setkey()"); - goto exit; - } - - BENCHMARK_FUNC_CALL(title, - mbedtls_ccm_encrypt_and_tag(&ccm, BUFSIZE, tmp, 12, - NULL, 0, buf, buf, tmp, - 16)); - } - - ret = 0; - -exit: - mbedtls_ccm_free(&ccm); - - return ret; -} -#endif /* MBEDTLS_AES_C && MBEDTLS_CCM_C */ - -#if defined(MBEDTLS_AES_C) && defined(MBEDTLS_CMAC_C) -MBED_NOINLINE static int benchmark_aes_cmac() -{ - int ret = 0; - unsigned char output[16]; - const mbedtls_cipher_info_t *cipher_info; - mbedtls_cipher_type_t cipher_type; - int keysize; - - cipher_type = MBEDTLS_CIPHER_AES_128_ECB; - for (keysize = 128; keysize <= 256; keysize += 64) { - ret = mbedtls_snprintf(title, sizeof(title), "AES-CMAC-%d", keysize); - if (ret < 0 || static_cast(ret) >= sizeof(title)) { - mbedtls_printf("Failed to compose title string using " - "mbedtls_snprintf(): %d\n", ret); - goto exit; - } - - memset(buf, 0, sizeof(buf)); - memset(tmp, 0, sizeof(tmp)); - - cipher_info = mbedtls_cipher_info_from_type(cipher_type); - if (cipher_info == NULL) { - mbedtls_printf("mbedtls_cipher_info_from_type() returned NULL\n"); - goto exit; - } - - BENCHMARK_FUNC_CALL(title, - mbedtls_cipher_cmac(cipher_info, tmp, keysize, - buf, BUFSIZE, output)); - cipher_type = (mbedtls_cipher_type_t)(cipher_type + 1); - } - - memset(buf, 0, sizeof(buf)); - memset(tmp, 0, sizeof(tmp)); - - BENCHMARK_FUNC_CALL("AES-CMAC-PRF-128", - mbedtls_aes_cmac_prf_128(tmp, 16, buf, BUFSIZE, - output)); - - ret = 0; - -exit: - - return ret; -} -#endif /* MBEDTLS_AES_C && MBEDTLS_CMAC_C */ - -#if defined(MBEDTLS_CAMELLIA_C) && defined(MBEDTLS_CIPHER_MODE_CBC) -MBED_NOINLINE static int benchmark_camellia() -{ - int ret = 0; - int keysize; - mbedtls_camellia_context camellia; - - mbedtls_camellia_init(&camellia); - - for (keysize = 128; keysize <= 256; keysize += 64) { - ret = mbedtls_snprintf(title, sizeof(title), "CAMELLIA-CBC-%d", - keysize); - if (ret < 0 || static_cast(ret) >= sizeof(title)) { - mbedtls_printf("Failed to compose title string using " - "mbedtls_snprintf(): %d\n", ret); - goto exit; - } - - memset(buf, 0, sizeof(buf)); - memset(tmp, 0, sizeof(tmp)); - - ret = mbedtls_camellia_setkey_enc(&camellia, tmp, keysize); - if (ret == MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED) { - /* Do not consider this as a failure */ - mbedtls_printf(HEADER_FORMAT "Feature unsupported\n", title); - ret = 0; - continue; - } else if (ret != 0) { - PRINT_ERROR(ret, "mbedtls_camellia_setkey_enc()"); - goto exit; - } - - BENCHMARK_FUNC_CALL(title, - mbedtls_camellia_crypt_cbc(&camellia, - MBEDTLS_CAMELLIA_ENCRYPT, - BUFSIZE, tmp, buf, buf)); - } - - ret = 0; - -exit: - mbedtls_camellia_free(&camellia); - - return ret; -} -#endif /* MBEDTLS_CAMELLIA_C && MBEDTLS_CIPHER_MODE_CBC */ - -#if defined(MBEDTLS_BLOWFISH_C) && defined(MBEDTLS_CIPHER_MODE_CBC) -MBED_NOINLINE static int benchmark_blowfish() -{ - int ret = 0; - int keysize; - mbedtls_blowfish_context *blowfish; - - blowfish = (mbedtls_blowfish_context *)mbedtls_calloc(1, - sizeof(mbedtls_blowfish_context)); - if (blowfish == NULL) { - mbedtls_printf("Failed to allocate mbedtls_blowfish_context\n"); - return -1; - } - - mbedtls_blowfish_init(blowfish); - - for (keysize = 128; keysize <= 256; keysize += 64) { - mbedtls_snprintf(title, sizeof(title), "BLOWFISH-CBC-%d", keysize); - if (ret < 0 || static_cast(ret) >= sizeof(title)) { - mbedtls_printf("Failed to compose title string using " - "mbedtls_snprintf(): %d\n", ret); - goto exit; - } - - memset(buf, 0, sizeof(buf)); - memset(tmp, 0, sizeof(tmp)); - - ret = mbedtls_blowfish_setkey(blowfish, tmp, keysize); - if (ret == MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED) { - /* Do not consider this as a failure */ - mbedtls_printf(HEADER_FORMAT "Feature unsupported\n", title); - ret = 0; - continue; - } else if (ret != 0) { - PRINT_ERROR(ret, "mbedtls_blowfish_setkey()"); - goto exit; - } - - BENCHMARK_FUNC_CALL(title, - mbedtls_blowfish_crypt_cbc(blowfish, - MBEDTLS_BLOWFISH_ENCRYPT, - BUFSIZE, - tmp, buf, buf)); - } - - ret = 0; - -exit: - mbedtls_blowfish_free(blowfish); - mbedtls_free(blowfish); - - return ret; -} -#endif /* MBEDTLS_BLOWFISH_C && MBEDTLS_CIPHER_MODE_CBC */ - -#if defined(MBEDTLS_HAVEGE_C) -MBED_NOINLINE static int benchmark_havege() -{ - int ret = 0; - mbedtls_havege_state hs; - - mbedtls_havege_init(&hs); - - BENCHMARK_FUNC_CALL("HAVEGE", mbedtls_havege_random(&hs, buf, BUFSIZE)); - - ret = 0; - -exit: - mbedtls_havege_free(&hs); - - return ret; -} -#endif /* MBEDTLS_HAVEGE_C */ - -#if defined(MBEDTLS_CTR_DRBG_C) -MBED_NOINLINE static int benchmark_ctr_drbg() -{ - int ret = 0; - const char *nopr_title = "CTR_DRBG (NOPR)"; - const char *pr_title = "CTR_DRBG (PR)"; - mbedtls_ctr_drbg_context ctr_drbg; - - mbedtls_ctr_drbg_init(&ctr_drbg); - ret = mbedtls_ctr_drbg_seed(&ctr_drbg, myrand, NULL, NULL, 0); - if (ret != 0) { - PRINT_ERROR(ret, "mbedtls_ctr_drbg_seed()"); - goto exit; - } - BENCHMARK_FUNC_CALL(nopr_title, - mbedtls_ctr_drbg_random(&ctr_drbg, buf, BUFSIZE)); - mbedtls_ctr_drbg_free(&ctr_drbg); - - mbedtls_ctr_drbg_init(&ctr_drbg); - ret = mbedtls_ctr_drbg_seed(&ctr_drbg, myrand, NULL, NULL, 0); - if (ret != 0) { - PRINT_ERROR(ret, "mbedtls_ctr_drbg_seed()"); - goto exit; - } - mbedtls_ctr_drbg_set_prediction_resistance(&ctr_drbg, - MBEDTLS_CTR_DRBG_PR_ON); - BENCHMARK_FUNC_CALL(pr_title, - mbedtls_ctr_drbg_random(&ctr_drbg, buf, BUFSIZE)); - - ret = 0; - -exit: - mbedtls_ctr_drbg_free(&ctr_drbg); - - return ret; -} -#endif /* MBEDTLS_CTR_DRBG_C */ - -#if defined(MBEDTLS_HMAC_DRBG_C) -MBED_NOINLINE static int benchmark_hmac_drbg() -{ - int ret = 0; - mbedtls_hmac_drbg_context hmac_drbg; - const mbedtls_md_info_t *md_info; - - mbedtls_hmac_drbg_init(&hmac_drbg); - -#if defined(MBEDTLS_SHA1_C) - md_info = mbedtls_md_info_from_type(MBEDTLS_MD_SHA1); - if (md_info == NULL) { - mbedtls_printf("mbedtls_md_info_from_type() returned NULL\n"); - ret = -1; - goto exit; - } - - ret = mbedtls_hmac_drbg_seed(&hmac_drbg, md_info, myrand, NULL, NULL, 0); - if (ret != 0) { - PRINT_ERROR(ret, "mbedtls_hmac_drbg_seed()"); - goto exit; - } - BENCHMARK_FUNC_CALL("HMAC_DRBG SHA-1 (NOPR)", - mbedtls_hmac_drbg_random(&hmac_drbg, buf, BUFSIZE)); - - ret = mbedtls_hmac_drbg_seed(&hmac_drbg, md_info, myrand, NULL, NULL, 0); - if (ret != 0) { - PRINT_ERROR(ret, "mbedtls_hmac_drbg_seed()"); - goto exit; - } - mbedtls_hmac_drbg_set_prediction_resistance(&hmac_drbg, - MBEDTLS_HMAC_DRBG_PR_ON); - BENCHMARK_FUNC_CALL("HMAC_DRBG SHA-1 (PR)", - mbedtls_hmac_drbg_random(&hmac_drbg, buf, BUFSIZE)); -#endif /* MBEDTLS_SHA1_C */ - -#if defined(MBEDTLS_SHA256_C) - md_info = mbedtls_md_info_from_type(MBEDTLS_MD_SHA256); - if (md_info == NULL) { - PRINT_ERROR(ret, "mbedtls_md_info_from_type()"); - goto exit; - } - - ret = mbedtls_hmac_drbg_seed(&hmac_drbg, md_info, myrand, NULL, NULL, 0); - if (ret != 0) { - PRINT_ERROR(ret, "mbedtls_hmac_drbg_seed()"); - goto exit; - } - BENCHMARK_FUNC_CALL("HMAC_DRBG SHA-256 (NOPR)", - mbedtls_hmac_drbg_random(&hmac_drbg, buf, BUFSIZE)); - - ret = mbedtls_hmac_drbg_seed(&hmac_drbg, md_info, myrand, NULL, NULL, 0); - if (ret != 0) { - PRINT_ERROR(ret, "mbedtls_hmac_drbg_seed()"); - goto exit; - } - mbedtls_hmac_drbg_set_prediction_resistance(&hmac_drbg, - MBEDTLS_HMAC_DRBG_PR_ON); - BENCHMARK_FUNC_CALL("HMAC_DRBG SHA-256 (PR)", - mbedtls_hmac_drbg_random(&hmac_drbg, buf, BUFSIZE)); -#endif /* MBEDTLS_SHA256_C */ - - ret = 0; - -exit: - mbedtls_hmac_drbg_free(&hmac_drbg); - - return ret; -} -#endif /* MBEDTLS_HMAC_DRBG_C */ - -#if defined(MBEDTLS_RSA_C) && \ - defined(MBEDTLS_PEM_PARSE_C) && defined(MBEDTLS_PK_PARSE_C) -MBED_NOINLINE static int benchmark_rsa() -{ - int ret = 0; - mbedtls_pk_context pk; - mbedtls_rsa_context *rsa; - const char *rsa_keys[] = { - RSA_PRIVATE_KEY_2048, - }; - size_t i; - - for (i = 0; i < sizeof(rsa_keys) / sizeof(rsa_keys[0]) && ret == 0; i++) { - mbedtls_pk_init(&pk); - - ret = mbedtls_pk_parse_key(&pk, (const unsigned char *)rsa_keys[i], - strlen(rsa_keys[i]) + 1, NULL, 0); - if (ret == MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED) { - /* Do not consider this as a failure */ - mbedtls_printf(HEADER_FORMAT "Feature unsupported\n", title); - ret = 0; - continue; - } else if (ret != 0) { - PRINT_ERROR(ret, "mbedtls_pk_parse_key()"); - goto exit; - } - - rsa = mbedtls_pk_rsa(pk); - - ret = mbedtls_snprintf(title, sizeof(title), "RSA-%d", - mbedtls_pk_get_bitlen(&pk)); - if (ret < 0 || static_cast(ret) >= sizeof(title)) { - mbedtls_printf("Failed to compose title string using " - "mbedtls_snprintf(): %d\n", ret); - goto exit; - } - - BENCHMARK_PUBLIC(title, " public", - buf[0] = 0; - ret = mbedtls_rsa_public(rsa, buf, buf)); - - BENCHMARK_PUBLIC(title, "private", - buf[0] = 0; - ret = mbedtls_rsa_private(rsa, myrand, NULL, buf, - buf)); - -exit: - mbedtls_pk_free(&pk); - } - - return ret; -} -#endif /* MBEDTLS_RSA_C && MBEDTLS_PEM_PARSE_C && MBEDTLS_PK_PARSE_C */ - -#if defined(MBEDTLS_DHM_C) && defined(MBEDTLS_BIGNUM_C) -MBED_NOINLINE static int benchmark_dhm() -{ - int ret = 0; - int dhm_sizes[] = { - 2048, - 3072, - }; - const char *dhm_P[] = { - MBEDTLS_DHM_RFC3526_MODP_2048_P, - MBEDTLS_DHM_RFC3526_MODP_3072_P, - }; - const char *dhm_G[] = { - MBEDTLS_DHM_RFC3526_MODP_2048_G, - MBEDTLS_DHM_RFC3526_MODP_3072_G, - }; - - mbedtls_dhm_context dhm; - size_t olen; - size_t i; - - for (i = 0; - i < sizeof(dhm_sizes) / sizeof(dhm_sizes[0]) && ret == 0; - i++) { - mbedtls_dhm_init(&dhm); - - ret = mbedtls_mpi_read_string(&dhm.P, 16, dhm_P[i]); - if (ret != 0) { - PRINT_ERROR(ret, "mbedtls_mpi_read_string()"); - goto exit; - } - ret = mbedtls_mpi_read_string(&dhm.G, 16, dhm_G[i]); - if (ret != 0) { - PRINT_ERROR(ret, "mbedtls_mpi_read_string()"); - goto exit; - } - - dhm.len = mbedtls_mpi_size(&dhm.P); - ret = mbedtls_dhm_make_public(&dhm, (int) dhm.len, buf, dhm.len, - myrand, NULL); - if (ret == MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED) { - /* Do not consider this as a failure */ - mbedtls_printf(HEADER_FORMAT "Feature unsupported\n", title); - ret = 0; - continue; - } else if (ret != 0) { - PRINT_ERROR(ret, "mbedtls_dhm_make_public()"); - goto exit; - } - - ret = mbedtls_mpi_copy(&dhm.GY, &dhm.GX); - if (ret != 0) { - PRINT_ERROR(ret, "mbedtls_mpi_copy()"); - goto exit; - } - - ret = mbedtls_snprintf(title, sizeof(title), "DHE-%d", dhm_sizes[i]); - if (ret < 0 || static_cast(ret) >= sizeof(title)) { - mbedtls_printf("Failed to compose title string using " - "mbedtls_snprintf(): %d\n", ret); - goto exit; - } - - /* - * Benchmarking this requires two function calls that can fail. We - * add a check in between them to check for any errors. In normal - * operation, the overhead of this check is negligible - */ - BENCHMARK_PUBLIC(title, "handshake", - ret = mbedtls_dhm_make_public(&dhm, (int)dhm.len, - buf, dhm.len, myrand, - NULL); - if (ret != 0) { - PRINT_ERROR(ret, "mbedtls_dhm_make_public()"); - goto exit; - } - ret = mbedtls_dhm_calc_secret(&dhm, buf, sizeof(buf), - &olen, myrand, NULL)); - - ret = mbedtls_snprintf(title, sizeof(title), "DH-%d", dhm_sizes[i]); - if (ret < 0 || static_cast(ret) >= sizeof(title)) { - mbedtls_printf("Failed to compose title string using " - "mbedtls_snprintf(): %d\n", ret); - goto exit; - } - - BENCHMARK_PUBLIC(title, "handshake", - ret = mbedtls_dhm_calc_secret(&dhm, buf, sizeof(buf), - &olen, myrand, NULL)); - -exit: - mbedtls_dhm_free(&dhm); - } - - return ret; -} -#endif /* MBEDTLS_DHM_C && MBEDTLS_BIGNUM_C */ - -#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_SHA256_C) -MBED_NOINLINE static int benchmark_ecdsa() -{ - int ret = 0; - mbedtls_ecdsa_context ecdsa; - const mbedtls_ecp_curve_info *curve_info; - size_t sig_len; - size_t hash_len; - - memset(buf, 0x2A, sizeof(buf)); - - for (curve_info = mbedtls_ecp_curve_list(); - curve_info->grp_id != MBEDTLS_ECP_DP_NONE && ret == 0; - curve_info++) { - mbedtls_ecdsa_init(&ecdsa); - - ret = mbedtls_snprintf(title, sizeof(title), "ECDSA-%s", - curve_info->name); - if (ret < 0 || static_cast(ret) >= sizeof(title)) { - mbedtls_printf("Failed to compose title string using " - "mbedtls_snprintf(): %d\n", ret); - goto exit; - } - - ret = mbedtls_ecdsa_genkey(&ecdsa, curve_info->grp_id, myrand, NULL); - if (ret == MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED) { - /* Do not consider this as a failure */ - mbedtls_printf(HEADER_FORMAT "Feature unsupported\n", title); - ret = 0; - continue; - } else if (ret != 0) { - PRINT_ERROR(ret, "mbedtls_ecdsa_genkey()"); - goto exit; - } - - ecp_clear_precomputed(&ecdsa.grp); - - hash_len = (curve_info->bit_size + 7) / 8; - BENCHMARK_PUBLIC(title, "sign", - ret = mbedtls_ecdsa_write_signature(&ecdsa, - MBEDTLS_MD_SHA256, - buf, hash_len, - tmp, &sig_len, - myrand, NULL)); - - mbedtls_ecdsa_free(&ecdsa); - } - - for (curve_info = mbedtls_ecp_curve_list(); - curve_info->grp_id != MBEDTLS_ECP_DP_NONE && ret == 0; - curve_info++) { - mbedtls_ecdsa_init(&ecdsa); - - ret = mbedtls_ecdsa_genkey(&ecdsa, curve_info->grp_id, myrand, NULL); - if (ret == MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED) { - /* Do not consider this as a failure */ - mbedtls_printf(HEADER_FORMAT "Feature unsupported\n", title); - ret = 0; - continue; - } else if (ret != 0) { - PRINT_ERROR(ret, "mbedtls_ecdsa_genkey()"); - goto exit; - } - - hash_len = (curve_info->bit_size + 7) / 8; - ret = mbedtls_ecdsa_write_signature(&ecdsa, MBEDTLS_MD_SHA256, buf, - hash_len, tmp, &sig_len, myrand, - NULL); - if (ret == MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED) { - /* Do not consider this as a failure */ - mbedtls_printf(HEADER_FORMAT "Feature unsupported\n", title); - ret = 0; - continue; - } else if (ret != 0) { - PRINT_ERROR(ret, "mbedtls_ecdsa_write_signature()"); - goto exit; - } - - ecp_clear_precomputed(&ecdsa.grp); - - ret = mbedtls_snprintf(title, sizeof(title), "ECDSA-%s", - curve_info->name); - if (ret < 0 || static_cast(ret) >= sizeof(title)) { - mbedtls_printf("Failed to compose title string using " - "mbedtls_snprintf(): %d\n", ret); - goto exit; - } - - BENCHMARK_PUBLIC(title, "verify", - ret = mbedtls_ecdsa_read_signature(&ecdsa, buf, - hash_len, tmp, - sig_len)); - -exit: - mbedtls_ecdsa_free(&ecdsa); - } - - return ret; -} -#endif /* MBEDTLS_ECDSA_C && MBEDTLS_SHA2565_C */ - -#if defined(MBEDTLS_ECDH_C) -MBED_NOINLINE static int benchmark_ecdh() -{ - int ret = 0; - mbedtls_ecdh_context ecdh; - const mbedtls_ecp_curve_info *curve_info; - size_t olen; - - for (curve_info = mbedtls_ecp_curve_list(); - curve_info->grp_id != MBEDTLS_ECP_DP_NONE && ret == 0; - curve_info++) { - mbedtls_ecdh_init(&ecdh); - - ret = mbedtls_ecp_group_load(&ecdh.grp, curve_info->grp_id); - if (ret == MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED) { - /* Do not consider this as a failure */ - mbedtls_printf(HEADER_FORMAT "Feature unsupported\n", title); - ret = 0; - continue; - } else if (ret != 0) { - PRINT_ERROR(ret, "mbedtls_ecp_group_load()"); - goto exit; - } - - ret = mbedtls_snprintf(title, sizeof(title), "ECDHE-%s", - curve_info->name); - if (ret < 0 || static_cast(ret) >= sizeof(title)) { - mbedtls_printf("Failed to compose title string using " - "mbedtls_snprintf(): %d\n", ret); - goto exit; - } - - ret = mbedtls_ecdh_make_public(&ecdh, &olen, buf, sizeof(buf), - myrand, NULL); - if (ret == MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED) { - /* Do not consider this as a failure */ - mbedtls_printf(HEADER_FORMAT "Feature unsupported\n", title); - ret = 0; - continue; - } else if (ret != 0) { - PRINT_ERROR(ret, "mbedtls_ecdh_make_public()"); - goto exit; - } - - ret = mbedtls_ecp_copy(&ecdh.Qp, &ecdh.Q); - if (ret == MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED) { - /* Do not consider this as a failure */ - mbedtls_printf(HEADER_FORMAT "Feature unsupported\n", title); - ret = 0; - continue; - } else if (ret != 0) { - PRINT_ERROR(ret, "mbedtls_ecp_copy()"); - goto exit; - } - - ecp_clear_precomputed(&ecdh.grp); - - /* - * Benchmarking this requires two function calls that can fail. We - * add a check in between them to check for any errors. In normal - * operation, the overhead of this check is negligible - */ - BENCHMARK_PUBLIC(title, "handshake", - ret = mbedtls_ecdh_make_public(&ecdh, &olen, buf, - sizeof(buf), myrand, - NULL); - if (ret != 0) { - PRINT_ERROR(ret, "mbedtls_ecdh_make_public()"); - goto exit; - } - ret = mbedtls_ecdh_calc_secret(&ecdh, &olen, buf, - sizeof(buf), myrand, - NULL)); - mbedtls_ecdh_free(&ecdh); - } - - for (curve_info = mbedtls_ecp_curve_list(); - curve_info->grp_id != MBEDTLS_ECP_DP_NONE && ret == 0; - curve_info++) { - mbedtls_ecdh_init(&ecdh); - - ret = mbedtls_ecp_group_load(&ecdh.grp, curve_info->grp_id); - if (ret == MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED) { - /* Do not consider this as a failure */ - mbedtls_printf(HEADER_FORMAT "Feature unsupported\n", title); - ret = 0; - continue; - } else if (ret != 0) { - PRINT_ERROR(ret, "mbedtls_ecp_group_load()"); - goto exit; - } - - ret = mbedtls_snprintf(title, sizeof(title), "ECDH-%s", - curve_info->name); - if (ret < 0 || static_cast(ret) >= sizeof(title)) { - mbedtls_printf("Failed to compose title string using " - "mbedtls_snprintf(): %d\n", ret); - goto exit; - } - - ret = mbedtls_ecdh_make_public(&ecdh, &olen, buf, sizeof(buf), myrand, - NULL); - if (ret == MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED) { - /* Do not consider this as a failure */ - mbedtls_printf(HEADER_FORMAT "Feature unsupported\n", title); - ret = 0; - continue; - } else if (ret != 0) { - PRINT_ERROR(ret, "mbedtls_ecdh_make_public()"); - goto exit; - } - - ret = mbedtls_ecp_copy(&ecdh.Qp, &ecdh.Q); - if (ret == MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED) { - /* Do not consider this as a failure */ - mbedtls_printf(HEADER_FORMAT "Feature unsupported\n", title); - ret = 0; - continue; - } else if (ret != 0) { - PRINT_ERROR(ret, "mbedtls_ecp_copy()"); - goto exit; - } - - ret = mbedtls_ecdh_make_public(&ecdh, &olen, buf, sizeof(buf), myrand, - NULL); - if (ret == MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED) { - /* Do not consider this as a failure */ - mbedtls_printf(HEADER_FORMAT "Feature unsupported\n", title); - ret = 0; - continue; - } else if (ret != 0) { - PRINT_ERROR(ret, "mbedtls_ecdh_make_public()"); - goto exit; - } - - ecp_clear_precomputed(&ecdh.grp); - - BENCHMARK_PUBLIC(title, "handshake", - ret = mbedtls_ecdh_calc_secret(&ecdh, &olen, buf, - sizeof(buf), myrand, - NULL)); - -exit: - mbedtls_ecdh_free(&ecdh); - } - - return ret; -} -#endif /* MBEDTLS_ECDH_C */ - -#if defined(MBEDTLS_ECDH_C) && defined(MBEDTLS_ECP_DP_CURVE25519_ENABLED) -/* Curve25519 needs to be handled separately */ -MBED_NOINLINE static int benchmark_ecdh_curve22519() -{ - int ret = 0; - mbedtls_ecdh_context ecdh; - mbedtls_mpi z; - - mbedtls_ecdh_init(&ecdh); - mbedtls_mpi_init(&z); - - ret = mbedtls_snprintf(title, sizeof(title), "ECDHE-Curve25519"); - if (ret < 0 || static_cast(ret) >= sizeof(title)) { - mbedtls_printf("Failed to compose title string using " - "mbedtls_snprintf(): %d\n", ret); - goto exit; - } - - ret = mbedtls_ecp_group_load(&ecdh.grp, MBEDTLS_ECP_DP_CURVE25519); - if (ret == MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED) { - /* Do not consider this as a failure */ - mbedtls_printf(HEADER_FORMAT "Feature unsupported\n", title); - ret = 0; - goto exit; - } else if (ret != 0) { - PRINT_ERROR(ret, "mbedtls_ecp_group_load()"); - goto exit; - } - - ret = mbedtls_ecdh_gen_public(&ecdh.grp, &ecdh.d, &ecdh.Qp, myrand, - NULL); - if (ret == MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED) { - /* Do not consider this as a failure */ - mbedtls_printf(HEADER_FORMAT "Feature unsupported\n", title); - ret = 0; - goto exit; - } else if (ret != 0) { - PRINT_ERROR(ret, "mbedtls_ecdh_gen_public()"); - goto exit; - } - - /* - * Benchmarking this requires two function calls that can fail. We - * add a check in between them to check for any errors. In normal - * operation, the overhead of this check is negligible - */ - BENCHMARK_PUBLIC(title, "handshake", - ret = mbedtls_ecdh_gen_public(&ecdh.grp, &ecdh.d, - &ecdh.Q, myrand, NULL); - if (ret != 0) { - PRINT_ERROR(ret, "mbedtls_ecdh_make_public()"); - goto exit; - } - ret = mbedtls_ecdh_compute_shared(&ecdh.grp, &z, - &ecdh.Qp, &ecdh.d, - myrand, NULL)); - - mbedtls_ecdh_free(&ecdh); - mbedtls_mpi_free(&z); - - mbedtls_ecdh_init(&ecdh); - mbedtls_mpi_init(&z); - - ret = mbedtls_snprintf(title, sizeof(title), "ECDH-Curve25519"); - if (ret < 0 || static_cast(ret) >= sizeof(title)) { - mbedtls_printf("Failed to compose title string using " - "mbedtls_snprintf(): %d\n", ret); - goto exit; - } - ret = mbedtls_ecp_group_load(&ecdh.grp, MBEDTLS_ECP_DP_CURVE25519); - if (ret == MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED) { - /* Do not consider this as a failure */ - mbedtls_printf(HEADER_FORMAT "Feature unsupported\n", title); - ret = 0; - goto exit; - } else if (ret != 0) { - PRINT_ERROR(ret, "mbedtls_ecp_group_load()"); - goto exit; - } - - ret = mbedtls_ecdh_gen_public(&ecdh.grp, &ecdh.d, &ecdh.Qp, myrand, NULL); - if (ret == MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED) { - /* Do not consider this as a failure */ - mbedtls_printf(HEADER_FORMAT "Feature unsupported\n", title); - ret = 0; - goto exit; - } else if (ret != 0) { - PRINT_ERROR(ret, "mbedtls_ecdh_gen_public()"); - goto exit; - } - - ret = mbedtls_ecdh_gen_public(&ecdh.grp, &ecdh.d, &ecdh.Q, myrand, NULL); - if (ret == MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED) { - /* Do not consider this as a failure */ - mbedtls_printf(HEADER_FORMAT "Feature unsupported\n", title); - ret = 0; - goto exit; - } else if (ret != 0) { - PRINT_ERROR(ret, "mbedtls_ecdh_gen_public()"); - goto exit; - } - - BENCHMARK_PUBLIC(title, "handshake", - ret = mbedtls_ecdh_compute_shared(&ecdh.grp, &z, - &ecdh.Qp, &ecdh.d, - myrand, NULL)); - -exit: - mbedtls_ecdh_free(&ecdh); - mbedtls_mpi_free(&z); - - return ret; -} -#endif /* MBEDTLS_ECDH_C && MBEDTLS_ECP_DP_CURVE25519_ENABLED */ - -int main() -{ - int exit_code = MBEDTLS_EXIT_SUCCESS; - - memset(buf, 0xAA, sizeof(buf)); - memset(tmp, 0xBB, sizeof(tmp)); - - if ((exit_code = mbedtls_platform_setup(NULL)) != 0) { - mbedtls_printf("Platform initialization failed with error %d\r\n", - exit_code); - return MBEDTLS_EXIT_FAILURE; - } - -#if defined(MBEDTLS_MD4_C) - if (benchmark_md4() != 0) { - exit_code = MBEDTLS_EXIT_FAILURE; - } -#endif /* MBEDTLS_MD4_C */ - -#if defined(MBEDTLS_MD5_C) - if (benchmark_md5() != 0) { - exit_code = MBEDTLS_EXIT_FAILURE; - } -#endif /* MBEDTLS_MD5_C */ - -#if defined(MBEDTLS_RIPEMD160_C) - if (benchmark_ripemd160() != 0) { - exit_code = MBEDTLS_EXIT_FAILURE; - } -#endif /* MBEDTLS_RIPEMD160_C */ - -#if defined(MBEDTLS_SHA1_C) - if (benchmark_sha1() != 0) { - exit_code = MBEDTLS_EXIT_FAILURE; - } -#endif /* MBEDTLS_SHA1_C */ - -#if defined(MBEDTLS_SHA256_C) - if (benchmark_sha256() != 0) { - exit_code = MBEDTLS_EXIT_FAILURE; - } -#endif /* MBEDTLS_SHA256_C */ - -#if defined(MBEDTLS_SHA256_C) - if (benchmark_sha512() != 0) { - exit_code = MBEDTLS_EXIT_FAILURE; - } -#endif /* MBEDTLS_SHA512_C */ - -#if defined(MBEDTLS_ARC4_C) - if (benchmark_arc4() != 0) { - exit_code = MBEDTLS_EXIT_FAILURE; - } -#endif /* MBEDTLS_ARC4_C */ - -#if defined(MBEDTLS_DES_C) && defined(MBEDTLS_CIPHER_MODE_CBC) - if (benchmark_des3() != 0) { - exit_code = MBEDTLS_EXIT_FAILURE; - } -#endif /* MBEDTLS_DES_C && MBEDTLS_CIPHER_MODE_CBC */ - -#if defined(MBEDTLS_DES_C) && defined(MBEDTLS_CIPHER_MODE_CBC) - if (benchmark_des() != 0) { - exit_code = MBEDTLS_EXIT_FAILURE; - } -#endif /* MBEDTLS_DES_C && MBEDTLS_CIPHER_MODE_CBC */ - -#if defined(MBEDTLS_DES_C) && defined(MBEDTLS_CIPHER_MODE_CBC) && \ - defined(MBEDTLS_CMAC_C) - if (benchmark_des3_cmac() != 0) { - exit_code = MBEDTLS_EXIT_FAILURE; - } -#endif /* MBEDTLS_DES_C && MBEDTLS_CIPHER_MODE_CBC && MBEDTLS_CMAC_C */ - -#if defined(MBEDTLS_AES_C) && defined(MBEDTLS_CIPHER_MODE_CBC) - if (benchmark_aes_cbc() != 0) { - exit_code = MBEDTLS_EXIT_FAILURE; - } -#endif /* MBEDTLS_AES_C && MBEDTLS_CIPHER_MODE_CBC */ - -#if defined(MBEDTLS_AES_C) && defined(MBEDTLS_CIPHER_MODE_CTR) - if (benchmark_aes_ctr() != 0) { - exit_code = MBEDTLS_EXIT_FAILURE; - } -#endif /* MBEDTLS_AES_C && MBEDTLS_CIPHER_MODE_CTR */ - -#if defined(MBEDTLS_AES_C) && defined(MBEDTLS_GCM_C) - if (benchmark_aes_gcm() != 0) { - exit_code = MBEDTLS_EXIT_FAILURE; - } -#endif /* MBEDTLS_AES_C && MBEDTLS_GCM_C */ - -#if defined(MBEDTLS_AES_C) && defined(MBEDTLS_CCM_C) - if (benchmark_aes_ccm() != 0) { - exit_code = MBEDTLS_EXIT_FAILURE; - } -#endif /* MBEDTLS_AES_C && MBEDTLS_CCM_C */ - -#if defined(MBEDTLS_AES_C) && defined(MBEDTLS_CMAC_C) - if (benchmark_aes_cmac() != 0) { - exit_code = MBEDTLS_EXIT_FAILURE; - } -#endif /* MBEDTLS_AES_C && MBEDTLS_CMAC_C */ - -#if defined(MBEDTLS_CAMELLIA_C) && defined(MBEDTLS_CIPHER_MODE_CBC) - if (benchmark_camellia() != 0) { - exit_code = MBEDTLS_EXIT_FAILURE; - } -#endif /* MBEDTLS_CAMELLIA_C && MBEDTLS_CIPHER_MODE_CBC */ - -#if defined(MBEDTLS_BLOWFISH_C) && defined(MBEDTLS_CIPHER_MODE_CBC) - if (benchmark_blowfish() != 0) { - exit_code = MBEDTLS_EXIT_FAILURE; - } -#endif /* MBEDTLS_BLOWFISH_C && MBEDTLS_CIPHER_MODE_CBC */ - -#if defined(MBEDTLS_HAVEGE_C) - if (benchmark_havege() != 0) { - exit_code = MBEDTLS_EXIT_FAILURE; - } -#endif /* MBEDTLS_HAVEGE_C */ - -#if defined(MBEDTLS_CTR_DRBG_C) - if (benchmark_ctr_drbg() != 0) { - exit_code = MBEDTLS_EXIT_FAILURE; - } -#endif /* MBEDTLS_CTR_DRBG_C */ - -#if defined(MBEDTLS_HMAC_DRBG_C) - if (benchmark_hmac_drbg() != 0) { - exit_code = MBEDTLS_EXIT_FAILURE; - } -#endif /* MBEDTLS_HMAC_DRBG_C */ - -#if defined(MBEDTLS_RSA_C) && \ - defined(MBEDTLS_PEM_PARSE_C) && defined(MBEDTLS_PK_PARSE_C) - if (benchmark_rsa() != 0) { - exit_code = MBEDTLS_EXIT_FAILURE; - } -#endif /* MBEDTLS_RSA_C && MBEDTLS_PEM_PARSE_C && MBEDTLS_PK_PARSE_C */ - -#if defined(MBEDTLS_DHM_C) && defined(MBEDTLS_BIGNUM_C) - if (benchmark_dhm() != 0) { - exit_code = MBEDTLS_EXIT_FAILURE; - } -#endif /* MBEDTLS_DHM_C && MBEDTLS_BIGNUM_C */ - -#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_SHA256_C) - if (benchmark_ecdsa() != 0) { - exit_code = MBEDTLS_EXIT_FAILURE; - } -#endif /* MBEDTLS_ECDSA_C && MBEDTLS_SHA2565_C */ - -#if defined(MBEDTLS_ECDH_C) - if (benchmark_ecdh() != 0) { - exit_code = MBEDTLS_EXIT_FAILURE; - } - -#if defined(MBEDTLS_ECP_DP_CURVE25519_ENABLED) - if (benchmark_ecdh_curve22519() != 0) { - exit_code = MBEDTLS_EXIT_FAILURE; - } -#endif /* MBEDTLS_ECP_DP_CURVE25519_ENABLED */ -#endif /* MBEDTLS_ECDH_C */ - - mbedtls_printf("DONE\n"); - - mbedtls_platform_teardown(NULL); - return exit_code; -} diff --git a/benchmark/mbed_app.json b/benchmark/mbed_app.json index e618845ac..f7ec99bca 100644 --- a/benchmark/mbed_app.json +++ b/benchmark/mbed_app.json @@ -4,7 +4,8 @@ ], "target_overrides": { "*": { - "platform.stdio-convert-newlines": true + "rtos.main-thread-stack-size": 32768, + "platform.stdio-convert-newlines": true } } } diff --git a/benchmark/mbedtls_config.h b/benchmark/mbedtls_config.h index 9a9e337e9..38b774cd5 100644 --- a/benchmark/mbedtls_config.h +++ b/benchmark/mbedtls_config.h @@ -89,6 +89,10 @@ #define MBEDTLS_RSA_C #endif +#if !defined(MBEDTLS_GENPRIME) +#define MBEDTLS_GENPRIME +#endif + #if !defined(MBEDTLS_ECDSA_C) #define MBEDTLS_ECDSA_C #endif @@ -96,3 +100,11 @@ #if !defined(MBEDTLS_ECDH_C) #define MBEDTLS_ECDH_C #endif + +#if !defined(MBEDTLS_TIMING_C) +#define MBEDTLS_TIMING_C +#endif + +#if !defined(MBEDTLS_TIMING_ALT) +#define MBEDTLS_TIMING_ALT +#endif diff --git a/tests/benchmark.log b/tests/benchmark.log index 033de01bc..55c94cf9b 100644 --- a/tests/benchmark.log +++ b/tests/benchmark.log @@ -1,51 +1,62 @@ -\s+MD4\s*:\s*(\d+ KB/s|Feature unsupported) -\s+MD5\s*:\s*(\d+ KB/s|Feature unsupported) -\s+RIPEMD160\s*:\s*(\d+ KB/s|Feature unsupported) -\s+SHA-1\s*:\s*(\d+ KB/s|Feature unsupported) -\s+SHA-256\s*:\s*(\d+ KB/s|Feature unsupported) -\s+SHA-512\s*:\s*(\d+ KB/s|Feature unsupported) -\s+ARC4\s*:\s*(\d+ KB/s|Feature unsupported) -\s+3DES\s*:\s*(\d+ KB/s|Feature unsupported) -\s+DES\s*:\s*(\d+ KB/s|Feature unsupported) -\s+3DES-CMAC\s*:\s*(\d+ KB/s|Feature unsupported) -\s+AES-CBC-128\s*:\s*(\d+ KB/s|Feature unsupported) -\s+AES-CBC-192\s*:\s*(\d+ KB/s|Feature unsupported) -\s+AES-CBC-256\s*:\s*(\d+ KB/s|Feature unsupported) -\s+AES-CTR-128\s*:\s*(\d+ KB/s|Feature unsupported) -\s+AES-CTR-192\s*:\s*(\d+ KB/s|Feature unsupported) -\s+AES-CTR-256\s*:\s*(\d+ KB/s|Feature unsupported) -\s+AES-GCM-128\s*:\s*(\d+ KB/s|Feature unsupported) -\s+AES-GCM-192\s*:\s*(\d+ KB/s|Feature unsupported) -\s+AES-GCM-256\s*:\s*(\d+ KB/s|Feature unsupported) -\s+AES-CCM-128\s*:\s*(\d+ KB/s|Feature unsupported) -\s+AES-CCM-192\s*:\s*(\d+ KB/s|Feature unsupported) -\s+AES-CCM-256\s*:\s*(\d+ KB/s|Feature unsupported) -\s+AES-CMAC-128\s*:\s*(\d+ KB/s|Feature unsupported) -\s+AES-CMAC-192\s*:\s*(\d+ KB/s|Feature unsupported) -\s+AES-CMAC-256\s*:\s*(\d+ KB/s|Feature unsupported) -\s+AES-CMAC-PRF-128\s*:\s*(\d+ KB/s|Feature unsupported) -\s+CAMELLIA-CBC-128\s*:\s*(\d+ KB/s|Feature unsupported) -\s+CAMELLIA-CBC-192\s*:\s*(\d+ KB/s|Feature unsupported) -\s+CAMELLIA-CBC-256\s*:\s*(\d+ KB/s|Feature unsupported) -\s+BLOWFISH-CBC-128\s*:\s*(\d+ KB/s|Feature unsupported) -\s+BLOWFISH-CBC-192\s*:\s*(\d+ KB/s|Feature unsupported) -\s+BLOWFISH-CBC-256\s*:\s*(\d+ KB/s|Feature unsupported) -\s+CTR_DRBG \(NOPR\)\s*:\s*(\d+ KB/s|Feature unsupported) -\s+CTR_DRBG \(PR\)\s*:\s*(\d+ KB/s|Feature unsupported) -\s+HMAC_DRBG SHA-1 \(NOPR\)\s*:\s*(\d+ KB/s|Feature unsupported) -\s+HMAC_DRBG SHA-1 \(PR\)\s*:\s*(\d+ KB/s|Feature unsupported) -\s+HMAC_DRBG SHA-256 \(NOPR\)\s*:\s*(\d+ KB/s|Feature unsupported) -\s+HMAC_DRBG SHA-256 \(PR\)\s*:\s*(\d+ KB/s|Feature unsupported) -\s+RSA-2048\s*:\s*(\d+ ms/ public|Feature unsupported) -\s+RSA-2048\s*:\s*(\d+ ms/private|Feature unsupported) -\s+ECDSA-secp384r1\s*:\s*(\d+ ms/sign|Feature unsupported) -\s+ECDSA-secp256r1\s*:\s*(\d+ ms/sign|Feature unsupported) -\s+ECDSA-secp384r1\s*:\s*(\d+ ms/verify|Feature unsupported) -\s+ECDSA-secp256r1\s*:\s*(\d+ ms/verify|Feature unsupported) -\s+ECDHE-secp384r1\s*:\s*(\d+ ms/handshake|Feature unsupported) -\s+ECDHE-secp256r1\s*:\s*(\d+ ms/handshake|Feature unsupported) -\s+ECDH-secp384r1\s*:\s*(\d+ ms/handshake|Feature unsupported) -\s+ECDH-secp256r1\s*:\s*(\d+ ms/handshake|Feature unsupported) -\s+ECDHE-Curve25519\s*:\s*(\d+ ms/handshake|Feature unsupported) -\s+ECDH-Curve25519\s*:\s*(\d+ ms/handshake|Feature unsupported) -DONE +\s+MD4\s*:\s*\d+ KiB/s,\s*\d+ cycles/byte +\s+MD5\s*:\s*\d+ KiB/s,\s*\d+ cycles/byte +\s+RIPEMD160\s*:\s*\d+ KiB/s,\s*\d+ cycles/byte +\s+SHA-1\s*:\s*\d+ KiB/s,\s*\d+ cycles/byte +\s+SHA-256\s*:\s*\d+ KiB/s,\s*\d+ cycles/byte +\s+SHA-512\s*:\s*\d+ KiB/s,\s*\d+ cycles/byte +\s+ARC4\s*:\s*\d+ KiB/s,\s*\d+ cycles/byte +\s+3DES\s*:\s*\d+ KiB/s,\s*\d+ cycles/byte +\s+DES\s*:\s*\d+ KiB/s,\s*\d+ cycles/byte +\s+3DES-CMAC\s*:\s*\d+ KiB/s,\s*\d+ cycles/byte +\s+AES-CBC-128\s*:\s*\d+ KiB/s,\s*\d+ cycles/byte +\s+AES-CBC-192\s*:\s*\d+ KiB/s,\s*\d+ cycles/byte +\s+AES-CBC-256\s*:\s*\d+ KiB/s,\s*\d+ cycles/byte +\s+AES-GCM-128\s*:\s*\d+ KiB/s,\s*\d+ cycles/byte +\s+AES-GCM-192\s*:\s*\d+ KiB/s,\s*\d+ cycles/byte +\s+AES-GCM-256\s*:\s*\d+ KiB/s,\s*\d+ cycles/byte +\s+AES-CCM-128\s*:\s*\d+ KiB/s,\s*\d+ cycles/byte +\s+AES-CCM-192\s*:\s*\d+ KiB/s,\s*\d+ cycles/byte +\s+AES-CCM-256\s*:\s*\d+ KiB/s,\s*\d+ cycles/byte +\s+ChaCha20-Poly1305\s*:\s*\d+ KiB/s,\s*\d+ cycles/byte +\s+AES-CMAC-128\s*:\s*\d+ KiB/s,\s*\d+ cycles/byte +\s+AES-CMAC-192\s*:\s*\d+ KiB/s,\s*\d+ cycles/byte +\s+AES-CMAC-256\s*:\s*\d+ KiB/s,\s*\d+ cycles/byte +\s+AES-CMAC-PRF-128\s*:\s*\d+ KiB/s,\s*\d+ cycles/byte +\s+CAMELLIA-CBC-128\s*:\s*\d+ KiB/s,\s*\d+ cycles/byte +\s+CAMELLIA-CBC-192\s*:\s*\d+ KiB/s,\s*\d+ cycles/byte +\s+CAMELLIA-CBC-256\s*:\s*\d+ KiB/s,\s*\d+ cycles/byte +\s+ChaCha20\s*:\s*\d+ KiB/s,\s*\d+ cycles/byte +\s+Poly1305\s*:\s*\d+ KiB/s,\s*\d+ cycles/byte +\s+BLOWFISH-CBC-128\s*:\s*\d+ KiB/s,\s*\d+ cycles/byte +\s+BLOWFISH-CBC-192\s*:\s*\d+ KiB/s,\s*\d+ cycles/byte +\s+BLOWFISH-CBC-256\s*:\s*\d+ KiB/s,\s*\d+ cycles/byte +\s+CTR_DRBG \(NOPR\)\s*:\s*\d+ KiB/s,\s*\d+ cycles/byte +\s+CTR_DRBG \(PR\)\s*:\s*\d+ KiB/s,\s*\d+ cycles/byte +\s+HMAC_DRBG SHA-1 \(NOPR\)\s*:\s*\d+ KiB/s,\s*\d+ cycles/byte +\s+HMAC_DRBG SHA-1 \(PR\)\s*:\s*\d+ KiB/s,\s*\d+ cycles/byte +\s+HMAC_DRBG SHA-256 \(NOPR\)\s*:\s*\d+ KiB/s,\s*\d+ cycles/byte +\s+HMAC_DRBG SHA-256 \(PR\)\s*:\s*\d+ KiB/s,\s*\d+ cycles/byte +\s+RSA-2048\s*:\s*\d+\s+public/s +\s+RSA-2048\s*:\s*\d+\s+private/s +\s+RSA-4096\s*:\s*\d+\s+public/s +\s+RSA-4096\s*:\s*\d+\s+private/s +\s+ECDSA-secp384r1\s*:\s*\d+ sign/s +\s+ECDSA-secp256r1\s*:\s*\d+ sign/s +\s+ECDSA-secp384r1\s*:\s*\d+ verify/s +\s+ECDSA-secp256r1\s*:\s*\d+ verify/s +\s+ECDHE-secp384r1\s*:\s*\d+ handshake/s +\s+ECDHE-secp256r1\s*:\s*\d+ handshake/s +\s+ECDHE-x25519\s*:\s*\d+ handshake/s +\s+ECDHE-x448\s*:\s*\d+ handshake/s +\s+ECDHE-Curve25519\s*:\s*\d+ handshake/s +\s+ECDHE-Curve448\s*:\s*\d+ handshake/s +\s+ECDH-secp384r1\s*:\s*\d+ handshake/s +\s+ECDH-secp256r1\s*:\s*\d+ handshake/s +\s+ECDH-x25519\s*:\s*\d+ handshake/s +\s+ECDH-x448\s*:\s*\d+ handshake/s +\s+ECDH-Curve25519\s*:\s*\d+ handshake/s +\s+ECDH-Curve448\s*:\s*\d+ handshake/s +\s+ECDHE-secp384r1\s*:\s*\d+ full handshake/s +\s+ECDHE-secp256r1\s*:\s*\d+ full handshake/s +\s+ECDHE-x25519\s*:\s*\d+ full handshake/s +\s+ECDHE-x448\s*:\s*\d+ full handshake/s