1 /*
2 * Benchmark demonstration program
3 *
4 * Copyright The Mbed TLS Contributors
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
20 #define MBEDTLS_ALLOW_PRIVATE_ACCESS
21
22 #include "mbedtls/build_info.h"
23
24 #include "mbedtls/platform.h"
25 #if !defined(MBEDTLS_PLATFORM_C)
26 #include <stdio.h>
27 #include <stdlib.h>
28 #define mbedtls_exit exit
29 #define mbedtls_printf printf
30 #define mbedtls_free free
31 #endif
32
33 #if !defined(MBEDTLS_TIMING_C)
main(void)34 int main( void )
35 {
36 mbedtls_printf("MBEDTLS_TIMING_C not defined.\n");
37 mbedtls_exit( 0 );
38 }
39 #else
40
41 #include <string.h>
42 #include <stdlib.h>
43
44 #include "mbedtls/timing.h"
45
46 #include "mbedtls/md5.h"
47 #include "mbedtls/ripemd160.h"
48 #include "mbedtls/sha1.h"
49 #include "mbedtls/sha256.h"
50 #include "mbedtls/sha512.h"
51
52 #include "mbedtls/des.h"
53 #include "mbedtls/aes.h"
54 #include "mbedtls/aria.h"
55 #include "mbedtls/camellia.h"
56 #include "mbedtls/chacha20.h"
57 #include "mbedtls/gcm.h"
58 #include "mbedtls/ccm.h"
59 #include "mbedtls/chachapoly.h"
60 #include "mbedtls/cmac.h"
61 #include "mbedtls/poly1305.h"
62
63 #include "mbedtls/ctr_drbg.h"
64 #include "mbedtls/hmac_drbg.h"
65
66 #include "mbedtls/rsa.h"
67 #include "mbedtls/dhm.h"
68 #include "mbedtls/ecdsa.h"
69 #include "mbedtls/ecdh.h"
70
71 #include "mbedtls/error.h"
72
73 #ifndef asm
74 #define asm __asm
75 #endif
76
77 #if defined(_WIN32) && !defined(EFIX64) && !defined(EFI32)
78
79 #include <windows.h>
80 #include <process.h>
81
82 struct _hr_time
83 {
84 LARGE_INTEGER start;
85 };
86
87 #else
88
89 #include <unistd.h>
90 #include <sys/types.h>
91 #include <sys/time.h>
92 #include <signal.h>
93 #include <time.h>
94
95 struct _hr_time
96 {
97 struct timeval start;
98 };
99
100 #endif /* _WIN32 && !EFIX64 && !EFI32 */
101
102 #if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C)
103 #include "mbedtls/memory_buffer_alloc.h"
104 #endif
105
106 static void mbedtls_set_alarm( int seconds );
107
108 /*
109 * For heap usage estimates, we need an estimate of the overhead per allocated
110 * block. ptmalloc2/3 (used in gnu libc for instance) uses 2 size_t per block,
111 * so use that as our baseline.
112 */
113 #define MEM_BLOCK_OVERHEAD ( 2 * sizeof( size_t ) )
114
115 /*
116 * Size to use for the alloc buffer if MEMORY_BUFFER_ALLOC_C is defined.
117 */
118 #define HEAP_SIZE (1u << 16) /* 64k */
119
120 #define BUFSIZE 1024
121 #define HEADER_FORMAT " %-24s : "
122 #define TITLE_LEN 25
123
124 #define OPTIONS \
125 "md5, ripemd160, sha1, sha256, sha512,\n" \
126 "des3, des, camellia, chacha20,\n" \
127 "aes_cbc, aes_gcm, aes_ccm, aes_xts, chachapoly,\n" \
128 "aes_cmac, des3_cmac, poly1305\n" \
129 "ctr_drbg, hmac_drbg\n" \
130 "rsa, dhm, ecdsa, ecdh.\n"
131
132 #if defined(MBEDTLS_ERROR_C)
133 #define PRINT_ERROR \
134 mbedtls_strerror( ret, ( char * )tmp, sizeof( tmp ) ); \
135 mbedtls_printf( "FAILED: %s\n", tmp );
136 #else
137 #define PRINT_ERROR \
138 mbedtls_printf( "FAILED: -0x%04x\n", (unsigned int) -ret );
139 #endif
140
141 #define TIME_AND_TSC( TITLE, CODE ) \
142 do { \
143 unsigned long ii, jj, tsc; \
144 int ret = 0; \
145 \
146 mbedtls_printf( HEADER_FORMAT, TITLE ); \
147 fflush( stdout ); \
148 \
149 mbedtls_set_alarm( 1 ); \
150 for( ii = 1; ret == 0 && ! mbedtls_timing_alarmed; ii++ ) \
151 { \
152 ret = CODE; \
153 } \
154 \
155 tsc = mbedtls_timing_hardclock(); \
156 for( jj = 0; ret == 0 && jj < 1024; jj++ ) \
157 { \
158 ret = CODE; \
159 } \
160 \
161 if( ret != 0 ) \
162 { \
163 PRINT_ERROR; \
164 } \
165 else \
166 { \
167 mbedtls_printf( "%9lu KiB/s, %9lu cycles/byte\n", \
168 ii * BUFSIZE / 1024, \
169 ( mbedtls_timing_hardclock() - tsc ) \
170 / ( jj * BUFSIZE ) ); \
171 } \
172 } while( 0 )
173
174 #if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C) && defined(MBEDTLS_MEMORY_DEBUG)
175
176 /* How much space to reserve for the title when printing heap usage results.
177 * Updated manually as the output of the following command:
178 *
179 * sed -n 's/.*[T]IME_PUBLIC.*"\(.*\)",/\1/p' programs/test/benchmark.c |
180 * awk '{print length+2}' | sort -rn | head -n1
181 *
182 * This computes the maximum length of a title +2 (because we appends "/s").
183 * (If the value is too small, the only consequence is poor alignement.) */
184 #define TITLE_SPACE 16
185
186 #define MEMORY_MEASURE_INIT \
187 size_t max_used, max_blocks, max_bytes; \
188 size_t prv_used, prv_blocks; \
189 mbedtls_memory_buffer_alloc_cur_get( &prv_used, &prv_blocks ); \
190 mbedtls_memory_buffer_alloc_max_reset( );
191
192 #define MEMORY_MEASURE_PRINT( title_len ) \
193 mbedtls_memory_buffer_alloc_max_get( &max_used, &max_blocks ); \
194 ii = TITLE_SPACE > (title_len) ? TITLE_SPACE - (title_len) : 1; \
195 while( ii-- ) mbedtls_printf( " " ); \
196 max_used -= prv_used; \
197 max_blocks -= prv_blocks; \
198 max_bytes = max_used + MEM_BLOCK_OVERHEAD * max_blocks; \
199 mbedtls_printf( "%6u heap bytes", (unsigned) max_bytes );
200
201 #else
202 #define MEMORY_MEASURE_INIT
203 #define MEMORY_MEASURE_PRINT( title_len )
204 #endif
205
206 #define TIME_PUBLIC( TITLE, TYPE, CODE ) \
207 do { \
208 unsigned long ii; \
209 int ret; \
210 MEMORY_MEASURE_INIT; \
211 \
212 mbedtls_printf( HEADER_FORMAT, TITLE ); \
213 fflush( stdout ); \
214 mbedtls_set_alarm( 3 ); \
215 \
216 ret = 0; \
217 for( ii = 1; ! mbedtls_timing_alarmed && ! ret ; ii++ ) \
218 { \
219 CODE; \
220 } \
221 \
222 if( ret == MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED ) \
223 { \
224 mbedtls_printf( "Feature Not Supported. Skipping.\n" ); \
225 ret = 0; \
226 } \
227 else if( ret != 0 ) \
228 { \
229 PRINT_ERROR; \
230 } \
231 else \
232 { \
233 mbedtls_printf( "%6lu " TYPE "/s", ii / 3 ); \
234 MEMORY_MEASURE_PRINT( sizeof( TYPE ) + 1 ); \
235 mbedtls_printf( "\n" ); \
236 } \
237 } while( 0 )
238
239 #if !defined(HAVE_HARDCLOCK) && defined(MBEDTLS_HAVE_ASM) && \
240 ( defined(_MSC_VER) && defined(_M_IX86) ) || defined(__WATCOMC__)
241
242 #define HAVE_HARDCLOCK
243
mbedtls_timing_hardclock(void)244 static unsigned long mbedtls_timing_hardclock( void )
245 {
246 unsigned long tsc;
247 __asm rdtsc
248 __asm mov [tsc], eax
249 return( tsc );
250 }
251 #endif /* !HAVE_HARDCLOCK && MBEDTLS_HAVE_ASM &&
252 ( _MSC_VER && _M_IX86 ) || __WATCOMC__ */
253
254 /* some versions of mingw-64 have 32-bit longs even on x84_64 */
255 #if !defined(HAVE_HARDCLOCK) && defined(MBEDTLS_HAVE_ASM) && \
256 defined(__GNUC__) && ( defined(__i386__) || ( \
257 ( defined(__amd64__) || defined( __x86_64__) ) && __SIZEOF_LONG__ == 4 ) )
258
259 #define HAVE_HARDCLOCK
260
mbedtls_timing_hardclock(void)261 static unsigned long mbedtls_timing_hardclock( void )
262 {
263 unsigned long lo, hi;
264 asm volatile( "rdtsc" : "=a" (lo), "=d" (hi) );
265 return( lo );
266 }
267 #endif /* !HAVE_HARDCLOCK && MBEDTLS_HAVE_ASM &&
268 __GNUC__ && __i386__ */
269
270 #if !defined(HAVE_HARDCLOCK) && defined(MBEDTLS_HAVE_ASM) && \
271 defined(__GNUC__) && ( defined(__amd64__) || defined(__x86_64__) )
272
273 #define HAVE_HARDCLOCK
274
mbedtls_timing_hardclock(void)275 static unsigned long mbedtls_timing_hardclock( void )
276 {
277 unsigned long lo, hi;
278 asm volatile( "rdtsc" : "=a" (lo), "=d" (hi) );
279 return( lo | ( hi << 32 ) );
280 }
281 #endif /* !HAVE_HARDCLOCK && MBEDTLS_HAVE_ASM &&
282 __GNUC__ && ( __amd64__ || __x86_64__ ) */
283
284 #if !defined(HAVE_HARDCLOCK) && defined(MBEDTLS_HAVE_ASM) && \
285 defined(__GNUC__) && ( defined(__powerpc__) || defined(__ppc__) )
286
287 #define HAVE_HARDCLOCK
288
mbedtls_timing_hardclock(void)289 static unsigned long mbedtls_timing_hardclock( void )
290 {
291 unsigned long tbl, tbu0, tbu1;
292
293 do
294 {
295 asm volatile( "mftbu %0" : "=r" (tbu0) );
296 asm volatile( "mftb %0" : "=r" (tbl ) );
297 asm volatile( "mftbu %0" : "=r" (tbu1) );
298 }
299 while( tbu0 != tbu1 );
300
301 return( tbl );
302 }
303 #endif /* !HAVE_HARDCLOCK && MBEDTLS_HAVE_ASM &&
304 __GNUC__ && ( __powerpc__ || __ppc__ ) */
305
306 #if !defined(HAVE_HARDCLOCK) && defined(MBEDTLS_HAVE_ASM) && \
307 defined(__GNUC__) && defined(__sparc64__)
308
309 #if defined(__OpenBSD__)
310 #warning OpenBSD does not allow access to tick register using software version instead
311 #else
312 #define HAVE_HARDCLOCK
313
mbedtls_timing_hardclock(void)314 static unsigned long mbedtls_timing_hardclock( void )
315 {
316 unsigned long tick;
317 asm volatile( "rdpr %%tick, %0;" : "=&r" (tick) );
318 return( tick );
319 }
320 #endif /* __OpenBSD__ */
321 #endif /* !HAVE_HARDCLOCK && MBEDTLS_HAVE_ASM &&
322 __GNUC__ && __sparc64__ */
323
324 #if !defined(HAVE_HARDCLOCK) && defined(MBEDTLS_HAVE_ASM) && \
325 defined(__GNUC__) && defined(__sparc__) && !defined(__sparc64__)
326
327 #define HAVE_HARDCLOCK
328
mbedtls_timing_hardclock(void)329 static unsigned long mbedtls_timing_hardclock( void )
330 {
331 unsigned long tick;
332 asm volatile( ".byte 0x83, 0x41, 0x00, 0x00" );
333 asm volatile( "mov %%g1, %0" : "=r" (tick) );
334 return( tick );
335 }
336 #endif /* !HAVE_HARDCLOCK && MBEDTLS_HAVE_ASM &&
337 __GNUC__ && __sparc__ && !__sparc64__ */
338
339 #if !defined(HAVE_HARDCLOCK) && defined(MBEDTLS_HAVE_ASM) && \
340 defined(__GNUC__) && defined(__alpha__)
341
342 #define HAVE_HARDCLOCK
343
mbedtls_timing_hardclock(void)344 static unsigned long mbedtls_timing_hardclock( void )
345 {
346 unsigned long cc;
347 asm volatile( "rpcc %0" : "=r" (cc) );
348 return( cc & 0xFFFFFFFF );
349 }
350 #endif /* !HAVE_HARDCLOCK && MBEDTLS_HAVE_ASM &&
351 __GNUC__ && __alpha__ */
352
353 #if !defined(HAVE_HARDCLOCK) && defined(MBEDTLS_HAVE_ASM) && \
354 defined(__GNUC__) && defined(__ia64__)
355
356 #define HAVE_HARDCLOCK
357
mbedtls_timing_hardclock(void)358 static unsigned long mbedtls_timing_hardclock( void )
359 {
360 unsigned long itc;
361 asm volatile( "mov %0 = ar.itc" : "=r" (itc) );
362 return( itc );
363 }
364 #endif /* !HAVE_HARDCLOCK && MBEDTLS_HAVE_ASM &&
365 __GNUC__ && __ia64__ */
366
367 #if !defined(HAVE_HARDCLOCK) && defined(_MSC_VER) && \
368 !defined(EFIX64) && !defined(EFI32)
369
370 #define HAVE_HARDCLOCK
371
mbedtls_timing_hardclock(void)372 static unsigned long mbedtls_timing_hardclock( void )
373 {
374 LARGE_INTEGER offset;
375
376 QueryPerformanceCounter( &offset );
377
378 return( (unsigned long)( offset.QuadPart ) );
379 }
380 #endif /* !HAVE_HARDCLOCK && _MSC_VER && !EFIX64 && !EFI32 */
381
382 #if !defined(HAVE_HARDCLOCK)
383
384 #define HAVE_HARDCLOCK
385
386 static int hardclock_init = 0;
387 static struct timeval tv_init;
388
mbedtls_timing_hardclock(void)389 static unsigned long mbedtls_timing_hardclock( void )
390 {
391 struct timeval tv_cur;
392
393 if( hardclock_init == 0 )
394 {
395 gettimeofday( &tv_init, NULL );
396 hardclock_init = 1;
397 }
398
399 gettimeofday( &tv_cur, NULL );
400 return( ( tv_cur.tv_sec - tv_init.tv_sec ) * 1000000
401 + ( tv_cur.tv_usec - tv_init.tv_usec ) );
402 }
403 #endif /* !HAVE_HARDCLOCK */
404
405 volatile int mbedtls_timing_alarmed = 0;
406
407 #if defined(_WIN32) && !defined(EFIX64) && !defined(EFI32)
408
409 /* It's OK to use a global because alarm() is supposed to be global anyway */
410 static DWORD alarmMs;
411
TimerProc(void * TimerContext)412 static void TimerProc( void *TimerContext )
413 {
414 (void) TimerContext;
415 Sleep( alarmMs );
416 mbedtls_timing_alarmed = 1;
417 /* _endthread will be called implicitly on return
418 * That ensures execution of thread funcition's epilogue */
419 }
420
mbedtls_set_alarm(int seconds)421 static void mbedtls_set_alarm( int seconds )
422 {
423 if( seconds == 0 )
424 {
425 /* No need to create a thread for this simple case.
426 * Also, this shorcut is more reliable at least on MinGW32 */
427 mbedtls_timing_alarmed = 1;
428 return;
429 }
430
431 mbedtls_timing_alarmed = 0;
432 alarmMs = seconds * 1000;
433 (void) _beginthread( TimerProc, 0, NULL );
434 }
435
436 #else /* _WIN32 && !EFIX64 && !EFI32 */
437
sighandler(int signum)438 static void sighandler( int signum )
439 {
440 mbedtls_timing_alarmed = 1;
441 signal( signum, sighandler );
442 }
443
mbedtls_set_alarm(int seconds)444 static void mbedtls_set_alarm( int seconds )
445 {
446 mbedtls_timing_alarmed = 0;
447 signal( SIGALRM, sighandler );
448 alarm( seconds );
449 if( seconds == 0 )
450 {
451 /* alarm(0) cancelled any previous pending alarm, but the
452 handler won't fire, so raise the flag straight away. */
453 mbedtls_timing_alarmed = 1;
454 }
455 }
456
457 #endif /* _WIN32 && !EFIX64 && !EFI32 */
458
myrand(void * rng_state,unsigned char * output,size_t len)459 static int myrand( void *rng_state, unsigned char *output, size_t len )
460 {
461 size_t use_len;
462 int rnd;
463
464 if( rng_state != NULL )
465 rng_state = NULL;
466
467 while( len > 0 )
468 {
469 use_len = len;
470 if( use_len > sizeof(int) )
471 use_len = sizeof(int);
472
473 rnd = rand();
474 memcpy( output, &rnd, use_len );
475 output += use_len;
476 len -= use_len;
477 }
478
479 return( 0 );
480 }
481
482 #define CHECK_AND_CONTINUE( R ) \
483 { \
484 int CHECK_AND_CONTINUE_ret = ( R ); \
485 if( CHECK_AND_CONTINUE_ret == MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED ) { \
486 mbedtls_printf( "Feature not supported. Skipping.\n" ); \
487 continue; \
488 } \
489 else if( CHECK_AND_CONTINUE_ret != 0 ) { \
490 mbedtls_exit( 1 ); \
491 } \
492 }
493
494 /*
495 * Clear some memory that was used to prepare the context
496 */
497 #if defined(MBEDTLS_ECP_C)
ecp_clear_precomputed(mbedtls_ecp_group * grp)498 void ecp_clear_precomputed( mbedtls_ecp_group *grp )
499 {
500 if( grp->T != NULL
501 #if MBEDTLS_ECP_FIXED_POINT_OPTIM == 1
502 && grp->T_size != 0
503 #endif
504 )
505 {
506 size_t i;
507 for( i = 0; i < grp->T_size; i++ )
508 mbedtls_ecp_point_free( &grp->T[i] );
509 mbedtls_free( grp->T );
510 }
511 grp->T = NULL;
512 grp->T_size = 0;
513 }
514 #else
515 #define ecp_clear_precomputed( g )
516 #endif
517
518 #if defined(MBEDTLS_ECP_C)
set_ecp_curve(const char * string,mbedtls_ecp_curve_info * curve)519 static int set_ecp_curve( const char *string, mbedtls_ecp_curve_info *curve )
520 {
521 const mbedtls_ecp_curve_info *found =
522 mbedtls_ecp_curve_info_from_name( string );
523 if( found != NULL )
524 {
525 *curve = *found;
526 return( 1 );
527 }
528 else
529 return( 0 );
530 }
531 #endif
532
533 unsigned char buf[BUFSIZE];
534
535 typedef struct {
536 char md5, ripemd160, sha1, sha256, sha512,
537 des3, des,
538 aes_cbc, aes_gcm, aes_ccm, aes_xts, chachapoly,
539 aes_cmac, des3_cmac,
540 aria, camellia, chacha20,
541 poly1305,
542 ctr_drbg, hmac_drbg,
543 rsa, dhm, ecdsa, ecdh;
544 } todo_list;
545
546
main(int argc,char * argv[])547 int main( int argc, char *argv[] )
548 {
549 int i;
550 unsigned char tmp[200];
551 char title[TITLE_LEN];
552 todo_list todo;
553 #if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C)
554 unsigned char alloc_buf[HEAP_SIZE] = { 0 };
555 #endif
556 #if defined(MBEDTLS_ECP_C)
557 mbedtls_ecp_curve_info single_curve[2] = {
558 { MBEDTLS_ECP_DP_NONE, 0, 0, NULL },
559 { MBEDTLS_ECP_DP_NONE, 0, 0, NULL },
560 };
561 const mbedtls_ecp_curve_info *curve_list = mbedtls_ecp_curve_list( );
562 #endif
563
564 #if defined(MBEDTLS_ECP_C)
565 (void) curve_list; /* Unused in some configurations where no benchmark uses ECC */
566 #endif
567
568 if( argc <= 1 )
569 {
570 memset( &todo, 1, sizeof( todo ) );
571 }
572 else
573 {
574 memset( &todo, 0, sizeof( todo ) );
575
576 for( i = 1; i < argc; i++ )
577 {
578 if( strcmp( argv[i], "md5" ) == 0 )
579 todo.md5 = 1;
580 else if( strcmp( argv[i], "ripemd160" ) == 0 )
581 todo.ripemd160 = 1;
582 else if( strcmp( argv[i], "sha1" ) == 0 )
583 todo.sha1 = 1;
584 else if( strcmp( argv[i], "sha256" ) == 0 )
585 todo.sha256 = 1;
586 else if( strcmp( argv[i], "sha512" ) == 0 )
587 todo.sha512 = 1;
588 else if( strcmp( argv[i], "des3" ) == 0 )
589 todo.des3 = 1;
590 else if( strcmp( argv[i], "des" ) == 0 )
591 todo.des = 1;
592 else if( strcmp( argv[i], "aes_cbc" ) == 0 )
593 todo.aes_cbc = 1;
594 else if( strcmp( argv[i], "aes_xts" ) == 0 )
595 todo.aes_xts = 1;
596 else if( strcmp( argv[i], "aes_gcm" ) == 0 )
597 todo.aes_gcm = 1;
598 else if( strcmp( argv[i], "aes_ccm" ) == 0 )
599 todo.aes_ccm = 1;
600 else if( strcmp( argv[i], "chachapoly" ) == 0 )
601 todo.chachapoly = 1;
602 else if( strcmp( argv[i], "aes_cmac" ) == 0 )
603 todo.aes_cmac = 1;
604 else if( strcmp( argv[i], "des3_cmac" ) == 0 )
605 todo.des3_cmac = 1;
606 else if( strcmp( argv[i], "aria" ) == 0 )
607 todo.aria = 1;
608 else if( strcmp( argv[i], "camellia" ) == 0 )
609 todo.camellia = 1;
610 else if( strcmp( argv[i], "chacha20" ) == 0 )
611 todo.chacha20 = 1;
612 else if( strcmp( argv[i], "poly1305" ) == 0 )
613 todo.poly1305 = 1;
614 else if( strcmp( argv[i], "ctr_drbg" ) == 0 )
615 todo.ctr_drbg = 1;
616 else if( strcmp( argv[i], "hmac_drbg" ) == 0 )
617 todo.hmac_drbg = 1;
618 else if( strcmp( argv[i], "rsa" ) == 0 )
619 todo.rsa = 1;
620 else if( strcmp( argv[i], "dhm" ) == 0 )
621 todo.dhm = 1;
622 else if( strcmp( argv[i], "ecdsa" ) == 0 )
623 todo.ecdsa = 1;
624 else if( strcmp( argv[i], "ecdh" ) == 0 )
625 todo.ecdh = 1;
626 #if defined(MBEDTLS_ECP_C)
627 else if( set_ecp_curve( argv[i], single_curve ) )
628 curve_list = single_curve;
629 #endif
630 else
631 {
632 mbedtls_printf( "Unrecognized option: %s\n", argv[i] );
633 mbedtls_printf( "Available options: " OPTIONS );
634 }
635 }
636 }
637
638 mbedtls_printf( "\n" );
639
640 #if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C)
641 mbedtls_memory_buffer_alloc_init( alloc_buf, sizeof( alloc_buf ) );
642 #endif
643 memset( buf, 0xAA, sizeof( buf ) );
644 memset( tmp, 0xBB, sizeof( tmp ) );
645
646 #if defined(MBEDTLS_MD5_C)
647 if( todo.md5 )
648 TIME_AND_TSC( "MD5", mbedtls_md5( buf, BUFSIZE, tmp ) );
649 #endif
650
651 #if defined(MBEDTLS_RIPEMD160_C)
652 if( todo.ripemd160 )
653 TIME_AND_TSC( "RIPEMD160", mbedtls_ripemd160( buf, BUFSIZE, tmp ) );
654 #endif
655
656 #if defined(MBEDTLS_SHA1_C)
657 if( todo.sha1 )
658 TIME_AND_TSC( "SHA-1", mbedtls_sha1( buf, BUFSIZE, tmp ) );
659 #endif
660
661 #if defined(MBEDTLS_SHA256_C)
662 if( todo.sha256 )
663 TIME_AND_TSC( "SHA-256", mbedtls_sha256( buf, BUFSIZE, tmp, 0 ) );
664 #endif
665
666 #if defined(MBEDTLS_SHA512_C)
667 if( todo.sha512 )
668 TIME_AND_TSC( "SHA-512", mbedtls_sha512( buf, BUFSIZE, tmp, 0 ) );
669 #endif
670
671 #if defined(MBEDTLS_DES_C)
672 #if defined(MBEDTLS_CIPHER_MODE_CBC)
673 if( todo.des3 )
674 {
675 mbedtls_des3_context des3;
676 mbedtls_des3_init( &des3 );
677 if( mbedtls_des3_set3key_enc( &des3, tmp ) != 0 )
678 mbedtls_exit( 1 );
679 TIME_AND_TSC( "3DES",
680 mbedtls_des3_crypt_cbc( &des3, MBEDTLS_DES_ENCRYPT, BUFSIZE, tmp, buf, buf ) );
681 mbedtls_des3_free( &des3 );
682 }
683
684 if( todo.des )
685 {
686 mbedtls_des_context des;
687 mbedtls_des_init( &des );
688 if( mbedtls_des_setkey_enc( &des, tmp ) != 0 )
689 mbedtls_exit( 1 );
690 TIME_AND_TSC( "DES",
691 mbedtls_des_crypt_cbc( &des, MBEDTLS_DES_ENCRYPT, BUFSIZE, tmp, buf, buf ) );
692 mbedtls_des_free( &des );
693 }
694
695 #endif /* MBEDTLS_CIPHER_MODE_CBC */
696 #if defined(MBEDTLS_CMAC_C)
697 if( todo.des3_cmac )
698 {
699 unsigned char output[8];
700 const mbedtls_cipher_info_t *cipher_info;
701
702 memset( buf, 0, sizeof( buf ) );
703 memset( tmp, 0, sizeof( tmp ) );
704
705 cipher_info = mbedtls_cipher_info_from_type( MBEDTLS_CIPHER_DES_EDE3_ECB );
706
707 TIME_AND_TSC( "3DES-CMAC",
708 mbedtls_cipher_cmac( cipher_info, tmp, 192, buf,
709 BUFSIZE, output ) );
710 }
711 #endif /* MBEDTLS_CMAC_C */
712 #endif /* MBEDTLS_DES_C */
713
714 #if defined(MBEDTLS_AES_C)
715 #if defined(MBEDTLS_CIPHER_MODE_CBC)
716 if( todo.aes_cbc )
717 {
718 int keysize;
719 mbedtls_aes_context aes;
720 mbedtls_aes_init( &aes );
721 for( keysize = 128; keysize <= 256; keysize += 64 )
722 {
723 mbedtls_snprintf( title, sizeof( title ), "AES-CBC-%d", keysize );
724
725 memset( buf, 0, sizeof( buf ) );
726 memset( tmp, 0, sizeof( tmp ) );
727 CHECK_AND_CONTINUE( mbedtls_aes_setkey_enc( &aes, tmp, keysize ) );
728
729 TIME_AND_TSC( title,
730 mbedtls_aes_crypt_cbc( &aes, MBEDTLS_AES_ENCRYPT, BUFSIZE, tmp, buf, buf ) );
731 }
732 mbedtls_aes_free( &aes );
733 }
734 #endif
735 #if defined(MBEDTLS_CIPHER_MODE_XTS)
736 if( todo.aes_xts )
737 {
738 int keysize;
739 mbedtls_aes_xts_context ctx;
740
741 mbedtls_aes_xts_init( &ctx );
742 for( keysize = 128; keysize <= 256; keysize += 128 )
743 {
744 mbedtls_snprintf( title, sizeof( title ), "AES-XTS-%d", keysize );
745
746 memset( buf, 0, sizeof( buf ) );
747 memset( tmp, 0, sizeof( tmp ) );
748 CHECK_AND_CONTINUE( mbedtls_aes_xts_setkey_enc( &ctx, tmp, keysize * 2 ) );
749
750 TIME_AND_TSC( title,
751 mbedtls_aes_crypt_xts( &ctx, MBEDTLS_AES_ENCRYPT, BUFSIZE,
752 tmp, buf, buf ) );
753
754 mbedtls_aes_xts_free( &ctx );
755 }
756 }
757 #endif
758 #if defined(MBEDTLS_GCM_C)
759 if( todo.aes_gcm )
760 {
761 int keysize;
762 mbedtls_gcm_context gcm;
763
764 mbedtls_gcm_init( &gcm );
765 for( keysize = 128; keysize <= 256; keysize += 64 )
766 {
767 mbedtls_snprintf( title, sizeof( title ), "AES-GCM-%d", keysize );
768
769 memset( buf, 0, sizeof( buf ) );
770 memset( tmp, 0, sizeof( tmp ) );
771 mbedtls_gcm_setkey( &gcm, MBEDTLS_CIPHER_ID_AES, tmp, keysize );
772
773 TIME_AND_TSC( title,
774 mbedtls_gcm_crypt_and_tag( &gcm, MBEDTLS_GCM_ENCRYPT, BUFSIZE, tmp,
775 12, NULL, 0, buf, buf, 16, tmp ) );
776
777 mbedtls_gcm_free( &gcm );
778 }
779 }
780 #endif
781 #if defined(MBEDTLS_CCM_C)
782 if( todo.aes_ccm )
783 {
784 int keysize;
785 mbedtls_ccm_context ccm;
786
787 mbedtls_ccm_init( &ccm );
788 for( keysize = 128; keysize <= 256; keysize += 64 )
789 {
790 mbedtls_snprintf( title, sizeof( title ), "AES-CCM-%d", keysize );
791
792 memset( buf, 0, sizeof( buf ) );
793 memset( tmp, 0, sizeof( tmp ) );
794 mbedtls_ccm_setkey( &ccm, MBEDTLS_CIPHER_ID_AES, tmp, keysize );
795
796 TIME_AND_TSC( title,
797 mbedtls_ccm_encrypt_and_tag( &ccm, BUFSIZE, tmp,
798 12, NULL, 0, buf, buf, tmp, 16 ) );
799
800 mbedtls_ccm_free( &ccm );
801 }
802 }
803 #endif
804 #if defined(MBEDTLS_CHACHAPOLY_C)
805 if( todo.chachapoly )
806 {
807 mbedtls_chachapoly_context chachapoly;
808
809 mbedtls_chachapoly_init( &chachapoly );
810 memset( buf, 0, sizeof( buf ) );
811 memset( tmp, 0, sizeof( tmp ) );
812
813 mbedtls_snprintf( title, sizeof( title ), "ChaCha20-Poly1305" );
814
815 mbedtls_chachapoly_setkey( &chachapoly, tmp );
816
817 TIME_AND_TSC( title,
818 mbedtls_chachapoly_encrypt_and_tag( &chachapoly,
819 BUFSIZE, tmp, NULL, 0, buf, buf, tmp ) );
820
821 mbedtls_chachapoly_free( &chachapoly );
822 }
823 #endif
824 #if defined(MBEDTLS_CMAC_C)
825 if( todo.aes_cmac )
826 {
827 unsigned char output[16];
828 const mbedtls_cipher_info_t *cipher_info;
829 mbedtls_cipher_type_t cipher_type;
830 int keysize;
831
832 for( keysize = 128, cipher_type = MBEDTLS_CIPHER_AES_128_ECB;
833 keysize <= 256;
834 keysize += 64, cipher_type++ )
835 {
836 mbedtls_snprintf( title, sizeof( title ), "AES-CMAC-%d", keysize );
837
838 memset( buf, 0, sizeof( buf ) );
839 memset( tmp, 0, sizeof( tmp ) );
840
841 cipher_info = mbedtls_cipher_info_from_type( cipher_type );
842
843 TIME_AND_TSC( title,
844 mbedtls_cipher_cmac( cipher_info, tmp, keysize,
845 buf, BUFSIZE, output ) );
846 }
847
848 memset( buf, 0, sizeof( buf ) );
849 memset( tmp, 0, sizeof( tmp ) );
850 TIME_AND_TSC( "AES-CMAC-PRF-128",
851 mbedtls_aes_cmac_prf_128( tmp, 16, buf, BUFSIZE,
852 output ) );
853 }
854 #endif /* MBEDTLS_CMAC_C */
855 #endif /* MBEDTLS_AES_C */
856
857 #if defined(MBEDTLS_ARIA_C) && defined(MBEDTLS_CIPHER_MODE_CBC)
858 if( todo.aria )
859 {
860 int keysize;
861 mbedtls_aria_context aria;
862 mbedtls_aria_init( &aria );
863 for( keysize = 128; keysize <= 256; keysize += 64 )
864 {
865 mbedtls_snprintf( title, sizeof( title ), "ARIA-CBC-%d", keysize );
866
867 memset( buf, 0, sizeof( buf ) );
868 memset( tmp, 0, sizeof( tmp ) );
869 mbedtls_aria_setkey_enc( &aria, tmp, keysize );
870
871 TIME_AND_TSC( title,
872 mbedtls_aria_crypt_cbc( &aria, MBEDTLS_ARIA_ENCRYPT,
873 BUFSIZE, tmp, buf, buf ) );
874 }
875 mbedtls_aria_free( &aria );
876 }
877 #endif
878
879 #if defined(MBEDTLS_CAMELLIA_C) && defined(MBEDTLS_CIPHER_MODE_CBC)
880 if( todo.camellia )
881 {
882 int keysize;
883 mbedtls_camellia_context camellia;
884 mbedtls_camellia_init( &camellia );
885 for( keysize = 128; keysize <= 256; keysize += 64 )
886 {
887 mbedtls_snprintf( title, sizeof( title ), "CAMELLIA-CBC-%d", keysize );
888
889 memset( buf, 0, sizeof( buf ) );
890 memset( tmp, 0, sizeof( tmp ) );
891 mbedtls_camellia_setkey_enc( &camellia, tmp, keysize );
892
893 TIME_AND_TSC( title,
894 mbedtls_camellia_crypt_cbc( &camellia, MBEDTLS_CAMELLIA_ENCRYPT,
895 BUFSIZE, tmp, buf, buf ) );
896 }
897 mbedtls_camellia_free( &camellia );
898 }
899 #endif
900
901 #if defined(MBEDTLS_CHACHA20_C)
902 if ( todo.chacha20 )
903 {
904 TIME_AND_TSC( "ChaCha20", mbedtls_chacha20_crypt( buf, buf, 0U, BUFSIZE, buf, buf ) );
905 }
906 #endif
907
908 #if defined(MBEDTLS_POLY1305_C)
909 if ( todo.poly1305 )
910 {
911 TIME_AND_TSC( "Poly1305", mbedtls_poly1305_mac( buf, buf, BUFSIZE, buf ) );
912 }
913 #endif
914
915 #if defined(MBEDTLS_CTR_DRBG_C)
916 if( todo.ctr_drbg )
917 {
918 mbedtls_ctr_drbg_context ctr_drbg;
919
920 mbedtls_ctr_drbg_init( &ctr_drbg );
921 if( mbedtls_ctr_drbg_seed( &ctr_drbg, myrand, NULL, NULL, 0 ) != 0 )
922 mbedtls_exit(1);
923 TIME_AND_TSC( "CTR_DRBG (NOPR)",
924 mbedtls_ctr_drbg_random( &ctr_drbg, buf, BUFSIZE ) );
925 mbedtls_ctr_drbg_free( &ctr_drbg );
926
927 mbedtls_ctr_drbg_init( &ctr_drbg );
928 if( mbedtls_ctr_drbg_seed( &ctr_drbg, myrand, NULL, NULL, 0 ) != 0 )
929 mbedtls_exit(1);
930 mbedtls_ctr_drbg_set_prediction_resistance( &ctr_drbg, MBEDTLS_CTR_DRBG_PR_ON );
931 TIME_AND_TSC( "CTR_DRBG (PR)",
932 mbedtls_ctr_drbg_random( &ctr_drbg, buf, BUFSIZE ) );
933 mbedtls_ctr_drbg_free( &ctr_drbg );
934 }
935 #endif
936
937 #if defined(MBEDTLS_HMAC_DRBG_C)
938 if( todo.hmac_drbg )
939 {
940 mbedtls_hmac_drbg_context hmac_drbg;
941 const mbedtls_md_info_t *md_info;
942
943 mbedtls_hmac_drbg_init( &hmac_drbg );
944
945 #if defined(MBEDTLS_SHA1_C)
946 if( ( md_info = mbedtls_md_info_from_type( MBEDTLS_MD_SHA1 ) ) == NULL )
947 mbedtls_exit(1);
948
949 if( mbedtls_hmac_drbg_seed( &hmac_drbg, md_info, myrand, NULL, NULL, 0 ) != 0 )
950 mbedtls_exit(1);
951 TIME_AND_TSC( "HMAC_DRBG SHA-1 (NOPR)",
952 mbedtls_hmac_drbg_random( &hmac_drbg, buf, BUFSIZE ) );
953
954 if( mbedtls_hmac_drbg_seed( &hmac_drbg, md_info, myrand, NULL, NULL, 0 ) != 0 )
955 mbedtls_exit(1);
956 mbedtls_hmac_drbg_set_prediction_resistance( &hmac_drbg,
957 MBEDTLS_HMAC_DRBG_PR_ON );
958 TIME_AND_TSC( "HMAC_DRBG SHA-1 (PR)",
959 mbedtls_hmac_drbg_random( &hmac_drbg, buf, BUFSIZE ) );
960 #endif
961
962 #if defined(MBEDTLS_SHA256_C)
963 if( ( md_info = mbedtls_md_info_from_type( MBEDTLS_MD_SHA256 ) ) == NULL )
964 mbedtls_exit(1);
965
966 if( mbedtls_hmac_drbg_seed( &hmac_drbg, md_info, myrand, NULL, NULL, 0 ) != 0 )
967 mbedtls_exit(1);
968 TIME_AND_TSC( "HMAC_DRBG SHA-256 (NOPR)",
969 mbedtls_hmac_drbg_random( &hmac_drbg, buf, BUFSIZE ) );
970
971 if( mbedtls_hmac_drbg_seed( &hmac_drbg, md_info, myrand, NULL, NULL, 0 ) != 0 )
972 mbedtls_exit(1);
973 mbedtls_hmac_drbg_set_prediction_resistance( &hmac_drbg,
974 MBEDTLS_HMAC_DRBG_PR_ON );
975 TIME_AND_TSC( "HMAC_DRBG SHA-256 (PR)",
976 mbedtls_hmac_drbg_random( &hmac_drbg, buf, BUFSIZE ) );
977 #endif
978 mbedtls_hmac_drbg_free( &hmac_drbg );
979 }
980 #endif
981
982 #if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_GENPRIME)
983 if( todo.rsa )
984 {
985 int keysize;
986 mbedtls_rsa_context rsa;
987 for( keysize = 2048; keysize <= 4096; keysize *= 2 )
988 {
989 mbedtls_snprintf( title, sizeof( title ), "RSA-%d", keysize );
990
991 mbedtls_rsa_init( &rsa );
992 mbedtls_rsa_gen_key( &rsa, myrand, NULL, keysize, 65537 );
993
994 TIME_PUBLIC( title, " public",
995 buf[0] = 0;
996 ret = mbedtls_rsa_public( &rsa, buf, buf ) );
997
998 TIME_PUBLIC( title, "private",
999 buf[0] = 0;
1000 ret = mbedtls_rsa_private( &rsa, myrand, NULL, buf, buf ) );
1001
1002 mbedtls_rsa_free( &rsa );
1003 }
1004 }
1005 #endif
1006
1007 #if defined(MBEDTLS_DHM_C) && defined(MBEDTLS_BIGNUM_C)
1008 if( todo.dhm )
1009 {
1010 int dhm_sizes[] = { 2048, 3072 };
1011 static const unsigned char dhm_P_2048[] =
1012 MBEDTLS_DHM_RFC3526_MODP_2048_P_BIN;
1013 static const unsigned char dhm_P_3072[] =
1014 MBEDTLS_DHM_RFC3526_MODP_3072_P_BIN;
1015 static const unsigned char dhm_G_2048[] =
1016 MBEDTLS_DHM_RFC3526_MODP_2048_G_BIN;
1017 static const unsigned char dhm_G_3072[] =
1018 MBEDTLS_DHM_RFC3526_MODP_3072_G_BIN;
1019
1020 const unsigned char *dhm_P[] = { dhm_P_2048, dhm_P_3072 };
1021 const size_t dhm_P_size[] = { sizeof( dhm_P_2048 ),
1022 sizeof( dhm_P_3072 ) };
1023
1024 const unsigned char *dhm_G[] = { dhm_G_2048, dhm_G_3072 };
1025 const size_t dhm_G_size[] = { sizeof( dhm_G_2048 ),
1026 sizeof( dhm_G_3072 ) };
1027
1028 mbedtls_dhm_context dhm;
1029 size_t olen;
1030 size_t n;
1031 for( i = 0; (size_t) i < sizeof( dhm_sizes ) / sizeof( dhm_sizes[0] ); i++ )
1032 {
1033 mbedtls_dhm_init( &dhm );
1034
1035 if( mbedtls_mpi_read_binary( &dhm.P, dhm_P[i],
1036 dhm_P_size[i] ) != 0 ||
1037 mbedtls_mpi_read_binary( &dhm.G, dhm_G[i],
1038 dhm_G_size[i] ) != 0 )
1039 {
1040 mbedtls_exit( 1 );
1041 }
1042
1043 n = mbedtls_mpi_size( &dhm.P );
1044 mbedtls_dhm_make_public( &dhm, (int) n, buf, n, myrand, NULL );
1045 if( mbedtls_mpi_copy( &dhm.GY, &dhm.GX ) != 0 )
1046 mbedtls_exit( 1 );
1047
1048 mbedtls_snprintf( title, sizeof( title ), "DHE-%d", dhm_sizes[i] );
1049 TIME_PUBLIC( title, "handshake",
1050 ret |= mbedtls_dhm_make_public( &dhm, (int) n, buf, n,
1051 myrand, NULL );
1052 ret |= mbedtls_dhm_calc_secret( &dhm, buf, sizeof( buf ), &olen, myrand, NULL ) );
1053
1054 mbedtls_snprintf( title, sizeof( title ), "DH-%d", dhm_sizes[i] );
1055 TIME_PUBLIC( title, "handshake",
1056 ret |= mbedtls_dhm_calc_secret( &dhm, buf, sizeof( buf ), &olen, myrand, NULL ) );
1057
1058 mbedtls_dhm_free( &dhm );
1059 }
1060 }
1061 #endif
1062
1063 #if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_SHA256_C)
1064 if( todo.ecdsa )
1065 {
1066 mbedtls_ecdsa_context ecdsa;
1067 const mbedtls_ecp_curve_info *curve_info;
1068 size_t sig_len;
1069
1070 memset( buf, 0x2A, sizeof( buf ) );
1071
1072 for( curve_info = curve_list;
1073 curve_info->grp_id != MBEDTLS_ECP_DP_NONE;
1074 curve_info++ )
1075 {
1076 if( ! mbedtls_ecdsa_can_do( curve_info->grp_id ) )
1077 continue;
1078
1079 mbedtls_ecdsa_init( &ecdsa );
1080
1081 if( mbedtls_ecdsa_genkey( &ecdsa, curve_info->grp_id, myrand, NULL ) != 0 )
1082 mbedtls_exit( 1 );
1083 ecp_clear_precomputed( &ecdsa.grp );
1084
1085 mbedtls_snprintf( title, sizeof( title ), "ECDSA-%s",
1086 curve_info->name );
1087 TIME_PUBLIC( title, "sign",
1088 ret = mbedtls_ecdsa_write_signature( &ecdsa, MBEDTLS_MD_SHA256, buf, curve_info->bit_size,
1089 tmp, sizeof( tmp ), &sig_len, myrand, NULL ) );
1090
1091 mbedtls_ecdsa_free( &ecdsa );
1092 }
1093
1094 for( curve_info = curve_list;
1095 curve_info->grp_id != MBEDTLS_ECP_DP_NONE;
1096 curve_info++ )
1097 {
1098 if( ! mbedtls_ecdsa_can_do( curve_info->grp_id ) )
1099 continue;
1100
1101 mbedtls_ecdsa_init( &ecdsa );
1102
1103 if( mbedtls_ecdsa_genkey( &ecdsa, curve_info->grp_id, myrand, NULL ) != 0 ||
1104 mbedtls_ecdsa_write_signature( &ecdsa, MBEDTLS_MD_SHA256, buf, curve_info->bit_size,
1105 tmp, sizeof( tmp ), &sig_len, myrand, NULL ) != 0 )
1106 {
1107 mbedtls_exit( 1 );
1108 }
1109 ecp_clear_precomputed( &ecdsa.grp );
1110
1111 mbedtls_snprintf( title, sizeof( title ), "ECDSA-%s",
1112 curve_info->name );
1113 TIME_PUBLIC( title, "verify",
1114 ret = mbedtls_ecdsa_read_signature( &ecdsa, buf, curve_info->bit_size,
1115 tmp, sig_len ) );
1116
1117 mbedtls_ecdsa_free( &ecdsa );
1118 }
1119 }
1120 #endif
1121
1122 #if defined(MBEDTLS_ECDH_C) && defined(MBEDTLS_ECDH_LEGACY_CONTEXT)
1123 if( todo.ecdh )
1124 {
1125 mbedtls_ecdh_context ecdh;
1126 mbedtls_mpi z;
1127 const mbedtls_ecp_curve_info montgomery_curve_list[] = {
1128 #if defined(MBEDTLS_ECP_DP_CURVE25519_ENABLED)
1129 { MBEDTLS_ECP_DP_CURVE25519, 0, 0, "Curve25519" },
1130 #endif
1131 #if defined(MBEDTLS_ECP_DP_CURVE448_ENABLED)
1132 { MBEDTLS_ECP_DP_CURVE448, 0, 0, "Curve448" },
1133 #endif
1134 { MBEDTLS_ECP_DP_NONE, 0, 0, 0 }
1135 };
1136 const mbedtls_ecp_curve_info *curve_info;
1137 size_t olen;
1138 const mbedtls_ecp_curve_info *selected_montgomery_curve_list =
1139 montgomery_curve_list;
1140
1141 if( curve_list == (const mbedtls_ecp_curve_info*) &single_curve )
1142 {
1143 mbedtls_ecp_group grp;
1144 mbedtls_ecp_group_init( &grp );
1145 if( mbedtls_ecp_group_load( &grp, curve_list->grp_id ) != 0 )
1146 mbedtls_exit( 1 );
1147 if( mbedtls_ecp_get_type( &grp ) == MBEDTLS_ECP_TYPE_MONTGOMERY )
1148 selected_montgomery_curve_list = single_curve;
1149 else /* empty list */
1150 selected_montgomery_curve_list = single_curve + 1;
1151 mbedtls_ecp_group_free( &grp );
1152 }
1153
1154 for( curve_info = curve_list;
1155 curve_info->grp_id != MBEDTLS_ECP_DP_NONE;
1156 curve_info++ )
1157 {
1158 if( ! mbedtls_ecdh_can_do( curve_info->grp_id ) )
1159 continue;
1160
1161 mbedtls_ecdh_init( &ecdh );
1162
1163 CHECK_AND_CONTINUE( mbedtls_ecp_group_load( &ecdh.grp, curve_info->grp_id ) );
1164 CHECK_AND_CONTINUE( mbedtls_ecdh_make_public( &ecdh, &olen, buf, sizeof( buf),
1165 myrand, NULL ) );
1166 CHECK_AND_CONTINUE( mbedtls_ecp_copy( &ecdh.Qp, &ecdh.Q ) );
1167 ecp_clear_precomputed( &ecdh.grp );
1168
1169 mbedtls_snprintf( title, sizeof( title ), "ECDHE-%s",
1170 curve_info->name );
1171 TIME_PUBLIC( title, "handshake",
1172 CHECK_AND_CONTINUE( mbedtls_ecdh_make_public( &ecdh, &olen, buf, sizeof( buf),
1173 myrand, NULL ) );
1174 CHECK_AND_CONTINUE( mbedtls_ecdh_calc_secret( &ecdh, &olen, buf, sizeof( buf ),
1175 myrand, NULL ) ) );
1176 mbedtls_ecdh_free( &ecdh );
1177 }
1178
1179 /* Montgomery curves need to be handled separately */
1180 for ( curve_info = selected_montgomery_curve_list;
1181 curve_info->grp_id != MBEDTLS_ECP_DP_NONE;
1182 curve_info++ )
1183 {
1184 mbedtls_ecdh_init( &ecdh );
1185 mbedtls_mpi_init( &z );
1186
1187 CHECK_AND_CONTINUE( mbedtls_ecp_group_load( &ecdh.grp, curve_info->grp_id ) );
1188 CHECK_AND_CONTINUE( mbedtls_ecdh_gen_public( &ecdh.grp, &ecdh.d, &ecdh.Qp, myrand, NULL ) );
1189
1190 mbedtls_snprintf( title, sizeof(title), "ECDHE-%s",
1191 curve_info->name );
1192 TIME_PUBLIC( title, "handshake",
1193 CHECK_AND_CONTINUE( mbedtls_ecdh_gen_public( &ecdh.grp, &ecdh.d, &ecdh.Q,
1194 myrand, NULL ) );
1195 CHECK_AND_CONTINUE( mbedtls_ecdh_compute_shared( &ecdh.grp, &z, &ecdh.Qp, &ecdh.d,
1196 myrand, NULL ) ) );
1197
1198 mbedtls_ecdh_free( &ecdh );
1199 mbedtls_mpi_free( &z );
1200 }
1201
1202 for( curve_info = curve_list;
1203 curve_info->grp_id != MBEDTLS_ECP_DP_NONE;
1204 curve_info++ )
1205 {
1206 if( ! mbedtls_ecdh_can_do( curve_info->grp_id ) )
1207 continue;
1208
1209 mbedtls_ecdh_init( &ecdh );
1210
1211 CHECK_AND_CONTINUE( mbedtls_ecp_group_load( &ecdh.grp, curve_info->grp_id ) );
1212 CHECK_AND_CONTINUE( mbedtls_ecdh_make_public( &ecdh, &olen, buf, sizeof( buf),
1213 myrand, NULL ) );
1214 CHECK_AND_CONTINUE( mbedtls_ecp_copy( &ecdh.Qp, &ecdh.Q ) );
1215 CHECK_AND_CONTINUE( mbedtls_ecdh_make_public( &ecdh, &olen, buf, sizeof( buf),
1216 myrand, NULL ) );
1217 ecp_clear_precomputed( &ecdh.grp );
1218
1219 mbedtls_snprintf( title, sizeof( title ), "ECDH-%s",
1220 curve_info->name );
1221 TIME_PUBLIC( title, "handshake",
1222 CHECK_AND_CONTINUE( mbedtls_ecdh_calc_secret( &ecdh, &olen, buf, sizeof( buf ),
1223 myrand, NULL ) ) );
1224 mbedtls_ecdh_free( &ecdh );
1225 }
1226
1227 /* Montgomery curves need to be handled separately */
1228 for ( curve_info = selected_montgomery_curve_list;
1229 curve_info->grp_id != MBEDTLS_ECP_DP_NONE;
1230 curve_info++)
1231 {
1232 mbedtls_ecdh_init( &ecdh );
1233 mbedtls_mpi_init( &z );
1234
1235 CHECK_AND_CONTINUE( mbedtls_ecp_group_load( &ecdh.grp, curve_info->grp_id ) );
1236 CHECK_AND_CONTINUE( mbedtls_ecdh_gen_public( &ecdh.grp, &ecdh.d, &ecdh.Qp,
1237 myrand, NULL ) );
1238 CHECK_AND_CONTINUE( mbedtls_ecdh_gen_public( &ecdh.grp, &ecdh.d, &ecdh.Q, myrand, NULL ) );
1239
1240 mbedtls_snprintf( title, sizeof(title), "ECDH-%s",
1241 curve_info->name );
1242 TIME_PUBLIC( title, "handshake",
1243 CHECK_AND_CONTINUE( mbedtls_ecdh_compute_shared( &ecdh.grp, &z, &ecdh.Qp, &ecdh.d,
1244 myrand, NULL ) ) );
1245
1246 mbedtls_ecdh_free( &ecdh );
1247 mbedtls_mpi_free( &z );
1248 }
1249 }
1250 #endif
1251
1252 #if defined(MBEDTLS_ECDH_C)
1253 if( todo.ecdh )
1254 {
1255 mbedtls_ecdh_context ecdh_srv, ecdh_cli;
1256 unsigned char buf_srv[BUFSIZE], buf_cli[BUFSIZE];
1257 const mbedtls_ecp_curve_info *curve_info;
1258 size_t olen;
1259
1260 for( curve_info = curve_list;
1261 curve_info->grp_id != MBEDTLS_ECP_DP_NONE;
1262 curve_info++ )
1263 {
1264 if( ! mbedtls_ecdh_can_do( curve_info->grp_id ) )
1265 continue;
1266
1267 mbedtls_ecdh_init( &ecdh_srv );
1268 mbedtls_ecdh_init( &ecdh_cli );
1269
1270 mbedtls_snprintf( title, sizeof( title ), "ECDHE-%s", curve_info->name );
1271 TIME_PUBLIC( title, "full handshake",
1272 const unsigned char * p_srv = buf_srv;
1273
1274 CHECK_AND_CONTINUE( mbedtls_ecdh_setup( &ecdh_srv, curve_info->grp_id ) );
1275 CHECK_AND_CONTINUE( mbedtls_ecdh_make_params( &ecdh_srv, &olen, buf_srv, sizeof( buf_srv ), myrand, NULL ) );
1276
1277 CHECK_AND_CONTINUE( mbedtls_ecdh_read_params( &ecdh_cli, &p_srv, p_srv + olen ) );
1278 CHECK_AND_CONTINUE( mbedtls_ecdh_make_public( &ecdh_cli, &olen, buf_cli, sizeof( buf_cli ), myrand, NULL ) );
1279
1280 CHECK_AND_CONTINUE( mbedtls_ecdh_read_public( &ecdh_srv, buf_cli, olen ) );
1281 CHECK_AND_CONTINUE( mbedtls_ecdh_calc_secret( &ecdh_srv, &olen, buf_srv, sizeof( buf_srv ), myrand, NULL ) );
1282
1283 CHECK_AND_CONTINUE( mbedtls_ecdh_calc_secret( &ecdh_cli, &olen, buf_cli, sizeof( buf_cli ), myrand, NULL ) );
1284 mbedtls_ecdh_free( &ecdh_cli );
1285
1286 mbedtls_ecdh_free( &ecdh_srv );
1287 );
1288
1289 }
1290 }
1291 #endif
1292
1293 mbedtls_printf( "\n" );
1294
1295 #if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C)
1296 mbedtls_memory_buffer_alloc_free();
1297 #endif
1298
1299 #if defined(_WIN32)
1300 mbedtls_printf( " Press Enter to exit this program.\n" );
1301 fflush( stdout ); getchar();
1302 #endif
1303
1304 mbedtls_exit( 0 );
1305 }
1306
1307 #endif /* MBEDTLS_TIMING_C */
1308