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