TrustedFirmware Git Browser
Code Review Sign In
review.trustedfirmware.org / mirror / mbed-tls / f9c599cd8ac9d00c484d4f5b027e18c6af4f9fdf / . / yotta / data / example-benchmark / main.cpp
blob: 23c87b6c3bd3b9a963dc45cffd0f1d089f1cdbda [file] [log] [blame]
Manuel Pégourié-Gonnard63e7eba2015-07-28 14:17:48 +0200[diff] [blame]1/*
2 * Benchmark demonstration program
3 *
4 * Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
5 *
6 * This file is part of mbed TLS (https://tls.mbed.org)
Manuel Pégourié-Gonnardcdee2d92015-08-07 09:40:51 +0200[diff] [blame]7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License along
19 * with this program; if not, write to the Free Software Foundation, Inc.,
20 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
Manuel Pégourié-Gonnard63e7eba2015-07-28 14:17:48 +0200[diff] [blame]21 */
22
23#if !defined(TARGET_LIKE_MBED)
24
25#include <stdio.h>
26
27int main() {
28 printf("this version of this program only works on mbed OS\n");
29 return 0;
30}
31
32#else
33
34#if !defined(MBEDTLS_CONFIG_FILE)
35#include "mbedtls/config.h"
36#else
37#include MBEDTLS_CONFIG_FILE
38#endif
39
40#if defined(MBEDTLS_PLATFORM_C)
41#include "mbedtls/platform.h"
42#else
43#include <stdio.h>
44#define mbedtls_exit exit
45#define mbedtls_printf printf
46#define mbedtls_snprintf snprintf
47#define mbedtls_free free
48#endif
49
50#include <string.h>
51
52#include "mbedtls/md4.h"
53#include "mbedtls/md5.h"
54#include "mbedtls/ripemd160.h"
55#include "mbedtls/sha1.h"
56#include "mbedtls/sha256.h"
57#include "mbedtls/sha512.h"
58#include "mbedtls/arc4.h"
59#include "mbedtls/des.h"
60#include "mbedtls/aes.h"
61#include "mbedtls/blowfish.h"
62#include "mbedtls/camellia.h"
63#include "mbedtls/gcm.h"
64#include "mbedtls/ccm.h"
65#include "mbedtls/havege.h"
66#include "mbedtls/ctr_drbg.h"
67#include "mbedtls/hmac_drbg.h"
68#include "mbedtls/rsa.h"
69#include "mbedtls/pk.h"
70#include "mbedtls/dhm.h"
71#include "mbedtls/ecdsa.h"
72#include "mbedtls/ecdh.h"
73#include "mbedtls/error.h"
74
75#include "mbed.h"
76
77#if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C)
78#include "mbedtls/memory_buffer_alloc.h"
79#endif
80
81#define RSA_PRIVATE_KEY_2048 \
82"-----BEGIN RSA PRIVATE KEY-----\r\n" \
83"MIIEogIBAAKCAQEA2dwVr+IMGEtA2/MCP6fA5eb/6B18Bq6e7gw8brNPkm3E6LyR\r\n" \
84"4DnMJVxZmw3bPDKBDoKzfntkMESi/Yw5UopLtVfjGfWeQWPClqffLZBsZ60BRAsg\r\n" \
85"/g+ID5tgzxSuxzftypK59uexOVCAm7hCKZHGO3DbI7bLY27j7VAgEP7d/yuaz5Fx\r\n" \
86"Kl/vu7shqrBoz6ABJVJD3KC8nUiMRUCXRINmxbyUUjA4DnicZv6+xrGKr36r6M8h\r\n" \
87"VYLa5msKc8WzbnBWzpUsrpb4/r7ML+qp92gdSfVJ8/bLiU7h2C7faDA59uaqrFK9\r\n" \
88"xmDdx7FaWhGQs3LWW6w1UNgkPS0FDYUslpsnsQIDAQABAoIBAC7IJNwM5V3+IuJY\r\n" \
89"T35Nzo1PyloUosJokvY5KGz5Ejg2XBdCDu0gXCcVqqQyGIbXrYDpLhQV+RCoXHun\r\n" \
90"tdN0oQdC5SB47s/J1Uo2qCUHo0+sBd6PqTkFKsl3KxWssk9TQjvCwC412IefMs69\r\n" \
91"hW+ZvwCanmQP56LleApIr2oW4KLfW8Ry/QfZlua+dizctdN7+H1mWwgZQTY9T27J\r\n" \
92"6RtGRA5NVkKVPzIHVJfdpKoO7xGg1g06aEbPB/VmGvZaaFWWnaf7uRvFjLZecBLu\r\n" \
93"QSx2DA/GDjirlDYj99PJb7DtB4xRtKzsyw0o+xapC8w6OtIl/3xFt9moCu2jGrsx\r\n" \
94"vpjHdfECgYEA7fSACRseIs9gAIVX8wq6gayTpA47DHYWAD6IQfIj35SJ+AgsvbFF\r\n" \
95"4AmrwDhcJVPmDy1N4nLBfyGAMt/2CfiYkdkW6QFX/ULRMMBL/G7kWV8hYQDICB2g\r\n" \
96"xaMRN1lPCmFq6BkSWjwIYTnYDFBDWVm1GVT8TMtJoM8Erej9qC0PeFUCgYEA6mF3\r\n" \
97"bigO3t8f5sig+XepaftEUbkJMzo72TVRnIR2ycdR2ihelPQ+25g9dwV0ZA5XXhBS\r\n" \
98"DKOABWjMM739Mwmy9v26Dlmu9R01zHQktMvtEAyfz7lk2NF0aMuj8285OJUBf9bz\r\n" \
99"Cq3MjtMCD+4CZ6iaEqCdUKOuxfpx5cWVJV+qve0CgYBhD1YaYMFOGaBjFgDl1f51\r\n" \
100"Xltqk5NqZdBbkSYrIAWZ8RDF5y+4wFJsLAWuhk6vuyUgE66tK3nZzWRpXAkT0B8L\r\n" \
101"fq1lpXKqj1KcvBNCiEkEW1VWJ+dvyAYIF5eyJ++hoFLnETL3M32HivyhKSwPihPg\r\n" \
102"nVW8TT9fJJIYDe1JZ/fjcQKBgHJfv7UsrR0LSvkG3K8AOtbx+8PZhOjPuRbk0v+L\r\n" \
103"EKCkuIe5/XW4vtfQMeZb7hFJgk7vrepm+vkoy8VQKDf4urGW3W1VTHBmobM01hi4\r\n" \
104"DuYvEul+Mf0wMRtWjJolo4m+BO5KiW2jpFfqFm6JmfjVqOIAKOSKC6am8V/MDF0h\r\n" \
105"kyN9AoGAT9oOiEXMolbkDZw/QCaBiRoAGlGlNYUkJ+58U6OjIZLISw6aFv+Y2uE0\r\n" \
106"mEImItjuYZtSYKblWikp6ldPoKlt9bwEFe3c6IZ8kJ3+xyEyAGrvjXjEY7PzP6dp\r\n" \
107"Ajbjp9X9uocEBv9W/KsBLdQ7yizcL/toHwdBO4vQqmqTvAc5IIw=\r\n" \
108"-----END RSA PRIVATE KEY-----\r\n"
109
110#define RSA_PRIVATE_KEY_4096 \
111"-----BEGIN RSA PRIVATE KEY-----\r\n" \
112"MIIJKgIBAAKCAgEAmkdGjoIshJuOt2NO47qB3Z3yyvmLg2j351isItSNuFQU3qr+\r\n" \
113"jXHIeANf03yw/K0Zvos8RPd+CqLjoxAQL3QDH4bZAl88bIo29i+SANbNSrKQmc0k\r\n" \
114"pH+yzw3alDzO0GZaOPZjsbo6AwBrno5msi0vRuC2aY8vGLPsZWSyLai7tneS1j/o\r\n" \
115"vYW6XIo8Cj61j2Ypy9HhVUW/4Wc+zAT25D/x7jTpkqJLWWT+YzibNbOY48M5eJcB\r\n" \
116"6/sMyUIeI3/u/wXyMrooNyLiCpedkuHRA0m7u5cWPTUISTunSRlVFij/NHJjuU8e\r\n" \
117"wA3B29yfZFsUqDEnyc+OxniIueAixTomVszxAaVn8zFEbYhFMPqziiFp99u3jfeG\r\n" \
118"k1q9mmUi/uCfUC4e2IC5rqq1ZbKSduH7Ug/Vn2bGQahww0sZFRHDXFrnBcotcW+M\r\n" \
119"bnC290VBDnYgzmdYrIOxuPb2aUwJo4ZlbKh5uBB1PigMuyhLKibQ1a+V5ZJGdpP6\r\n" \
120"SE9PGIdgYWSmh2QEMuLE6v+wTO2LQ5JgqsvFfi3GIZvkn0s8jTS72Jq2uMkFkMer\r\n" \
121"UBjPDYaSPy5kpo103KerWs+cMPOJ/3FtZzI++7MoSUTkWVr1ySQFt5i1EIZ/0Thi\r\n" \
122"jut2jNe8a4AoA3TtC8Rkk/3AIIbg8MVNT4EnT+KHROTMu6gET1oJ3YfBRpUCAwEA\r\n" \
123"AQKCAgEAhuNSmT7PVZH8kfLOAuYKrY1vvm+4v0iDl048Eqfs0QESziyLK3gUYnnw\r\n" \
124"yqP2yrU+EQ8Dvvj0xq/sf6GHxTWVlXb9PcmutueRbmXhLcKg83J0Y0StiPXtjIL8\r\n" \
125"XSddW3Bh6fPi7n14Qy+W6KZwu9AtybanRlvePabyRSRpdOpWVQ7u30w5XZsSed6S\r\n" \
126"6BI0BBC68m2qqje1sInoqdCdXKtcB31TytUDNEHM+UuAyM8iGeGS2hCNqZlycHTS\r\n" \
127"jQ9KEsdMH3YLu0lQgRpWtxmg+VL6ROWwmAtKF12EwbDYZ+uoVl69OkQnCpv8pxKa\r\n" \
128"ec/4m6V+uEA1AOpaAMorHG3fH31IKWC/fTZstovgO/eG2XCtlbcCoWCQ7amFq16l\r\n" \
129"Gh1UKeBHxMXpDj4oDmIUGUvgzSNnEeSN/v76losWvWYQDjXR/LMDa/CNYsD8BmJR\r\n" \
130"PZidIjIXdVRlYOhA7ljtySQvp6RBujBfw3tsVMyZw2XzXFwM9O89b1xXC6+M5jf9\r\n" \
131"DXs/U7Fw+J9qq/YpByABcPCwWdttwdQFRbOxwxaSOKarIqS87TW1JuFcNJ59Ut6G\r\n" \
132"kMvAg6gC34U+0ktkG/AmI1hgjC+P7ErHCXBR2xARoGzcO/CMZF59S+Z2HFchpTSP\r\n" \
133"5T2o4mGy3VfHSBidQQrcZRukg8ZP8M1NF3bXjpY6QZpeLHc4oHECggEBAMjdgzzk\r\n" \
134"xp4mIYFxAEiXYt7tzuUXJk+0UpEJj5uboWLirUZqZmNUPyh6WDnzlREBH++Ms0LO\r\n" \
135"+AWSfaGPDoMb0NE2j3c4FRWAhe7Vn6lj7nLVpF2RdwRo88yGerZ4uwGMY8NUQCtn\r\n" \
136"zum3J7eCJ5DojiceRb6uMxTJ8xZmUC4W2f3J/lrR7wlYjyVnnHqH5HcemYUipWSw\r\n" \
137"sM0/cHp3lrz2VWrbAEu8HVpklvDQpdAgl7cjXt/JHYawY+p426IF/PzQSRROnzgy\r\n" \
138"4WI8FVYNV2tgu0TOFURbkkEvuj/duDKeooUIF0G0XHzha5oAX/j0iWiHbrOF6wHj\r\n" \
139"0xeajL9msKBnmD8CggEBAMSgLWmv7G31x4tndJCcXnX4AyVL7KpygAx/ZwCcyTR8\r\n" \
140"rY1rO07f/ta2noEra/xmEW/BW98qJFCHSU2nSLAQ5FpFSWyuQqrnffrMJnfWyvpr\r\n" \
141"ceQ0yQ/MiA6/JIOvGAjabcspzZijxzGp+Qk3eTT0yOXLSVOCH9B9XVHLodcy4PQM\r\n" \
142"KSCxy0vVHhVNl2SdPEwTXRmxk99Q/rw6IHVpQxBq1OhQt05nTKT+rZMD/grSK22e\r\n" \
143"my2F0DodAJwLo063Zv3RXQZhDYodMmjcp9Hqrtvj9P3HD7J3z6ACiV3SCi8cZumL\r\n" \
144"bSmnKCcd0bb45+aOWm31ieECJuIcJ9rOREEa/KDYTCsCggEBAMG5WkSVhLWsou37\r\n" \
145"dUGNuA63nq42SH3gtS0q4nU6gUkkw+dA4ST1cMByVrr1oRQ4WHup4I4TnQOKyF3T\r\n" \
146"4jQy1I+ipnVeAn+tZ/7zyzwMpEHeqNqRXA9FxbTBEoMAJ6QTqXgOvqDeSqIAQm7r\r\n" \
147"OYu5rrgtqyh/S8bGCwvUe4ooAfCSKx2ekYMbBVwW9MT8YS09tuS/iHJ3Mt2RTMLg\r\n" \
148"qeHvVmxrcXqZoFm44Ba7tN/pP0mi9HKyviZT4tmV3IYEbn3JyGGsfkUuVU9wEUfg\r\n" \
149"MCrgrVxrwfketAzooiHMjkVL2ASjzAJTmEvdAPETYXxzJD9LN0ovY3t8JfAC37IN\r\n" \
150"sVXS8/MCggEBALByOS59Y4Ktq1rLBQx8djwQyuneP0wZohUVAx7Gk7xZIfklQDyg\r\n" \
151"v/R4PrcVezstcPpDnykdjScCsGJR+uWc0v667I/ttP/e6utz5hVmmBGu965dPAzE\r\n" \
152"c1ggaSkOqFfRg/Nr2Qbf+fH0YPnHYSqHe/zSt0OMIvaaeXLcdKhEDSCUBRhE1HWB\r\n" \
153"kxR046WzgBeYzNQwycz9xwqsctJKGpeR9ute+5ANHPd3X9XtID0fqz8ctI5eZaSw\r\n" \
154"wApIW01ZQcAF8B+4WkkVuFXnpWW33yCOaRyPVOPHpnclr5WU1fS+3Q85QkW9rkej\r\n" \
155"97zlkl0QY9AHJqrXnoML1ywAK7ns+MVyNK8CggEAf62xcKZhOb1djeF72Ms+i/i/\r\n" \
156"WIAq4Q4YpsElgvJTHpNH2v9g4ngSTKe3ws3bGc502sWRlhcoTFMOW2rJNe/iqKkb\r\n" \
157"3cdeTkseDbpqozmJWz9dJWSVtXas2bZjzBEa//gQ7nHGVeQdqZJQ9rxPsoOAkfpi\r\n" \
158"qCFrmfUVUqC53e3XMt8+W+aSvKl+JZiB9ozkO9A6Q0vfQLKtjUMdQE3XaCFQT8DI\r\n" \
159"smaLBlBmeRaBpc02ENeC4ADlWosm1SwgxqMhuh2Alba/GrHOoPlVl4hDs9Fb5a6R\r\n" \
160"rmpXSt07GAxnG6j9jssA95E4rc1zO0CVKG5bvjVTxwi/sT0/VVX7VsJM4uTAQg==\r\n" \
161"-----END RSA PRIVATE KEY-----\r\n"
162
163#if defined _MSC_VER && !defined snprintf
164#define snprintf _snprintf
165#endif
166
167/*
168 * For heap usage estimates, we need an estimate of the overhead per allocated
169 * block. ptmalloc2/3 (used in gnu libc for instance) uses 2 size_t per block,
170 * so use that as our baseline.
171 */
172#define MEM_BLOCK_OVERHEAD ( 2 * sizeof( size_t ) )
173
174/*
175 * Size to use for the malloc buffer if MEMORY_BUFFER_ALLOC_C is defined.
176 */
177#define HEAP_SIZE (1u << 16) // 64k
178
179#define BUFSIZE 1024
180#define HEADER_FORMAT " %-24s : "
181#define TITLE_LEN 25
182
183#define OPTIONS \
184 "md4, md5, ripemd160, sha1, sha256, sha512,\r\n" \
185 "arc4, des3, des, aes_cbc, aes_gcm, aes_ccm, camellia, blowfish,\r\n" \
186 "havege, ctr_drbg, hmac_drbg\r\n" \
187 "rsa, dhm, ecdsa, ecdh.\r\n"
188
189#if defined(MBEDTLS_ERROR_C)
190#define PRINT_ERROR \
191 mbedtls_strerror( ret, ( char * )tmp, sizeof( tmp ) ); \
192 mbedtls_printf( "FAILED: %s\r\n", tmp );
193#else
194#define PRINT_ERROR \
195 mbedtls_printf( "FAILED: -0x%04x\r\n", -ret );
196#endif
197
198static unsigned long mbedtls_timing_hardclock( void )
199{
200 static int dwt_started = 0;
201
202 if( dwt_started == 0 )
203 {
204 CoreDebug->DEMCR |= CoreDebug_DEMCR_TRCENA_Msk;
205 DWT->CTRL |= DWT_CTRL_CYCCNTENA_Msk;
206 }
207
208 return( DWT->CYCCNT );
209}
210
211static volatile int alarmed;
212static void alarm() { alarmed = 1; }
213
214#define TIME_AND_TSC( TITLE, CODE ) \
215do { \
216 unsigned long i, j, tsc; \
217 Timeout t; \
218 \
219 mbedtls_printf( HEADER_FORMAT, TITLE ); \
220 fflush( stdout ); \
221 \
222 for( i = 1, alarmed = 0, t.attach( alarm, 1.0 ); !alarmed; i++ ) \
223 { \
224 CODE; \
225 } \
226 \
227 tsc = mbedtls_timing_hardclock(); \
228 for( j = 0; j < 1024; j++ ) \
229 { \
230 CODE; \
231 } \
232 \
233 mbedtls_printf( "%9lu Kb/s, %9lu cycles/byte\r\n", \
234 i * BUFSIZE / 1024, \
235 ( mbedtls_timing_hardclock() - tsc ) / ( j * BUFSIZE ) ); \
236} while( 0 )
237
238#if defined(MBEDTLS_ERROR_C)
239#define PRINT_ERROR \
240 mbedtls_strerror( ret, ( char * )tmp, sizeof( tmp ) ); \
241 mbedtls_printf( "FAILED: %s\r\n", tmp );
242#else
243#define PRINT_ERROR \
244 mbedtls_printf( "FAILED: -0x%04x\r\n", -ret );
245#endif
246
247#if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C) && defined(MBEDTLS_MEMORY_DEBUG)
248
249#define MEMORY_MEASURE_INIT \
250 size_t max_used, max_blocks, max_bytes; \
251 size_t prv_used, prv_blocks; \
252 mbedtls_memory_buffer_alloc_cur_get( &prv_used, &prv_blocks ); \
253 mbedtls_memory_buffer_alloc_max_reset( );
254
255#define MEMORY_MEASURE_PRINT( title_len ) \
256 mbedtls_memory_buffer_alloc_max_get( &max_used, &max_blocks ); \
257 for( i = 12 - title_len; i != 0; i-- ) mbedtls_printf( " " ); \
258 max_used -= prv_used; \
259 max_blocks -= prv_blocks; \
260 max_bytes = max_used + MEM_BLOCK_OVERHEAD * max_blocks; \
261 mbedtls_printf( "%6u heap bytes", (unsigned) max_bytes );
262
263#else
264#define MEMORY_MEASURE_INIT
265#define MEMORY_MEASURE_PRINT( title_len )
266#endif
267
268#define TIME_PUBLIC( TITLE, TYPE, CODE ) \
269do { \
270 unsigned long ms; \
271 int ret = 0; \
272 Timer t; \
273 MEMORY_MEASURE_INIT; \
274 \
275 mbedtls_printf( HEADER_FORMAT, TITLE ); \
276 fflush( stdout ); \
277 \
278 t.start(); \
279 CODE; \
280 t.stop(); \
281 ms = t.read_ms(); \
282 \
283 if( ret != 0 ) \
284 { \
285 PRINT_ERROR; \
286 } \
287 else \
288 { \
289 mbedtls_printf( "%6lu ms/" TYPE, ms ); \
290 MEMORY_MEASURE_PRINT( sizeof( TYPE ) + 1 ); \
291 mbedtls_printf( "\r\n" ); \
292 } \
293} while( 0 )
294
295static int myrand( void *rng_state, unsigned char *output, size_t len )
296{
297 size_t use_len;
298 int rnd;
299
300 if( rng_state != NULL )
301 rng_state = NULL;
302
303 while( len > 0 )
304 {
305 use_len = len;
306 if( use_len > sizeof(int) )
307 use_len = sizeof(int);
308
309 rnd = rand();
310 memcpy( output, &rnd, use_len );
311 output += use_len;
312 len -= use_len;
313 }
314
315 return( 0 );
316}
317
318/*
319 * Clear some memory that was used to prepare the context
320 */
321#if defined(MBEDTLS_ECP_C)
322void ecp_clear_precomputed( mbedtls_ecp_group *grp )
323{
324 if( grp->T != NULL )
325 {
326 size_t i;
327 for( i = 0; i < grp->T_size; i++ )
328 mbedtls_ecp_point_free( &grp->T[i] );
329 mbedtls_free( grp->T );
330 }
331 grp->T = NULL;
332 grp->T_size = 0;
333}
334#else
335#define ecp_clear_precomputed( g )
336#endif
337
338unsigned char buf[BUFSIZE];
339
340typedef struct {
341 char md4, md5, ripemd160, sha1, sha256, sha512,
342 arc4, des3, des, aes_cbc, aes_gcm, aes_ccm, camellia, blowfish,
343 havege, ctr_drbg, hmac_drbg,
344 rsa, dhm, ecdsa, ecdh;
345} todo_list;
346
347int benchmark( int argc, char *argv[] )
348{
349 int i;
350 unsigned char tmp[200];
351 char title[TITLE_LEN];
352 todo_list todo;
353#if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C)
354 unsigned char malloc_buf[HEAP_SIZE] = { 0 };
355#endif
356
357 if( argc <= 1 )
358 {
359 memset( &todo, 1, sizeof( todo ) );
360 }
361 else
362 {
363 memset( &todo, 0, sizeof( todo ) );
364
365 for( i = 1; i < argc; i++ )
366 {
367 if( strcmp( argv[i], "md4" ) == 0 )
368 todo.md4 = 1;
369 else if( strcmp( argv[i], "md5" ) == 0 )
370 todo.md5 = 1;
371 else if( strcmp( argv[i], "ripemd160" ) == 0 )
372 todo.ripemd160 = 1;
373 else if( strcmp( argv[i], "sha1" ) == 0 )
374 todo.sha1 = 1;
375 else if( strcmp( argv[i], "sha256" ) == 0 )
376 todo.sha256 = 1;
377 else if( strcmp( argv[i], "sha512" ) == 0 )
378 todo.sha512 = 1;
379 else if( strcmp( argv[i], "arc4" ) == 0 )
380 todo.arc4 = 1;
381 else if( strcmp( argv[i], "des3" ) == 0 )
382 todo.des3 = 1;
383 else if( strcmp( argv[i], "des" ) == 0 )
384 todo.des = 1;
385 else if( strcmp( argv[i], "aes_cbc" ) == 0 )
386 todo.aes_cbc = 1;
387 else if( strcmp( argv[i], "aes_gcm" ) == 0 )
388 todo.aes_gcm = 1;
389 else if( strcmp( argv[i], "aes_ccm" ) == 0 )
390 todo.aes_ccm = 1;
391 else if( strcmp( argv[i], "camellia" ) == 0 )
392 todo.camellia = 1;
393 else if( strcmp( argv[i], "blowfish" ) == 0 )
394 todo.blowfish = 1;
395 else if( strcmp( argv[i], "havege" ) == 0 )
396 todo.havege = 1;
397 else if( strcmp( argv[i], "ctr_drbg" ) == 0 )
398 todo.ctr_drbg = 1;
399 else if( strcmp( argv[i], "hmac_drbg" ) == 0 )
400 todo.hmac_drbg = 1;
401 else if( strcmp( argv[i], "rsa" ) == 0 )
402 todo.rsa = 1;
403 else if( strcmp( argv[i], "dhm" ) == 0 )
404 todo.dhm = 1;
405 else if( strcmp( argv[i], "ecdsa" ) == 0 )
406 todo.ecdsa = 1;
407 else if( strcmp( argv[i], "ecdh" ) == 0 )
408 todo.ecdh = 1;
409 else
410 {
411 mbedtls_printf( "Unrecognized option: %s\r\n", argv[i] );
412 mbedtls_printf( "Available options: " OPTIONS );
413 }
414 }
415 }
416
417 mbedtls_printf( "\r\n\r\n" );
418
419#if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C)
420 mbedtls_memory_buffer_alloc_init( malloc_buf, sizeof( malloc_buf ) );
421#endif
422 memset( buf, 0xAA, sizeof( buf ) );
423 memset( tmp, 0xBB, sizeof( tmp ) );
424
425#if defined(MBEDTLS_MD4_C)
426 if( todo.md4 )
427 TIME_AND_TSC( "MD4", mbedtls_md4( buf, BUFSIZE, tmp ) );
428#endif
429
430#if defined(MBEDTLS_MD5_C)
431 if( todo.md5 )
432 TIME_AND_TSC( "MD5", mbedtls_md5( buf, BUFSIZE, tmp ) );
433#endif
434
435#if defined(MBEDTLS_RIPEMD160_C)
436 if( todo.ripemd160 )
437 TIME_AND_TSC( "RIPEMD160", mbedtls_ripemd160( buf, BUFSIZE, tmp ) );
438#endif
439
440#if defined(MBEDTLS_SHA1_C)
441 if( todo.sha1 )
442 TIME_AND_TSC( "SHA-1", mbedtls_sha1( buf, BUFSIZE, tmp ) );
443#endif
444
445#if defined(MBEDTLS_SHA256_C)
446 if( todo.sha256 )
447 TIME_AND_TSC( "SHA-256", mbedtls_sha256( buf, BUFSIZE, tmp, 0 ) );
448#endif
449
450#if defined(MBEDTLS_SHA512_C)
451 if( todo.sha512 )
452 TIME_AND_TSC( "SHA-512", mbedtls_sha512( buf, BUFSIZE, tmp, 0 ) );
453#endif
454
455#if defined(MBEDTLS_ARC4_C)
456 if( todo.arc4 )
457 {
458 mbedtls_arc4_context arc4;
459 mbedtls_arc4_init( &arc4 );
460 mbedtls_arc4_setup( &arc4, tmp, 32 );
461 TIME_AND_TSC( "ARC4", mbedtls_arc4_crypt( &arc4, BUFSIZE, buf, buf ) );
462 mbedtls_arc4_free( &arc4 );
463 }
464#endif
465
466#if defined(MBEDTLS_DES_C) && defined(MBEDTLS_CIPHER_MODE_CBC)
467 if( todo.des3 )
468 {
469 mbedtls_des3_context des3;
470 mbedtls_des3_init( &des3 );
471 mbedtls_des3_set3key_enc( &des3, tmp );
472 TIME_AND_TSC( "3DES",
473 mbedtls_des3_crypt_cbc( &des3, MBEDTLS_DES_ENCRYPT, BUFSIZE, tmp, buf, buf ) );
474 mbedtls_des3_free( &des3 );
475 }
476
477 if( todo.des )
478 {
479 mbedtls_des_context des;
480 mbedtls_des_init( &des );
481 mbedtls_des_setkey_enc( &des, tmp );
482 TIME_AND_TSC( "DES",
483 mbedtls_des_crypt_cbc( &des, MBEDTLS_DES_ENCRYPT, BUFSIZE, tmp, buf, buf ) );
484 mbedtls_des_free( &des );
485 }
486#endif
487
488#if defined(MBEDTLS_AES_C)
489#if defined(MBEDTLS_CIPHER_MODE_CBC)
490 if( todo.aes_cbc )
491 {
492 int keysize;
493 mbedtls_aes_context aes;
494 mbedtls_aes_init( &aes );
495 for( keysize = 128; keysize <= 256; keysize += 64 )
496 {
497 mbedtls_snprintf( title, sizeof( title ), "AES-CBC-%d", keysize );
498
499 memset( buf, 0, sizeof( buf ) );
500 memset( tmp, 0, sizeof( tmp ) );
501 mbedtls_aes_setkey_enc( &aes, tmp, keysize );
502
503 TIME_AND_TSC( title,
504 mbedtls_aes_crypt_cbc( &aes, MBEDTLS_AES_ENCRYPT, BUFSIZE, tmp, buf, buf ) );
505 }
506 mbedtls_aes_free( &aes );
507 }
508#endif
509#if defined(MBEDTLS_GCM_C)
510 if( todo.aes_gcm )
511 {
512 int keysize;
513 mbedtls_gcm_context gcm;
514
515 mbedtls_gcm_init( &gcm );
516 for( keysize = 128; keysize <= 256; keysize += 64 )
517 {
518 mbedtls_snprintf( title, sizeof( title ), "AES-GCM-%d", keysize );
519
520 memset( buf, 0, sizeof( buf ) );
521 memset( tmp, 0, sizeof( tmp ) );
522 mbedtls_gcm_setkey( &gcm, MBEDTLS_CIPHER_ID_AES, tmp, keysize );
523
524 TIME_AND_TSC( title,
525 mbedtls_gcm_crypt_and_tag( &gcm, MBEDTLS_GCM_ENCRYPT, BUFSIZE, tmp,
526 12, NULL, 0, buf, buf, 16, tmp ) );
527
528 mbedtls_gcm_free( &gcm );
529 }
530 }
531#endif
532#if defined(MBEDTLS_CCM_C)
533 if( todo.aes_ccm )
534 {
535 int keysize;
536 mbedtls_ccm_context ccm;
537
538 mbedtls_ccm_init( &ccm );
539 for( keysize = 128; keysize <= 256; keysize += 64 )
540 {
541 mbedtls_snprintf( title, sizeof( title ), "AES-CCM-%d", keysize );
542
543 memset( buf, 0, sizeof( buf ) );
544 memset( tmp, 0, sizeof( tmp ) );
545 mbedtls_ccm_setkey( &ccm, MBEDTLS_CIPHER_ID_AES, tmp, keysize );
546
547 TIME_AND_TSC( title,
548 mbedtls_ccm_encrypt_and_tag( &ccm, BUFSIZE, tmp,
549 12, NULL, 0, buf, buf, tmp, 16 ) );
550
551 mbedtls_ccm_free( &ccm );
552 }
553 }
554#endif
555#endif
556
557#if defined(MBEDTLS_CAMELLIA_C) && defined(MBEDTLS_CIPHER_MODE_CBC)
558 if( todo.camellia )
559 {
560 int keysize;
561 mbedtls_camellia_context camellia;
562 mbedtls_camellia_init( &camellia );
563 for( keysize = 128; keysize <= 256; keysize += 64 )
564 {
565 mbedtls_snprintf( title, sizeof( title ), "CAMELLIA-CBC-%d", keysize );
566
567 memset( buf, 0, sizeof( buf ) );
568 memset( tmp, 0, sizeof( tmp ) );
569 mbedtls_camellia_setkey_enc( &camellia, tmp, keysize );
570
571 TIME_AND_TSC( title,
572 mbedtls_camellia_crypt_cbc( &camellia, MBEDTLS_CAMELLIA_ENCRYPT,
573 BUFSIZE, tmp, buf, buf ) );
574 }
575 mbedtls_camellia_free( &camellia );
576 }
577#endif
578
579#if defined(MBEDTLS_BLOWFISH_C) && defined(MBEDTLS_CIPHER_MODE_CBC)
580 if( todo.blowfish )
581 {
582 int keysize;
583 mbedtls_blowfish_context blowfish;
584 mbedtls_blowfish_init( &blowfish );
585
586 for( keysize = 128; keysize <= 256; keysize += 64 )
587 {
588 mbedtls_snprintf( title, sizeof( title ), "BLOWFISH-CBC-%d", keysize );
589
590 memset( buf, 0, sizeof( buf ) );
591 memset( tmp, 0, sizeof( tmp ) );
592 mbedtls_blowfish_setkey( &blowfish, tmp, keysize );
593
594 TIME_AND_TSC( title,
595 mbedtls_blowfish_crypt_cbc( &blowfish, MBEDTLS_BLOWFISH_ENCRYPT, BUFSIZE,
596 tmp, buf, buf ) );
597 }
598
599 mbedtls_blowfish_free( &blowfish );
600 }
601#endif
602
603#if defined(MBEDTLS_HAVEGE_C)
604 if( todo.havege )
605 {
606 mbedtls_havege_state hs;
607 mbedtls_havege_init( &hs );
608 TIME_AND_TSC( "HAVEGE", mbedtls_havege_random( &hs, buf, BUFSIZE ) );
609 mbedtls_havege_free( &hs );
610 }
611#endif
612
613#if defined(MBEDTLS_CTR_DRBG_C)
614 if( todo.ctr_drbg )
615 {
616 mbedtls_ctr_drbg_context ctr_drbg;
617
618 mbedtls_ctr_drbg_init( &ctr_drbg );
619
620 if( mbedtls_ctr_drbg_seed( &ctr_drbg, myrand, NULL, NULL, 0 ) != 0 )
621 mbedtls_exit(1);
622 TIME_AND_TSC( "CTR_DRBG (NOPR)",
623 if( mbedtls_ctr_drbg_random( &ctr_drbg, buf, BUFSIZE ) != 0 )
624 mbedtls_exit(1) );
625
626 if( mbedtls_ctr_drbg_seed( &ctr_drbg, myrand, NULL, NULL, 0 ) != 0 )
627 mbedtls_exit(1);
628 mbedtls_ctr_drbg_set_prediction_resistance( &ctr_drbg, MBEDTLS_CTR_DRBG_PR_ON );
629 TIME_AND_TSC( "CTR_DRBG (PR)",
630 if( mbedtls_ctr_drbg_random( &ctr_drbg, buf, BUFSIZE ) != 0 )
631 mbedtls_exit(1) );
632 mbedtls_ctr_drbg_free( &ctr_drbg );
633 }
634#endif
635
636#if defined(MBEDTLS_HMAC_DRBG_C)
637 if( todo.hmac_drbg )
638 {
639 mbedtls_hmac_drbg_context hmac_drbg;
640 const mbedtls_md_info_t *md_info;
641
642 mbedtls_hmac_drbg_init( &hmac_drbg );
643
644#if defined(MBEDTLS_SHA1_C)
645 if( ( md_info = mbedtls_md_info_from_type( MBEDTLS_MD_SHA1 ) ) == NULL )
646 mbedtls_exit(1);
647
648 if( mbedtls_hmac_drbg_seed( &hmac_drbg, md_info, myrand, NULL, NULL, 0 ) != 0 )
649 mbedtls_exit(1);
650 TIME_AND_TSC( "HMAC_DRBG SHA-1 (NOPR)",
651 if( mbedtls_hmac_drbg_random( &hmac_drbg, buf, BUFSIZE ) != 0 )
652 mbedtls_exit(1) );
653 mbedtls_hmac_drbg_free( &hmac_drbg );
654
655 if( mbedtls_hmac_drbg_seed( &hmac_drbg, md_info, myrand, NULL, NULL, 0 ) != 0 )
656 mbedtls_exit(1);
657 mbedtls_hmac_drbg_set_prediction_resistance( &hmac_drbg,
658 MBEDTLS_HMAC_DRBG_PR_ON );
659 TIME_AND_TSC( "HMAC_DRBG SHA-1 (PR)",
660 if( mbedtls_hmac_drbg_random( &hmac_drbg, buf, BUFSIZE ) != 0 )
661 mbedtls_exit(1) );
662 mbedtls_hmac_drbg_free( &hmac_drbg );
663#endif
664
665#if defined(MBEDTLS_SHA256_C)
666 if( ( md_info = mbedtls_md_info_from_type( MBEDTLS_MD_SHA256 ) ) == NULL )
667 mbedtls_exit(1);
668
669 if( mbedtls_hmac_drbg_seed( &hmac_drbg, md_info, myrand, NULL, NULL, 0 ) != 0 )
670 mbedtls_exit(1);
671 TIME_AND_TSC( "HMAC_DRBG SHA-256 (NOPR)",
672 if( mbedtls_hmac_drbg_random( &hmac_drbg, buf, BUFSIZE ) != 0 )
673 mbedtls_exit(1) );
674 mbedtls_hmac_drbg_free( &hmac_drbg );
675
676 if( mbedtls_hmac_drbg_seed( &hmac_drbg, md_info, myrand, NULL, NULL, 0 ) != 0 )
677 mbedtls_exit(1);
678 mbedtls_hmac_drbg_set_prediction_resistance( &hmac_drbg,
679 MBEDTLS_HMAC_DRBG_PR_ON );
680 TIME_AND_TSC( "HMAC_DRBG SHA-256 (PR)",
681 if( mbedtls_hmac_drbg_random( &hmac_drbg, buf, BUFSIZE ) != 0 )
682 mbedtls_exit(1) );
683 mbedtls_hmac_drbg_free( &hmac_drbg );
684#endif
685 }
686#endif
687
688#if defined(MBEDTLS_RSA_C) && \
689 defined(MBEDTLS_PEM_PARSE_C) && defined(MBEDTLS_PK_PARSE_C)
690 if( todo.rsa )
691 {
692 mbedtls_pk_context pk;
693 mbedtls_rsa_context *rsa;
694 const char *rsa_keys[] = { RSA_PRIVATE_KEY_2048, RSA_PRIVATE_KEY_4096 };
695 size_t i;
696
697 for( i = 0; i < sizeof( rsa_keys ) / sizeof( rsa_keys[0] ); i++ )
698 {
699 mbedtls_pk_init( &pk );
700 mbedtls_pk_parse_key( &pk, (const unsigned char *) rsa_keys[i],
701 strlen( rsa_keys[i] ) + 1, NULL, 0 );
702 rsa = mbedtls_pk_rsa( pk );
703
704 mbedtls_snprintf( title, sizeof( title ), "RSA-%d", mbedtls_pk_get_bitlen( &pk ) );
705
706 TIME_PUBLIC( title, " public",
707 buf[0] = 0;
708 ret = mbedtls_rsa_public( rsa, buf, buf ) );
709
710 TIME_PUBLIC( title, "private",
711 buf[0] = 0;
712 ret = mbedtls_rsa_private( rsa, myrand, NULL, buf, buf ) );
713
714 mbedtls_pk_free( &pk );
715 }
716 }
717#endif
718
719#if defined(MBEDTLS_DHM_C) && defined(MBEDTLS_BIGNUM_C)
720 if( todo.dhm )
721 {
722 int dhm_sizes[] = { 2048, 3072 };
723 const char *dhm_P[] = {
724 MBEDTLS_DHM_RFC3526_MODP_2048_P,
725 MBEDTLS_DHM_RFC3526_MODP_3072_P,
726 };
727 const char *dhm_G[] = {
728 MBEDTLS_DHM_RFC3526_MODP_2048_G,
729 MBEDTLS_DHM_RFC3526_MODP_3072_G,
730 };
731
732 mbedtls_dhm_context dhm;
733 size_t olen;
734 for( i = 0; (size_t) i < sizeof( dhm_sizes ) / sizeof( dhm_sizes[0] ); i++ )
735 {
736 mbedtls_dhm_init( &dhm );
737
738 if( mbedtls_mpi_read_string( &dhm.P, 16, dhm_P[i] ) != 0 ||
739 mbedtls_mpi_read_string( &dhm.G, 16, dhm_G[i] ) != 0 )
740 {
741 mbedtls_exit( 1 );
742 }
743
744 dhm.len = mbedtls_mpi_size( &dhm.P );
745 mbedtls_dhm_make_public( &dhm, (int) dhm.len, buf, dhm.len, myrand, NULL );
746 if( mbedtls_mpi_copy( &dhm.GY, &dhm.GX ) != 0 )
747 mbedtls_exit( 1 );
748
749 mbedtls_snprintf( title, sizeof( title ), "DHE-%d", dhm_sizes[i] );
750 TIME_PUBLIC( title, "handshake",
751 ret |= mbedtls_dhm_make_public( &dhm, (int) dhm.len, buf, dhm.len,
752 myrand, NULL );
753 ret |= mbedtls_dhm_calc_secret( &dhm, buf, sizeof( buf ), &olen, myrand, NULL ) );
754
755 mbedtls_snprintf( title, sizeof( title ), "DH-%d", dhm_sizes[i] );
756 TIME_PUBLIC( title, "handshake",
757 ret |= mbedtls_dhm_calc_secret( &dhm, buf, sizeof( buf ), &olen, myrand, NULL ) );
758
759 mbedtls_dhm_free( &dhm );
760 }
761 }
762#endif
763
764#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_SHA256_C)
765 if( todo.ecdsa )
766 {
767 mbedtls_ecdsa_context ecdsa;
768 const mbedtls_ecp_curve_info *curve_info;
769 size_t sig_len;
770
771 memset( buf, 0x2A, sizeof( buf ) );
772
773 for( curve_info = mbedtls_ecp_curve_list();
774 curve_info->grp_id != MBEDTLS_ECP_DP_NONE;
775 curve_info++ )
776 {
777 mbedtls_ecdsa_init( &ecdsa );
778
779 if( mbedtls_ecdsa_genkey( &ecdsa, curve_info->grp_id, myrand, NULL ) != 0 )
780 mbedtls_exit( 1 );
781 ecp_clear_precomputed( &ecdsa.grp );
782
783 mbedtls_snprintf( title, sizeof( title ), "ECDSA-%s",
784 curve_info->name );
785 TIME_PUBLIC( title, "sign",
786 ret = mbedtls_ecdsa_write_signature( &ecdsa, MBEDTLS_MD_SHA256, buf, curve_info->bit_size,
787 tmp, &sig_len, myrand, NULL ) );
788
789 mbedtls_ecdsa_free( &ecdsa );
790 }
791
792 for( curve_info = mbedtls_ecp_curve_list();
793 curve_info->grp_id != MBEDTLS_ECP_DP_NONE;
794 curve_info++ )
795 {
796 mbedtls_ecdsa_init( &ecdsa );
797
798 if( mbedtls_ecdsa_genkey( &ecdsa, curve_info->grp_id, myrand, NULL ) != 0 ||
799 mbedtls_ecdsa_write_signature( &ecdsa, MBEDTLS_MD_SHA256, buf, curve_info->bit_size,
800 tmp, &sig_len, myrand, NULL ) != 0 )
801 {
802 mbedtls_exit( 1 );
803 }
804 ecp_clear_precomputed( &ecdsa.grp );
805
806 mbedtls_snprintf( title, sizeof( title ), "ECDSA-%s",
807 curve_info->name );
808 TIME_PUBLIC( title, "verify",
809 ret = mbedtls_ecdsa_read_signature( &ecdsa, buf, curve_info->bit_size,
810 tmp, sig_len ) );
811
812 mbedtls_ecdsa_free( &ecdsa );
813 }
814 }
815#endif
816
817#if defined(MBEDTLS_ECDH_C)
818 if( todo.ecdh )
819 {
820 mbedtls_ecdh_context ecdh;
821#if defined(MBEDTLS_ECP_DP_CURVE25519_ENABLED)
822 mbedtls_mpi z;
823#endif
824 const mbedtls_ecp_curve_info *curve_info;
825 size_t olen;
826
827 for( curve_info = mbedtls_ecp_curve_list();
828 curve_info->grp_id != MBEDTLS_ECP_DP_NONE;
829 curve_info++ )
830 {
831 mbedtls_ecdh_init( &ecdh );
832
833 if( mbedtls_ecp_group_load( &ecdh.grp, curve_info->grp_id ) != 0 ||
834 mbedtls_ecdh_make_public( &ecdh, &olen, buf, sizeof( buf),
835 myrand, NULL ) != 0 ||
836 mbedtls_ecp_copy( &ecdh.Qp, &ecdh.Q ) != 0 )
837 {
838 mbedtls_exit( 1 );
839 }
840 ecp_clear_precomputed( &ecdh.grp );
841
842 mbedtls_snprintf( title, sizeof( title ), "ECDHE-%s",
843 curve_info->name );
844 TIME_PUBLIC( title, "handshake",
845 ret |= mbedtls_ecdh_make_public( &ecdh, &olen, buf, sizeof( buf),
846 myrand, NULL );
847 ret |= mbedtls_ecdh_calc_secret( &ecdh, &olen, buf, sizeof( buf ),
848 myrand, NULL ) );
849 mbedtls_ecdh_free( &ecdh );
850 }
851
852 /* Curve25519 needs to be handled separately */
853#if defined(MBEDTLS_ECP_DP_CURVE25519_ENABLED)
854 mbedtls_ecdh_init( &ecdh );
855 mbedtls_mpi_init( &z );
856
857 if( mbedtls_ecp_group_load( &ecdh.grp, MBEDTLS_ECP_DP_CURVE25519 ) != 0 ||
858 mbedtls_ecdh_gen_public( &ecdh.grp, &ecdh.d, &ecdh.Qp, myrand, NULL ) != 0 )
859 {
860 mbedtls_exit( 1 );
861 }
862
863 TIME_PUBLIC( "ECDHE-Curve25519", "handshake",
864 ret |= mbedtls_ecdh_gen_public( &ecdh.grp, &ecdh.d, &ecdh.Q,
865 myrand, NULL );
866 ret |= mbedtls_ecdh_compute_shared( &ecdh.grp, &z, &ecdh.Qp, &ecdh.d,
867 myrand, NULL ) );
868
869 mbedtls_ecdh_free( &ecdh );
870 mbedtls_mpi_free( &z );
871#endif
872
873 for( curve_info = mbedtls_ecp_curve_list();
874 curve_info->grp_id != MBEDTLS_ECP_DP_NONE;
875 curve_info++ )
876 {
877 mbedtls_ecdh_init( &ecdh );
878
879 if( mbedtls_ecp_group_load( &ecdh.grp, curve_info->grp_id ) != 0 ||
880 mbedtls_ecdh_make_public( &ecdh, &olen, buf, sizeof( buf),
881 myrand, NULL ) != 0 ||
882 mbedtls_ecp_copy( &ecdh.Qp, &ecdh.Q ) != 0 ||
883 mbedtls_ecdh_make_public( &ecdh, &olen, buf, sizeof( buf),
884 myrand, NULL ) != 0 )
885 {
886 mbedtls_exit( 1 );
887 }
888 ecp_clear_precomputed( &ecdh.grp );
889
890 mbedtls_snprintf( title, sizeof( title ), "ECDH-%s",
891 curve_info->name );
892 TIME_PUBLIC( title, "handshake",
893 ret |= mbedtls_ecdh_calc_secret( &ecdh, &olen, buf, sizeof( buf ),
894 myrand, NULL ) );
895 mbedtls_ecdh_free( &ecdh );
896 }
897
898 /* Curve25519 needs to be handled separately */
899#if defined(MBEDTLS_ECP_DP_CURVE25519_ENABLED)
900 mbedtls_ecdh_init( &ecdh );
901 mbedtls_mpi_init( &z );
902
903 if( mbedtls_ecp_group_load( &ecdh.grp, MBEDTLS_ECP_DP_CURVE25519 ) != 0 ||
904 mbedtls_ecdh_gen_public( &ecdh.grp, &ecdh.d, &ecdh.Qp,
905 myrand, NULL ) != 0 ||
906 mbedtls_ecdh_gen_public( &ecdh.grp, &ecdh.d, &ecdh.Q, myrand, NULL ) != 0 )
907 {
908 mbedtls_exit( 1 );
909 }
910
911 TIME_PUBLIC( "ECDH-Curve25519", "handshake",
912 ret |= mbedtls_ecdh_compute_shared( &ecdh.grp, &z, &ecdh.Qp, &ecdh.d,
913 myrand, NULL ) );
914
915 mbedtls_ecdh_free( &ecdh );
916 mbedtls_mpi_free( &z );
917#endif
918 }
919#endif
920
921 mbedtls_printf( "\r\n" );
922
923#if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C)
924 mbedtls_memory_buffer_alloc_free();
925#endif
926
927#if defined(_WIN32)
928 mbedtls_printf( " Press Enter to exit this program.\r\n" );
929 fflush( stdout ); getchar();
930#endif
931
932 return( 0 );
933}
934
935#include "mbed/test_env.h"
Manuel Pégourié-Gonnarde87b04c2015-08-11 04:09:44 +0200[diff] [blame]936#include "minar/minar.h"
Manuel Pégourié-Gonnard63e7eba2015-07-28 14:17:48 +0200[diff] [blame]937
Manuel Pégourié-Gonnarde87b04c2015-08-11 04:09:44 +0200[diff] [blame]938static void run() {
Manuel Pégourié-Gonnardbd5bbec2015-08-06 18:10:17 +0200[diff] [blame]939 /* Use 115200 bps for consistency with other examples */
940 Serial pc(USBTX, USBRX);
941 pc.baud(115200);
942
Manuel Pégourié-Gonnard63e7eba2015-07-28 14:17:48 +0200[diff] [blame]943 MBED_HOSTTEST_TIMEOUT(150);
944 MBED_HOSTTEST_SELECT(default);
945 MBED_HOSTTEST_DESCRIPTION(mbed TLS benchmark program);
946 MBED_HOSTTEST_START("MBEDTLS_BENCHMARK");
947 MBED_HOSTTEST_RESULT(benchmark(0, NULL) == 0);
948}
949
Manuel Pégourié-Gonnarde87b04c2015-08-11 04:09:44 +0200[diff] [blame]950void app_start(int, char*[]) {
951 minar::Scheduler::postCallback(FunctionPointer0<void>(run).bind());
952}
953
Manuel Pégourié-Gonnard63e7eba2015-07-28 14:17:48 +0200[diff] [blame]954#endif /* TARGET_LIKE_MBED */