1 /*
2 * Benchmark demonstration program
3 *
4 * Copyright (C) 2006-2016, ARM Limited, All Rights Reserved
5 * SPDX-License-Identifier: Apache-2.0
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License"); you may
8 * not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
15 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 *
19 * This file is part of mbed TLS (https://tls.mbed.org)
20 */
21
22 #if !defined(MBEDTLS_CONFIG_FILE)
23 #include "mbedtls/config.h"
24 #else
25 #include MBEDTLS_CONFIG_FILE
26 #endif
27
28 #if defined(MBEDTLS_PLATFORM_C)
29 #include "mbedtls/platform.h"
30 #else
31 #include <stdio.h>
32 #include <stdlib.h>
33 #define mbedtls_exit exit
34 #define mbedtls_printf printf
35 #define mbedtls_snprintf snprintf
36 #define mbedtls_free free
37 #define mbedtls_exit exit
38 #define MBEDTLS_EXIT_SUCCESS EXIT_SUCCESS
39 #define MBEDTLS_EXIT_FAILURE EXIT_FAILURE
40 #endif
41
42 #if !defined(MBEDTLS_TIMING_C)
main(void)43 int main( void )
44 {
45 mbedtls_printf("MBEDTLS_TIMING_C not defined.\n");
46 return( 0 );
47 }
48 #else
49
50 #include <string.h>
51 #include <stdlib.h>
52
53 #include "mbedtls/timing.h"
54
55 #include "mbedtls/md4.h"
56 #include "mbedtls/md5.h"
57 #include "mbedtls/ripemd160.h"
58 #include "mbedtls/sha1.h"
59 #include "mbedtls/sha256.h"
60 #include "mbedtls/sha512.h"
61
62 #include "mbedtls/arc4.h"
63 #include "mbedtls/des.h"
64 #include "mbedtls/aes.h"
65 #include "mbedtls/aria.h"
66 #include "mbedtls/blowfish.h"
67 #include "mbedtls/camellia.h"
68 #include "mbedtls/chacha20.h"
69 #include "mbedtls/gcm.h"
70 #include "mbedtls/ccm.h"
71 #include "mbedtls/chachapoly.h"
72 #include "mbedtls/cmac.h"
73 #include "mbedtls/poly1305.h"
74
75 #include "mbedtls/havege.h"
76 #include "mbedtls/ctr_drbg.h"
77 #include "mbedtls/hmac_drbg.h"
78
79 #include "mbedtls/rsa.h"
80 #include "mbedtls/dhm.h"
81 #include "mbedtls/ecdsa.h"
82 #include "mbedtls/ecdh.h"
83
84 #include "mbedtls/error.h"
85
86 #if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C)
87 #include "mbedtls/memory_buffer_alloc.h"
88 #endif
89
90 /*
91 * For heap usage estimates, we need an estimate of the overhead per allocated
92 * block. ptmalloc2/3 (used in gnu libc for instance) uses 2 size_t per block,
93 * so use that as our baseline.
94 */
95 #define MEM_BLOCK_OVERHEAD ( 2 * sizeof( size_t ) )
96
97 /*
98 * Size to use for the alloc buffer if MEMORY_BUFFER_ALLOC_C is defined.
99 */
100 #define HEAP_SIZE (1u << 16) // 64k
101
102 #define BUFSIZE 1024
103 #define HEADER_FORMAT " %-24s : "
104 #define TITLE_LEN 25
105
106 #define OPTIONS \
107 "md4, md5, ripemd160, sha1, sha256, sha512,\n" \
108 "arc4, des3, des, camellia, blowfish, chacha20,\n" \
109 "aes_cbc, aes_gcm, aes_ccm, aes_ctx, chachapoly,\n" \
110 "aes_cmac, des3_cmac, poly1305\n" \
111 "havege, ctr_drbg, hmac_drbg\n" \
112 "rsa, dhm, ecdsa, ecdh.\n"
113
114 #if defined(MBEDTLS_ERROR_C)
115 #define PRINT_ERROR \
116 mbedtls_strerror( ret, ( char * )tmp, sizeof( tmp ) ); \
117 mbedtls_printf( "FAILED: %s\n", tmp );
118 #else
119 #define PRINT_ERROR \
120 mbedtls_printf( "FAILED: -0x%04x\n", -ret );
121 #endif
122
123 #define TIME_AND_TSC( TITLE, CODE ) \
124 do { \
125 unsigned long ii, jj, tsc; \
126 int ret = 0; \
127 \
128 mbedtls_printf( HEADER_FORMAT, TITLE ); \
129 fflush( stdout ); \
130 \
131 mbedtls_set_alarm( 1 ); \
132 for( ii = 1; ret == 0 && ! mbedtls_timing_alarmed; ii++ ) \
133 { \
134 ret = CODE; \
135 } \
136 \
137 tsc = mbedtls_timing_hardclock(); \
138 for( jj = 0; ret == 0 && jj < 1024; jj++ ) \
139 { \
140 ret = CODE; \
141 } \
142 \
143 if( ret != 0 ) \
144 { \
145 PRINT_ERROR; \
146 } \
147 else \
148 { \
149 mbedtls_printf( "%9lu KiB/s, %9lu cycles/byte\n", \
150 ii * BUFSIZE / 1024, \
151 ( mbedtls_timing_hardclock() - tsc ) \
152 / ( jj * BUFSIZE ) ); \
153 } \
154 } while( 0 )
155
156 #if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C) && defined(MBEDTLS_MEMORY_DEBUG)
157
158 #define MEMORY_MEASURE_INIT \
159 size_t max_used, max_blocks, max_bytes; \
160 size_t prv_used, prv_blocks; \
161 mbedtls_memory_buffer_alloc_cur_get( &prv_used, &prv_blocks ); \
162 mbedtls_memory_buffer_alloc_max_reset( );
163
164 #define MEMORY_MEASURE_PRINT( title_len ) \
165 mbedtls_memory_buffer_alloc_max_get( &max_used, &max_blocks ); \
166 for( ii = 12 - title_len; ii != 0; ii-- ) mbedtls_printf( " " ); \
167 max_used -= prv_used; \
168 max_blocks -= prv_blocks; \
169 max_bytes = max_used + MEM_BLOCK_OVERHEAD * max_blocks; \
170 mbedtls_printf( "%6u heap bytes", (unsigned) max_bytes );
171
172 #else
173 #define MEMORY_MEASURE_INIT
174 #define MEMORY_MEASURE_PRINT( title_len )
175 #endif
176
177 #define TIME_PUBLIC( TITLE, TYPE, CODE ) \
178 do { \
179 unsigned long ii; \
180 int ret; \
181 MEMORY_MEASURE_INIT; \
182 \
183 mbedtls_printf( HEADER_FORMAT, TITLE ); \
184 fflush( stdout ); \
185 mbedtls_set_alarm( 3 ); \
186 \
187 ret = 0; \
188 for( ii = 1; ! mbedtls_timing_alarmed && ! ret ; ii++ ) \
189 { \
190 CODE; \
191 } \
192 \
193 if( ret != 0 ) \
194 { \
195 PRINT_ERROR; \
196 } \
197 else \
198 { \
199 mbedtls_printf( "%6lu " TYPE "/s", ii / 3 ); \
200 MEMORY_MEASURE_PRINT( sizeof( TYPE ) + 1 ); \
201 mbedtls_printf( "\n" ); \
202 } \
203 } while( 0 )
204
myrand(void * rng_state,unsigned char * output,size_t len)205 static int myrand( void *rng_state, unsigned char *output, size_t len )
206 {
207 size_t use_len;
208 int rnd;
209
210 if( rng_state != NULL )
211 rng_state = NULL;
212
213 while( len > 0 )
214 {
215 use_len = len;
216 if( use_len > sizeof(int) )
217 use_len = sizeof(int);
218
219 rnd = rand();
220 memcpy( output, &rnd, use_len );
221 output += use_len;
222 len -= use_len;
223 }
224
225 return( 0 );
226 }
227
228 /*
229 * Clear some memory that was used to prepare the context
230 */
231 #if defined(MBEDTLS_ECP_C)
ecp_clear_precomputed(mbedtls_ecp_group * grp)232 void ecp_clear_precomputed( mbedtls_ecp_group *grp )
233 {
234 if( grp->T != NULL )
235 {
236 size_t i;
237 for( i = 0; i < grp->T_size; i++ )
238 mbedtls_ecp_point_free( &grp->T[i] );
239 mbedtls_free( grp->T );
240 }
241 grp->T = NULL;
242 grp->T_size = 0;
243 }
244 #else
245 #define ecp_clear_precomputed( g )
246 #endif
247
248 unsigned char buf[BUFSIZE];
249
250 typedef struct {
251 char md4, md5, ripemd160, sha1, sha256, sha512,
252 arc4, des3, des,
253 aes_cbc, aes_gcm, aes_ccm, aes_xts, chachapoly,
254 aes_cmac, des3_cmac,
255 aria, camellia, blowfish, chacha20,
256 poly1305,
257 havege, ctr_drbg, hmac_drbg,
258 rsa, dhm, ecdsa, ecdh;
259 } todo_list;
260
261 #if defined(MBEDTLS_CHECK_PARAMS)
262 #include "mbedtls/platform_util.h"
mbedtls_param_failed(const char * failure_condition,const char * file,int line)263 void mbedtls_param_failed( const char *failure_condition,
264 const char *file,
265 int line )
266 {
267 mbedtls_printf( "%s:%i: Input param failed - %s\n",
268 file, line, failure_condition );
269 mbedtls_exit( MBEDTLS_EXIT_FAILURE );
270 }
271 #endif
272
main(int argc,char * argv[])273 int main( int argc, char *argv[] )
274 {
275 int i;
276 unsigned char tmp[200];
277 char title[TITLE_LEN];
278 todo_list todo;
279 #if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C)
280 unsigned char alloc_buf[HEAP_SIZE] = { 0 };
281 #endif
282
283 if( argc <= 1 )
284 {
285 memset( &todo, 1, sizeof( todo ) );
286 }
287 else
288 {
289 memset( &todo, 0, sizeof( todo ) );
290
291 for( i = 1; i < argc; i++ )
292 {
293 if( strcmp( argv[i], "md4" ) == 0 )
294 todo.md4 = 1;
295 else if( strcmp( argv[i], "md5" ) == 0 )
296 todo.md5 = 1;
297 else if( strcmp( argv[i], "ripemd160" ) == 0 )
298 todo.ripemd160 = 1;
299 else if( strcmp( argv[i], "sha1" ) == 0 )
300 todo.sha1 = 1;
301 else if( strcmp( argv[i], "sha256" ) == 0 )
302 todo.sha256 = 1;
303 else if( strcmp( argv[i], "sha512" ) == 0 )
304 todo.sha512 = 1;
305 else if( strcmp( argv[i], "arc4" ) == 0 )
306 todo.arc4 = 1;
307 else if( strcmp( argv[i], "des3" ) == 0 )
308 todo.des3 = 1;
309 else if( strcmp( argv[i], "des" ) == 0 )
310 todo.des = 1;
311 else if( strcmp( argv[i], "aes_cbc" ) == 0 )
312 todo.aes_cbc = 1;
313 else if( strcmp( argv[i], "aes_xts" ) == 0 )
314 todo.aes_xts = 1;
315 else if( strcmp( argv[i], "aes_gcm" ) == 0 )
316 todo.aes_gcm = 1;
317 else if( strcmp( argv[i], "aes_ccm" ) == 0 )
318 todo.aes_ccm = 1;
319 else if( strcmp( argv[i], "chachapoly" ) == 0 )
320 todo.chachapoly = 1;
321 else if( strcmp( argv[i], "aes_cmac" ) == 0 )
322 todo.aes_cmac = 1;
323 else if( strcmp( argv[i], "des3_cmac" ) == 0 )
324 todo.des3_cmac = 1;
325 else if( strcmp( argv[i], "aria" ) == 0 )
326 todo.aria = 1;
327 else if( strcmp( argv[i], "camellia" ) == 0 )
328 todo.camellia = 1;
329 else if( strcmp( argv[i], "blowfish" ) == 0 )
330 todo.blowfish = 1;
331 else if( strcmp( argv[i], "chacha20" ) == 0 )
332 todo.chacha20 = 1;
333 else if( strcmp( argv[i], "poly1305" ) == 0 )
334 todo.poly1305 = 1;
335 else if( strcmp( argv[i], "havege" ) == 0 )
336 todo.havege = 1;
337 else if( strcmp( argv[i], "ctr_drbg" ) == 0 )
338 todo.ctr_drbg = 1;
339 else if( strcmp( argv[i], "hmac_drbg" ) == 0 )
340 todo.hmac_drbg = 1;
341 else if( strcmp( argv[i], "rsa" ) == 0 )
342 todo.rsa = 1;
343 else if( strcmp( argv[i], "dhm" ) == 0 )
344 todo.dhm = 1;
345 else if( strcmp( argv[i], "ecdsa" ) == 0 )
346 todo.ecdsa = 1;
347 else if( strcmp( argv[i], "ecdh" ) == 0 )
348 todo.ecdh = 1;
349 else
350 {
351 mbedtls_printf( "Unrecognized option: %s\n", argv[i] );
352 mbedtls_printf( "Available options: " OPTIONS );
353 }
354 }
355 }
356
357 mbedtls_printf( "\n" );
358
359 #if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C)
360 mbedtls_memory_buffer_alloc_init( alloc_buf, sizeof( alloc_buf ) );
361 #endif
362 memset( buf, 0xAA, sizeof( buf ) );
363 memset( tmp, 0xBB, sizeof( tmp ) );
364
365 #if defined(MBEDTLS_MD4_C)
366 if( todo.md4 )
367 TIME_AND_TSC( "MD4", mbedtls_md4_ret( buf, BUFSIZE, tmp ) );
368 #endif
369
370 #if defined(MBEDTLS_MD5_C)
371 if( todo.md5 )
372 TIME_AND_TSC( "MD5", mbedtls_md5_ret( buf, BUFSIZE, tmp ) );
373 #endif
374
375 #if defined(MBEDTLS_RIPEMD160_C)
376 if( todo.ripemd160 )
377 TIME_AND_TSC( "RIPEMD160", mbedtls_ripemd160_ret( buf, BUFSIZE, tmp ) );
378 #endif
379
380 #if defined(MBEDTLS_SHA1_C)
381 if( todo.sha1 )
382 TIME_AND_TSC( "SHA-1", mbedtls_sha1_ret( buf, BUFSIZE, tmp ) );
383 #endif
384
385 #if defined(MBEDTLS_SHA256_C)
386 if( todo.sha256 )
387 TIME_AND_TSC( "SHA-256", mbedtls_sha256_ret( buf, BUFSIZE, tmp, 0 ) );
388 #endif
389
390 #if defined(MBEDTLS_SHA512_C)
391 if( todo.sha512 )
392 TIME_AND_TSC( "SHA-512", mbedtls_sha512_ret( buf, BUFSIZE, tmp, 0 ) );
393 #endif
394
395 #if defined(MBEDTLS_ARC4_C)
396 if( todo.arc4 )
397 {
398 mbedtls_arc4_context arc4;
399 mbedtls_arc4_init( &arc4 );
400 mbedtls_arc4_setup( &arc4, tmp, 32 );
401 TIME_AND_TSC( "ARC4", mbedtls_arc4_crypt( &arc4, BUFSIZE, buf, buf ) );
402 mbedtls_arc4_free( &arc4 );
403 }
404 #endif
405
406 #if defined(MBEDTLS_DES_C)
407 #if defined(MBEDTLS_CIPHER_MODE_CBC)
408 if( todo.des3 )
409 {
410 mbedtls_des3_context des3;
411 mbedtls_des3_init( &des3 );
412 mbedtls_des3_set3key_enc( &des3, tmp );
413 TIME_AND_TSC( "3DES",
414 mbedtls_des3_crypt_cbc( &des3, MBEDTLS_DES_ENCRYPT, BUFSIZE, tmp, buf, buf ) );
415 mbedtls_des3_free( &des3 );
416 }
417
418 if( todo.des )
419 {
420 mbedtls_des_context des;
421 mbedtls_des_init( &des );
422 mbedtls_des_setkey_enc( &des, tmp );
423 TIME_AND_TSC( "DES",
424 mbedtls_des_crypt_cbc( &des, MBEDTLS_DES_ENCRYPT, BUFSIZE, tmp, buf, buf ) );
425 mbedtls_des_free( &des );
426 }
427
428 #endif /* MBEDTLS_CIPHER_MODE_CBC */
429 #if defined(MBEDTLS_CMAC_C)
430 if( todo.des3_cmac )
431 {
432 unsigned char output[8];
433 const mbedtls_cipher_info_t *cipher_info;
434
435 memset( buf, 0, sizeof( buf ) );
436 memset( tmp, 0, sizeof( tmp ) );
437
438 cipher_info = mbedtls_cipher_info_from_type( MBEDTLS_CIPHER_DES_EDE3_ECB );
439
440 TIME_AND_TSC( "3DES-CMAC",
441 mbedtls_cipher_cmac( cipher_info, tmp, 192, buf,
442 BUFSIZE, output ) );
443 }
444 #endif /* MBEDTLS_CMAC_C */
445 #endif /* MBEDTLS_DES_C */
446
447 #if defined(MBEDTLS_AES_C)
448 #if defined(MBEDTLS_CIPHER_MODE_CBC)
449 if( todo.aes_cbc )
450 {
451 int keysize;
452 mbedtls_aes_context aes;
453 mbedtls_aes_init( &aes );
454 for( keysize = 128; keysize <= 256; keysize += 64 )
455 {
456 mbedtls_snprintf( title, sizeof( title ), "AES-CBC-%d", keysize );
457
458 memset( buf, 0, sizeof( buf ) );
459 memset( tmp, 0, sizeof( tmp ) );
460 mbedtls_aes_setkey_enc( &aes, tmp, keysize );
461
462 TIME_AND_TSC( title,
463 mbedtls_aes_crypt_cbc( &aes, MBEDTLS_AES_ENCRYPT, BUFSIZE, tmp, buf, buf ) );
464 }
465 mbedtls_aes_free( &aes );
466 }
467 #endif
468 #if defined(MBEDTLS_CIPHER_MODE_XTS)
469 if( todo.aes_xts )
470 {
471 int keysize;
472 mbedtls_aes_xts_context ctx;
473
474 mbedtls_aes_xts_init( &ctx );
475 for( keysize = 128; keysize <= 256; keysize += 128 )
476 {
477 mbedtls_snprintf( title, sizeof( title ), "AES-XTS-%d", keysize );
478
479 memset( buf, 0, sizeof( buf ) );
480 memset( tmp, 0, sizeof( tmp ) );
481 mbedtls_aes_xts_setkey_enc( &ctx, tmp, keysize * 2 );
482
483 TIME_AND_TSC( title,
484 mbedtls_aes_crypt_xts( &ctx, MBEDTLS_AES_ENCRYPT, BUFSIZE,
485 tmp, buf, buf ) );
486
487 mbedtls_aes_xts_free( &ctx );
488 }
489 }
490 #endif
491 #if defined(MBEDTLS_GCM_C)
492 if( todo.aes_gcm )
493 {
494 int keysize;
495 mbedtls_gcm_context gcm;
496
497 mbedtls_gcm_init( &gcm );
498 for( keysize = 128; keysize <= 256; keysize += 64 )
499 {
500 mbedtls_snprintf( title, sizeof( title ), "AES-GCM-%d", keysize );
501
502 memset( buf, 0, sizeof( buf ) );
503 memset( tmp, 0, sizeof( tmp ) );
504 mbedtls_gcm_setkey( &gcm, MBEDTLS_CIPHER_ID_AES, tmp, keysize );
505
506 TIME_AND_TSC( title,
507 mbedtls_gcm_crypt_and_tag( &gcm, MBEDTLS_GCM_ENCRYPT, BUFSIZE, tmp,
508 12, NULL, 0, buf, buf, 16, tmp ) );
509
510 mbedtls_gcm_free( &gcm );
511 }
512 }
513 #endif
514 #if defined(MBEDTLS_CCM_C)
515 if( todo.aes_ccm )
516 {
517 int keysize;
518 mbedtls_ccm_context ccm;
519
520 mbedtls_ccm_init( &ccm );
521 for( keysize = 128; keysize <= 256; keysize += 64 )
522 {
523 mbedtls_snprintf( title, sizeof( title ), "AES-CCM-%d", keysize );
524
525 memset( buf, 0, sizeof( buf ) );
526 memset( tmp, 0, sizeof( tmp ) );
527 mbedtls_ccm_setkey( &ccm, MBEDTLS_CIPHER_ID_AES, tmp, keysize );
528
529 TIME_AND_TSC( title,
530 mbedtls_ccm_encrypt_and_tag( &ccm, BUFSIZE, tmp,
531 12, NULL, 0, buf, buf, tmp, 16 ) );
532
533 mbedtls_ccm_free( &ccm );
534 }
535 }
536 #endif
537 #if defined(MBEDTLS_CHACHAPOLY_C)
538 if( todo.chachapoly )
539 {
540 mbedtls_chachapoly_context chachapoly;
541
542 mbedtls_chachapoly_init( &chachapoly );
543 memset( buf, 0, sizeof( buf ) );
544 memset( tmp, 0, sizeof( tmp ) );
545
546 mbedtls_snprintf( title, sizeof( title ), "ChaCha20-Poly1305" );
547
548 mbedtls_chachapoly_setkey( &chachapoly, tmp );
549
550 TIME_AND_TSC( title,
551 mbedtls_chachapoly_encrypt_and_tag( &chachapoly,
552 BUFSIZE, tmp, NULL, 0, buf, buf, tmp ) );
553
554 mbedtls_chachapoly_free( &chachapoly );
555 }
556 #endif
557 #if defined(MBEDTLS_CMAC_C)
558 if( todo.aes_cmac )
559 {
560 unsigned char output[16];
561 const mbedtls_cipher_info_t *cipher_info;
562 mbedtls_cipher_type_t cipher_type;
563 int keysize;
564
565 for( keysize = 128, cipher_type = MBEDTLS_CIPHER_AES_128_ECB;
566 keysize <= 256;
567 keysize += 64, cipher_type++ )
568 {
569 mbedtls_snprintf( title, sizeof( title ), "AES-CMAC-%d", keysize );
570
571 memset( buf, 0, sizeof( buf ) );
572 memset( tmp, 0, sizeof( tmp ) );
573
574 cipher_info = mbedtls_cipher_info_from_type( cipher_type );
575
576 TIME_AND_TSC( title,
577 mbedtls_cipher_cmac( cipher_info, tmp, keysize,
578 buf, BUFSIZE, output ) );
579 }
580
581 memset( buf, 0, sizeof( buf ) );
582 memset( tmp, 0, sizeof( tmp ) );
583 TIME_AND_TSC( "AES-CMAC-PRF-128",
584 mbedtls_aes_cmac_prf_128( tmp, 16, buf, BUFSIZE,
585 output ) );
586 }
587 #endif /* MBEDTLS_CMAC_C */
588 #endif /* MBEDTLS_AES_C */
589
590 #if defined(MBEDTLS_ARIA_C) && defined(MBEDTLS_CIPHER_MODE_CBC)
591 if( todo.aria )
592 {
593 int keysize;
594 mbedtls_aria_context aria;
595 mbedtls_aria_init( &aria );
596 for( keysize = 128; keysize <= 256; keysize += 64 )
597 {
598 mbedtls_snprintf( title, sizeof( title ), "ARIA-CBC-%d", keysize );
599
600 memset( buf, 0, sizeof( buf ) );
601 memset( tmp, 0, sizeof( tmp ) );
602 mbedtls_aria_setkey_enc( &aria, tmp, keysize );
603
604 TIME_AND_TSC( title,
605 mbedtls_aria_crypt_cbc( &aria, MBEDTLS_ARIA_ENCRYPT,
606 BUFSIZE, tmp, buf, buf ) );
607 }
608 mbedtls_aria_free( &aria );
609 }
610 #endif
611
612 #if defined(MBEDTLS_CAMELLIA_C) && defined(MBEDTLS_CIPHER_MODE_CBC)
613 if( todo.camellia )
614 {
615 int keysize;
616 mbedtls_camellia_context camellia;
617 mbedtls_camellia_init( &camellia );
618 for( keysize = 128; keysize <= 256; keysize += 64 )
619 {
620 mbedtls_snprintf( title, sizeof( title ), "CAMELLIA-CBC-%d", keysize );
621
622 memset( buf, 0, sizeof( buf ) );
623 memset( tmp, 0, sizeof( tmp ) );
624 mbedtls_camellia_setkey_enc( &camellia, tmp, keysize );
625
626 TIME_AND_TSC( title,
627 mbedtls_camellia_crypt_cbc( &camellia, MBEDTLS_CAMELLIA_ENCRYPT,
628 BUFSIZE, tmp, buf, buf ) );
629 }
630 mbedtls_camellia_free( &camellia );
631 }
632 #endif
633
634 #if defined(MBEDTLS_CHACHA20_C)
635 if ( todo.chacha20 )
636 {
637 TIME_AND_TSC( "ChaCha20", mbedtls_chacha20_crypt( buf, buf, 0U, BUFSIZE, buf, buf ) );
638 }
639 #endif
640
641 #if defined(MBEDTLS_POLY1305_C)
642 if ( todo.poly1305 )
643 {
644 TIME_AND_TSC( "Poly1305", mbedtls_poly1305_mac( buf, buf, BUFSIZE, buf ) );
645 }
646 #endif
647
648 #if defined(MBEDTLS_BLOWFISH_C) && defined(MBEDTLS_CIPHER_MODE_CBC)
649 if( todo.blowfish )
650 {
651 int keysize;
652 mbedtls_blowfish_context blowfish;
653 mbedtls_blowfish_init( &blowfish );
654
655 for( keysize = 128; keysize <= 256; keysize += 64 )
656 {
657 mbedtls_snprintf( title, sizeof( title ), "BLOWFISH-CBC-%d", keysize );
658
659 memset( buf, 0, sizeof( buf ) );
660 memset( tmp, 0, sizeof( tmp ) );
661 mbedtls_blowfish_setkey( &blowfish, tmp, keysize );
662
663 TIME_AND_TSC( title,
664 mbedtls_blowfish_crypt_cbc( &blowfish, MBEDTLS_BLOWFISH_ENCRYPT, BUFSIZE,
665 tmp, buf, buf ) );
666 }
667
668 mbedtls_blowfish_free( &blowfish );
669 }
670 #endif
671
672 #if defined(MBEDTLS_HAVEGE_C)
673 if( todo.havege )
674 {
675 mbedtls_havege_state hs;
676 mbedtls_havege_init( &hs );
677 TIME_AND_TSC( "HAVEGE", mbedtls_havege_random( &hs, buf, BUFSIZE ) );
678 mbedtls_havege_free( &hs );
679 }
680 #endif
681
682 #if defined(MBEDTLS_CTR_DRBG_C)
683 if( todo.ctr_drbg )
684 {
685 mbedtls_ctr_drbg_context ctr_drbg;
686
687 mbedtls_ctr_drbg_init( &ctr_drbg );
688
689 if( mbedtls_ctr_drbg_seed( &ctr_drbg, myrand, NULL, NULL, 0 ) != 0 )
690 mbedtls_exit(1);
691 TIME_AND_TSC( "CTR_DRBG (NOPR)",
692 mbedtls_ctr_drbg_random( &ctr_drbg, buf, BUFSIZE ) );
693
694 if( mbedtls_ctr_drbg_seed( &ctr_drbg, myrand, NULL, NULL, 0 ) != 0 )
695 mbedtls_exit(1);
696 mbedtls_ctr_drbg_set_prediction_resistance( &ctr_drbg, MBEDTLS_CTR_DRBG_PR_ON );
697 TIME_AND_TSC( "CTR_DRBG (PR)",
698 mbedtls_ctr_drbg_random( &ctr_drbg, buf, BUFSIZE ) );
699 mbedtls_ctr_drbg_free( &ctr_drbg );
700 }
701 #endif
702
703 #if defined(MBEDTLS_HMAC_DRBG_C)
704 if( todo.hmac_drbg )
705 {
706 mbedtls_hmac_drbg_context hmac_drbg;
707 const mbedtls_md_info_t *md_info;
708
709 mbedtls_hmac_drbg_init( &hmac_drbg );
710
711 #if defined(MBEDTLS_SHA1_C)
712 if( ( md_info = mbedtls_md_info_from_type( MBEDTLS_MD_SHA1 ) ) == NULL )
713 mbedtls_exit(1);
714
715 if( mbedtls_hmac_drbg_seed( &hmac_drbg, md_info, myrand, NULL, NULL, 0 ) != 0 )
716 mbedtls_exit(1);
717 TIME_AND_TSC( "HMAC_DRBG SHA-1 (NOPR)",
718 mbedtls_hmac_drbg_random( &hmac_drbg, buf, BUFSIZE ) );
719
720 if( mbedtls_hmac_drbg_seed( &hmac_drbg, md_info, myrand, NULL, NULL, 0 ) != 0 )
721 mbedtls_exit(1);
722 mbedtls_hmac_drbg_set_prediction_resistance( &hmac_drbg,
723 MBEDTLS_HMAC_DRBG_PR_ON );
724 TIME_AND_TSC( "HMAC_DRBG SHA-1 (PR)",
725 mbedtls_hmac_drbg_random( &hmac_drbg, buf, BUFSIZE ) );
726 #endif
727
728 #if defined(MBEDTLS_SHA256_C)
729 if( ( md_info = mbedtls_md_info_from_type( MBEDTLS_MD_SHA256 ) ) == NULL )
730 mbedtls_exit(1);
731
732 if( mbedtls_hmac_drbg_seed( &hmac_drbg, md_info, myrand, NULL, NULL, 0 ) != 0 )
733 mbedtls_exit(1);
734 TIME_AND_TSC( "HMAC_DRBG SHA-256 (NOPR)",
735 mbedtls_hmac_drbg_random( &hmac_drbg, buf, BUFSIZE ) );
736
737 if( mbedtls_hmac_drbg_seed( &hmac_drbg, md_info, myrand, NULL, NULL, 0 ) != 0 )
738 mbedtls_exit(1);
739 mbedtls_hmac_drbg_set_prediction_resistance( &hmac_drbg,
740 MBEDTLS_HMAC_DRBG_PR_ON );
741 TIME_AND_TSC( "HMAC_DRBG SHA-256 (PR)",
742 mbedtls_hmac_drbg_random( &hmac_drbg, buf, BUFSIZE ) );
743 #endif
744 mbedtls_hmac_drbg_free( &hmac_drbg );
745 }
746 #endif
747
748 #if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_GENPRIME)
749 if( todo.rsa )
750 {
751 int keysize;
752 mbedtls_rsa_context rsa;
753 for( keysize = 2048; keysize <= 4096; keysize *= 2 )
754 {
755 mbedtls_snprintf( title, sizeof( title ), "RSA-%d", keysize );
756
757 mbedtls_rsa_init( &rsa, MBEDTLS_RSA_PKCS_V15, 0 );
758 mbedtls_rsa_gen_key( &rsa, myrand, NULL, keysize, 65537 );
759
760 TIME_PUBLIC( title, " public",
761 buf[0] = 0;
762 ret = mbedtls_rsa_public( &rsa, buf, buf ) );
763
764 TIME_PUBLIC( title, "private",
765 buf[0] = 0;
766 ret = mbedtls_rsa_private( &rsa, myrand, NULL, buf, buf ) );
767
768 mbedtls_rsa_free( &rsa );
769 }
770 }
771 #endif
772
773 #if defined(MBEDTLS_DHM_C) && defined(MBEDTLS_BIGNUM_C)
774 if( todo.dhm )
775 {
776 int dhm_sizes[] = { 2048, 3072 };
777 static const unsigned char dhm_P_2048[] =
778 MBEDTLS_DHM_RFC3526_MODP_2048_P_BIN;
779 static const unsigned char dhm_P_3072[] =
780 MBEDTLS_DHM_RFC3526_MODP_3072_P_BIN;
781 static const unsigned char dhm_G_2048[] =
782 MBEDTLS_DHM_RFC3526_MODP_2048_G_BIN;
783 static const unsigned char dhm_G_3072[] =
784 MBEDTLS_DHM_RFC3526_MODP_3072_G_BIN;
785
786 const unsigned char *dhm_P[] = { dhm_P_2048, dhm_P_3072 };
787 const size_t dhm_P_size[] = { sizeof( dhm_P_2048 ),
788 sizeof( dhm_P_3072 ) };
789
790 const unsigned char *dhm_G[] = { dhm_G_2048, dhm_G_3072 };
791 const size_t dhm_G_size[] = { sizeof( dhm_G_2048 ),
792 sizeof( dhm_G_3072 ) };
793
794 mbedtls_dhm_context dhm;
795 size_t olen;
796 for( i = 0; (size_t) i < sizeof( dhm_sizes ) / sizeof( dhm_sizes[0] ); i++ )
797 {
798 mbedtls_dhm_init( &dhm );
799
800 if( mbedtls_mpi_read_binary( &dhm.P, dhm_P[i],
801 dhm_P_size[i] ) != 0 ||
802 mbedtls_mpi_read_binary( &dhm.G, dhm_G[i],
803 dhm_G_size[i] ) != 0 )
804 {
805 mbedtls_exit( 1 );
806 }
807
808 dhm.len = mbedtls_mpi_size( &dhm.P );
809 mbedtls_dhm_make_public( &dhm, (int) dhm.len, buf, dhm.len, myrand, NULL );
810 if( mbedtls_mpi_copy( &dhm.GY, &dhm.GX ) != 0 )
811 mbedtls_exit( 1 );
812
813 mbedtls_snprintf( title, sizeof( title ), "DHE-%d", dhm_sizes[i] );
814 TIME_PUBLIC( title, "handshake",
815 ret |= mbedtls_dhm_make_public( &dhm, (int) dhm.len, buf, dhm.len,
816 myrand, NULL );
817 ret |= mbedtls_dhm_calc_secret( &dhm, buf, sizeof( buf ), &olen, myrand, NULL ) );
818
819 mbedtls_snprintf( title, sizeof( title ), "DH-%d", dhm_sizes[i] );
820 TIME_PUBLIC( title, "handshake",
821 ret |= mbedtls_dhm_calc_secret( &dhm, buf, sizeof( buf ), &olen, myrand, NULL ) );
822
823 mbedtls_dhm_free( &dhm );
824 }
825 }
826 #endif
827
828 #if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_SHA256_C)
829 if( todo.ecdsa )
830 {
831 mbedtls_ecdsa_context ecdsa;
832 const mbedtls_ecp_curve_info *curve_info;
833 size_t sig_len;
834
835 memset( buf, 0x2A, sizeof( buf ) );
836
837 for( curve_info = mbedtls_ecp_curve_list();
838 curve_info->grp_id != MBEDTLS_ECP_DP_NONE;
839 curve_info++ )
840 {
841 mbedtls_ecdsa_init( &ecdsa );
842
843 if( mbedtls_ecdsa_genkey( &ecdsa, curve_info->grp_id, myrand, NULL ) != 0 )
844 mbedtls_exit( 1 );
845 ecp_clear_precomputed( &ecdsa.grp );
846
847 mbedtls_snprintf( title, sizeof( title ), "ECDSA-%s",
848 curve_info->name );
849 TIME_PUBLIC( title, "sign",
850 ret = mbedtls_ecdsa_write_signature( &ecdsa, MBEDTLS_MD_SHA256, buf, curve_info->bit_size,
851 tmp, &sig_len, myrand, NULL ) );
852
853 mbedtls_ecdsa_free( &ecdsa );
854 }
855
856 for( curve_info = mbedtls_ecp_curve_list();
857 curve_info->grp_id != MBEDTLS_ECP_DP_NONE;
858 curve_info++ )
859 {
860 mbedtls_ecdsa_init( &ecdsa );
861
862 if( mbedtls_ecdsa_genkey( &ecdsa, curve_info->grp_id, myrand, NULL ) != 0 ||
863 mbedtls_ecdsa_write_signature( &ecdsa, MBEDTLS_MD_SHA256, buf, curve_info->bit_size,
864 tmp, &sig_len, myrand, NULL ) != 0 )
865 {
866 mbedtls_exit( 1 );
867 }
868 ecp_clear_precomputed( &ecdsa.grp );
869
870 mbedtls_snprintf( title, sizeof( title ), "ECDSA-%s",
871 curve_info->name );
872 TIME_PUBLIC( title, "verify",
873 ret = mbedtls_ecdsa_read_signature( &ecdsa, buf, curve_info->bit_size,
874 tmp, sig_len ) );
875
876 mbedtls_ecdsa_free( &ecdsa );
877 }
878 }
879 #endif
880
881 #if defined(MBEDTLS_ECDH_C) && defined(MBEDTLS_ECDH_LEGACY_CONTEXT)
882 if( todo.ecdh )
883 {
884 mbedtls_ecdh_context ecdh;
885 mbedtls_mpi z;
886 const mbedtls_ecp_curve_info montgomery_curve_list[] = {
887 #if defined(MBEDTLS_ECP_DP_CURVE25519_ENABLED)
888 { MBEDTLS_ECP_DP_CURVE25519, 0, 0, "Curve25519" },
889 #endif
890 #if defined(MBEDTLS_ECP_DP_CURVE448_ENABLED)
891 { MBEDTLS_ECP_DP_CURVE448, 0, 0, "Curve448" },
892 #endif
893 { MBEDTLS_ECP_DP_NONE, 0, 0, 0 }
894 };
895 const mbedtls_ecp_curve_info *curve_info;
896 size_t olen;
897
898 for( curve_info = mbedtls_ecp_curve_list();
899 curve_info->grp_id != MBEDTLS_ECP_DP_NONE;
900 curve_info++ )
901 {
902 mbedtls_ecdh_init( &ecdh );
903
904 if( mbedtls_ecp_group_load( &ecdh.grp, curve_info->grp_id ) != 0 ||
905 mbedtls_ecdh_make_public( &ecdh, &olen, buf, sizeof( buf),
906 myrand, NULL ) != 0 ||
907 mbedtls_ecp_copy( &ecdh.Qp, &ecdh.Q ) != 0 )
908 {
909 mbedtls_exit( 1 );
910 }
911 ecp_clear_precomputed( &ecdh.grp );
912
913 mbedtls_snprintf( title, sizeof( title ), "ECDHE-%s",
914 curve_info->name );
915 TIME_PUBLIC( title, "handshake",
916 ret |= mbedtls_ecdh_make_public( &ecdh, &olen, buf, sizeof( buf),
917 myrand, NULL );
918 ret |= mbedtls_ecdh_calc_secret( &ecdh, &olen, buf, sizeof( buf ),
919 myrand, NULL ) );
920 mbedtls_ecdh_free( &ecdh );
921 }
922
923 /* Montgomery curves need to be handled separately */
924 for ( curve_info = montgomery_curve_list;
925 curve_info->grp_id != MBEDTLS_ECP_DP_NONE;
926 curve_info++ )
927 {
928 mbedtls_ecdh_init( &ecdh );
929 mbedtls_mpi_init( &z );
930
931 if( mbedtls_ecp_group_load( &ecdh.grp, curve_info->grp_id ) != 0 ||
932 mbedtls_ecdh_gen_public( &ecdh.grp, &ecdh.d, &ecdh.Qp, myrand, NULL ) != 0 )
933 {
934 mbedtls_exit( 1 );
935 }
936
937 mbedtls_snprintf( title, sizeof(title), "ECDHE-%s",
938 curve_info->name );
939 TIME_PUBLIC( title, "handshake",
940 ret |= mbedtls_ecdh_gen_public( &ecdh.grp, &ecdh.d, &ecdh.Q,
941 myrand, NULL );
942 ret |= mbedtls_ecdh_compute_shared( &ecdh.grp, &z, &ecdh.Qp, &ecdh.d,
943 myrand, NULL ) );
944
945 mbedtls_ecdh_free( &ecdh );
946 mbedtls_mpi_free( &z );
947 }
948
949 for( curve_info = mbedtls_ecp_curve_list();
950 curve_info->grp_id != MBEDTLS_ECP_DP_NONE;
951 curve_info++ )
952 {
953 mbedtls_ecdh_init( &ecdh );
954
955 if( mbedtls_ecp_group_load( &ecdh.grp, curve_info->grp_id ) != 0 ||
956 mbedtls_ecdh_make_public( &ecdh, &olen, buf, sizeof( buf),
957 myrand, NULL ) != 0 ||
958 mbedtls_ecp_copy( &ecdh.Qp, &ecdh.Q ) != 0 ||
959 mbedtls_ecdh_make_public( &ecdh, &olen, buf, sizeof( buf),
960 myrand, NULL ) != 0 )
961 {
962 mbedtls_exit( 1 );
963 }
964 ecp_clear_precomputed( &ecdh.grp );
965
966 mbedtls_snprintf( title, sizeof( title ), "ECDH-%s",
967 curve_info->name );
968 TIME_PUBLIC( title, "handshake",
969 ret |= mbedtls_ecdh_calc_secret( &ecdh, &olen, buf, sizeof( buf ),
970 myrand, NULL ) );
971 mbedtls_ecdh_free( &ecdh );
972 }
973
974 /* Montgomery curves need to be handled separately */
975 for ( curve_info = montgomery_curve_list;
976 curve_info->grp_id != MBEDTLS_ECP_DP_NONE;
977 curve_info++)
978 {
979 mbedtls_ecdh_init( &ecdh );
980 mbedtls_mpi_init( &z );
981
982 if( mbedtls_ecp_group_load( &ecdh.grp, curve_info->grp_id ) != 0 ||
983 mbedtls_ecdh_gen_public( &ecdh.grp, &ecdh.d, &ecdh.Qp,
984 myrand, NULL ) != 0 ||
985 mbedtls_ecdh_gen_public( &ecdh.grp, &ecdh.d, &ecdh.Q, myrand, NULL ) != 0 )
986 {
987 mbedtls_exit( 1 );
988 }
989
990 mbedtls_snprintf( title, sizeof(title), "ECDH-%s",
991 curve_info->name );
992 TIME_PUBLIC( title, "handshake",
993 ret |= mbedtls_ecdh_compute_shared( &ecdh.grp, &z, &ecdh.Qp, &ecdh.d,
994 myrand, NULL ) );
995
996 mbedtls_ecdh_free( &ecdh );
997 mbedtls_mpi_free( &z );
998 }
999 }
1000 #endif
1001
1002 mbedtls_printf( "\n" );
1003
1004 #if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C)
1005 mbedtls_memory_buffer_alloc_free();
1006 #endif
1007
1008 #if defined(_WIN32)
1009 mbedtls_printf( " Press Enter to exit this program.\n" );
1010 fflush( stdout ); getchar();
1011 #endif
1012
1013 return( 0 );
1014 }
1015
1016 #endif /* MBEDTLS_TIMING_C */
1017