1 /*
2 * SSL client with certificate authentication
3 *
4 * Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
5 * SPDX-License-Identifier: Apache-2.0
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License"); you may
8 * not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
15 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 *
19 * This file is part of mbed TLS (https://tls.mbed.org)
20 */
21
22 #if !defined(MBEDTLS_CONFIG_FILE)
23 #include "mbedtls/config.h"
24 #else
25 #include MBEDTLS_CONFIG_FILE
26 #endif
27
28 #if defined(MBEDTLS_PLATFORM_C)
29 #include "mbedtls/platform.h"
30 #else
31 #include <stdio.h>
32 #include <stdlib.h>
33 #define mbedtls_time time
34 #define mbedtls_time_t time_t
35 #define mbedtls_printf printf
36 #define mbedtls_fprintf fprintf
37 #define mbedtls_snprintf snprintf
38 #define mbedtls_exit exit
39 #define MBEDTLS_EXIT_SUCCESS EXIT_SUCCESS
40 #define MBEDTLS_EXIT_FAILURE EXIT_FAILURE
41 #endif
42
43 #if !defined(MBEDTLS_ENTROPY_C) || \
44 !defined(MBEDTLS_SSL_TLS_C) || !defined(MBEDTLS_SSL_CLI_C) || \
45 !defined(MBEDTLS_NET_C) || !defined(MBEDTLS_CTR_DRBG_C)
main(void)46 int main( void )
47 {
48 mbedtls_printf("MBEDTLS_ENTROPY_C and/or "
49 "MBEDTLS_SSL_TLS_C and/or MBEDTLS_SSL_CLI_C and/or "
50 "MBEDTLS_NET_C and/or MBEDTLS_CTR_DRBG_C and/or not defined.\n");
51 return( 0 );
52 }
53 #else
54
55 #include "mbedtls/net_sockets.h"
56 #include "mbedtls/ssl.h"
57 #include "mbedtls/entropy.h"
58 #include "mbedtls/ctr_drbg.h"
59 #include "mbedtls/certs.h"
60 #include "mbedtls/x509.h"
61 #include "mbedtls/error.h"
62 #include "mbedtls/debug.h"
63 #include "mbedtls/timing.h"
64
65 #include <stdio.h>
66 #include <stdlib.h>
67 #include <string.h>
68
69 #define MAX_REQUEST_SIZE 20000
70 #define MAX_REQUEST_SIZE_STR "20000"
71
72 #define DFL_SERVER_NAME "localhost"
73 #define DFL_SERVER_ADDR NULL
74 #define DFL_SERVER_PORT "4433"
75 #define DFL_REQUEST_PAGE "/"
76 #define DFL_REQUEST_SIZE -1
77 #define DFL_DEBUG_LEVEL 0
78 #define DFL_NBIO 0
79 #define DFL_EVENT 0
80 #define DFL_READ_TIMEOUT 0
81 #define DFL_MAX_RESEND 0
82 #define DFL_CA_FILE ""
83 #define DFL_CA_PATH ""
84 #define DFL_CRT_FILE ""
85 #define DFL_KEY_FILE ""
86 #define DFL_PSK ""
87 #define DFL_PSK_IDENTITY "Client_identity"
88 #define DFL_ECJPAKE_PW NULL
89 #define DFL_EC_MAX_OPS -1
90 #define DFL_FORCE_CIPHER 0
91 #define DFL_RENEGOTIATION MBEDTLS_SSL_RENEGOTIATION_DISABLED
92 #define DFL_ALLOW_LEGACY -2
93 #define DFL_RENEGOTIATE 0
94 #define DFL_EXCHANGES 1
95 #define DFL_MIN_VERSION -1
96 #define DFL_MAX_VERSION -1
97 #define DFL_ARC4 -1
98 #define DFL_SHA1 -1
99 #define DFL_AUTH_MODE -1
100 #define DFL_MFL_CODE MBEDTLS_SSL_MAX_FRAG_LEN_NONE
101 #define DFL_TRUNC_HMAC -1
102 #define DFL_RECSPLIT -1
103 #define DFL_DHMLEN -1
104 #define DFL_RECONNECT 0
105 #define DFL_RECO_DELAY 0
106 #define DFL_RECONNECT_HARD 0
107 #define DFL_TICKETS MBEDTLS_SSL_SESSION_TICKETS_ENABLED
108 #define DFL_ALPN_STRING NULL
109 #define DFL_CURVES NULL
110 #define DFL_TRANSPORT MBEDTLS_SSL_TRANSPORT_STREAM
111 #define DFL_HS_TO_MIN 0
112 #define DFL_HS_TO_MAX 0
113 #define DFL_DTLS_MTU -1
114 #define DFL_DGRAM_PACKING 1
115 #define DFL_FALLBACK -1
116 #define DFL_EXTENDED_MS -1
117 #define DFL_ETM -1
118
119 #define GET_REQUEST "GET %s HTTP/1.0\r\nExtra-header: "
120 #define GET_REQUEST_END "\r\n\r\n"
121
122 #if defined(MBEDTLS_X509_CRT_PARSE_C)
123 #if defined(MBEDTLS_FS_IO)
124 #define USAGE_IO \
125 " ca_file=%%s The single file containing the top-level CA(s) you fully trust\n" \
126 " default: \"\" (pre-loaded)\n" \
127 " ca_path=%%s The path containing the top-level CA(s) you fully trust\n" \
128 " default: \"\" (pre-loaded) (overrides ca_file)\n" \
129 " crt_file=%%s Your own cert and chain (in bottom to top order, top may be omitted)\n" \
130 " default: \"\" (pre-loaded)\n" \
131 " key_file=%%s default: \"\" (pre-loaded)\n"
132 #else
133 #define USAGE_IO \
134 " No file operations available (MBEDTLS_FS_IO not defined)\n"
135 #endif /* MBEDTLS_FS_IO */
136 #else
137 #define USAGE_IO ""
138 #endif /* MBEDTLS_X509_CRT_PARSE_C */
139
140 #if defined(MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED)
141 #define USAGE_PSK \
142 " psk=%%s default: \"\" (in hex, without 0x)\n" \
143 " psk_identity=%%s default: \"Client_identity\"\n"
144 #else
145 #define USAGE_PSK ""
146 #endif /* MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED */
147
148 #if defined(MBEDTLS_SSL_SESSION_TICKETS)
149 #define USAGE_TICKETS \
150 " tickets=%%d default: 1 (enabled)\n"
151 #else
152 #define USAGE_TICKETS ""
153 #endif /* MBEDTLS_SSL_SESSION_TICKETS */
154
155 #if defined(MBEDTLS_SSL_TRUNCATED_HMAC)
156 #define USAGE_TRUNC_HMAC \
157 " trunc_hmac=%%d default: library default\n"
158 #else
159 #define USAGE_TRUNC_HMAC ""
160 #endif /* MBEDTLS_SSL_TRUNCATED_HMAC */
161
162 #if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
163 #define USAGE_MAX_FRAG_LEN \
164 " max_frag_len=%%d default: 16384 (tls default)\n" \
165 " options: 512, 1024, 2048, 4096\n"
166 #else
167 #define USAGE_MAX_FRAG_LEN ""
168 #endif /* MBEDTLS_SSL_MAX_FRAGMENT_LENGTH */
169
170 #if defined(MBEDTLS_SSL_CBC_RECORD_SPLITTING)
171 #define USAGE_RECSPLIT \
172 " recsplit=0/1 default: (library default: on)\n"
173 #else
174 #define USAGE_RECSPLIT
175 #endif
176
177 #if defined(MBEDTLS_DHM_C)
178 #define USAGE_DHMLEN \
179 " dhmlen=%%d default: (library default: 1024 bits)\n"
180 #else
181 #define USAGE_DHMLEN
182 #endif
183
184 #if defined(MBEDTLS_SSL_ALPN)
185 #define USAGE_ALPN \
186 " alpn=%%s default: \"\" (disabled)\n" \
187 " example: spdy/1,http/1.1\n"
188 #else
189 #define USAGE_ALPN ""
190 #endif /* MBEDTLS_SSL_ALPN */
191
192 #if defined(MBEDTLS_ECP_C)
193 #define USAGE_CURVES \
194 " curves=a,b,c,d default: \"default\" (library default)\n" \
195 " example: \"secp521r1,brainpoolP512r1\"\n" \
196 " - use \"none\" for empty list\n" \
197 " - see mbedtls_ecp_curve_list()\n" \
198 " for acceptable curve names\n"
199 #else
200 #define USAGE_CURVES ""
201 #endif
202
203 #if defined(MBEDTLS_SSL_PROTO_DTLS)
204 #define USAGE_DTLS \
205 " dtls=%%d default: 0 (TLS)\n" \
206 " hs_timeout=%%d-%%d default: (library default: 1000-60000)\n" \
207 " range of DTLS handshake timeouts in millisecs\n" \
208 " mtu=%%d default: (library default: unlimited)\n" \
209 " dgram_packing=%%d default: 1 (allowed)\n" \
210 " allow or forbid packing of multiple\n" \
211 " records within a single datgram.\n"
212 #else
213 #define USAGE_DTLS ""
214 #endif
215
216 #if defined(MBEDTLS_SSL_FALLBACK_SCSV)
217 #define USAGE_FALLBACK \
218 " fallback=0/1 default: (library default: off)\n"
219 #else
220 #define USAGE_FALLBACK ""
221 #endif
222
223 #if defined(MBEDTLS_SSL_EXTENDED_MASTER_SECRET)
224 #define USAGE_EMS \
225 " extended_ms=0/1 default: (library default: on)\n"
226 #else
227 #define USAGE_EMS ""
228 #endif
229
230 #if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
231 #define USAGE_ETM \
232 " etm=0/1 default: (library default: on)\n"
233 #else
234 #define USAGE_ETM ""
235 #endif
236
237 #if defined(MBEDTLS_SSL_RENEGOTIATION)
238 #define USAGE_RENEGO \
239 " renegotiation=%%d default: 0 (disabled)\n" \
240 " renegotiate=%%d default: 0 (disabled)\n"
241 #else
242 #define USAGE_RENEGO ""
243 #endif
244
245 #if defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
246 #define USAGE_ECJPAKE \
247 " ecjpake_pw=%%s default: none (disabled)\n"
248 #else
249 #define USAGE_ECJPAKE ""
250 #endif
251
252 #if defined(MBEDTLS_ECP_RESTARTABLE)
253 #define USAGE_ECRESTART \
254 " ec_max_ops=%%s default: library default (restart disabled)\n"
255 #else
256 #define USAGE_ECRESTART ""
257 #endif
258
259 #define USAGE \
260 "\n usage: ssl_client2 param=<>...\n" \
261 "\n acceptable parameters:\n" \
262 " server_name=%%s default: localhost\n" \
263 " server_addr=%%s default: given by name\n" \
264 " server_port=%%d default: 4433\n" \
265 " request_page=%%s default: \".\"\n" \
266 " request_size=%%d default: about 34 (basic request)\n" \
267 " (minimum: 0, max: " MAX_REQUEST_SIZE_STR ")\n" \
268 " If 0, in the first exchange only an empty\n" \
269 " application data message is sent followed by\n" \
270 " a second non-empty message before attempting\n" \
271 " to read a response from the server\n" \
272 " debug_level=%%d default: 0 (disabled)\n" \
273 " nbio=%%d default: 0 (blocking I/O)\n" \
274 " options: 1 (non-blocking), 2 (added delays)\n" \
275 " event=%%d default: 0 (loop)\n" \
276 " options: 1 (level-triggered, implies nbio=1),\n" \
277 " read_timeout=%%d default: 0 ms (no timeout)\n" \
278 " max_resend=%%d default: 0 (no resend on timeout)\n" \
279 "\n" \
280 USAGE_DTLS \
281 "\n" \
282 " auth_mode=%%s default: (library default: none)\n" \
283 " options: none, optional, required\n" \
284 USAGE_IO \
285 "\n" \
286 USAGE_PSK \
287 USAGE_ECJPAKE \
288 USAGE_ECRESTART \
289 "\n" \
290 " allow_legacy=%%d default: (library default: no)\n" \
291 USAGE_RENEGO \
292 " exchanges=%%d default: 1\n" \
293 " reconnect=%%d default: 0 (disabled)\n" \
294 " reco_delay=%%d default: 0 seconds\n" \
295 " reconnect_hard=%%d default: 0 (disabled)\n" \
296 USAGE_TICKETS \
297 USAGE_MAX_FRAG_LEN \
298 USAGE_TRUNC_HMAC \
299 USAGE_ALPN \
300 USAGE_FALLBACK \
301 USAGE_EMS \
302 USAGE_ETM \
303 USAGE_CURVES \
304 USAGE_RECSPLIT \
305 USAGE_DHMLEN \
306 "\n" \
307 " arc4=%%d default: (library default: 0)\n" \
308 " allow_sha1=%%d default: 0\n" \
309 " min_version=%%s default: (library default: tls1)\n" \
310 " max_version=%%s default: (library default: tls1_2)\n" \
311 " force_version=%%s default: \"\" (none)\n" \
312 " options: ssl3, tls1, tls1_1, tls1_2, dtls1, dtls1_2\n" \
313 "\n" \
314 " force_ciphersuite=<name> default: all enabled\n"\
315 " acceptable ciphersuite names:\n"
316
317 #define ALPN_LIST_SIZE 10
318 #define CURVE_LIST_SIZE 20
319
320 #if defined(MBEDTLS_CHECK_PARAMS)
321 #include "mbedtls/platform_util.h"
mbedtls_param_failed(const char * failure_condition,const char * file,int line)322 void mbedtls_param_failed( const char *failure_condition,
323 const char *file,
324 int line )
325 {
326 mbedtls_printf( "%s:%i: Input param failed - %s\n",
327 file, line, failure_condition );
328 mbedtls_exit( MBEDTLS_EXIT_FAILURE );
329 }
330 #endif
331
332 /*
333 * global options
334 */
335 struct options
336 {
337 const char *server_name; /* hostname of the server (client only) */
338 const char *server_addr; /* address of the server (client only) */
339 const char *server_port; /* port on which the ssl service runs */
340 int debug_level; /* level of debugging */
341 int nbio; /* should I/O be blocking? */
342 int event; /* loop or event-driven IO? level or edge triggered? */
343 uint32_t read_timeout; /* timeout on mbedtls_ssl_read() in milliseconds */
344 int max_resend; /* DTLS times to resend on read timeout */
345 const char *request_page; /* page on server to request */
346 int request_size; /* pad request with header to requested size */
347 const char *ca_file; /* the file with the CA certificate(s) */
348 const char *ca_path; /* the path with the CA certificate(s) reside */
349 const char *crt_file; /* the file with the client certificate */
350 const char *key_file; /* the file with the client key */
351 const char *psk; /* the pre-shared key */
352 const char *psk_identity; /* the pre-shared key identity */
353 const char *ecjpake_pw; /* the EC J-PAKE password */
354 int ec_max_ops; /* EC consecutive operations limit */
355 int force_ciphersuite[2]; /* protocol/ciphersuite to use, or all */
356 int renegotiation; /* enable / disable renegotiation */
357 int allow_legacy; /* allow legacy renegotiation */
358 int renegotiate; /* attempt renegotiation? */
359 int renego_delay; /* delay before enforcing renegotiation */
360 int exchanges; /* number of data exchanges */
361 int min_version; /* minimum protocol version accepted */
362 int max_version; /* maximum protocol version accepted */
363 int arc4; /* flag for arc4 suites support */
364 int allow_sha1; /* flag for SHA-1 support */
365 int auth_mode; /* verify mode for connection */
366 unsigned char mfl_code; /* code for maximum fragment length */
367 int trunc_hmac; /* negotiate truncated hmac or not */
368 int recsplit; /* enable record splitting? */
369 int dhmlen; /* minimum DHM params len in bits */
370 int reconnect; /* attempt to resume session */
371 int reco_delay; /* delay in seconds before resuming session */
372 int reconnect_hard; /* unexpectedly reconnect from the same port */
373 int tickets; /* enable / disable session tickets */
374 const char *curves; /* list of supported elliptic curves */
375 const char *alpn_string; /* ALPN supported protocols */
376 int transport; /* TLS or DTLS? */
377 uint32_t hs_to_min; /* Initial value of DTLS handshake timer */
378 uint32_t hs_to_max; /* Max value of DTLS handshake timer */
379 int dtls_mtu; /* UDP Maximum tranport unit for DTLS */
380 int fallback; /* is this a fallback connection? */
381 int dgram_packing; /* allow/forbid datagram packing */
382 int extended_ms; /* negotiate extended master secret? */
383 int etm; /* negotiate encrypt then mac? */
384 } opt;
385
my_debug(void * ctx,int level,const char * file,int line,const char * str)386 static void my_debug( void *ctx, int level,
387 const char *file, int line,
388 const char *str )
389 {
390 const char *p, *basename;
391
392 /* Extract basename from file */
393 for( p = basename = file; *p != '\0'; p++ )
394 if( *p == '/' || *p == '\\' )
395 basename = p + 1;
396
397 mbedtls_fprintf( (FILE *) ctx, "%s:%04d: |%d| %s",
398 basename, line, level, str );
399 fflush( (FILE *) ctx );
400 }
401
402 /*
403 * Test recv/send functions that make sure each try returns
404 * WANT_READ/WANT_WRITE at least once before sucesseding
405 */
my_recv(void * ctx,unsigned char * buf,size_t len)406 static int my_recv( void *ctx, unsigned char *buf, size_t len )
407 {
408 static int first_try = 1;
409 int ret;
410
411 if( first_try )
412 {
413 first_try = 0;
414 return( MBEDTLS_ERR_SSL_WANT_READ );
415 }
416
417 ret = mbedtls_net_recv( ctx, buf, len );
418 if( ret != MBEDTLS_ERR_SSL_WANT_READ )
419 first_try = 1; /* Next call will be a new operation */
420 return( ret );
421 }
422
my_send(void * ctx,const unsigned char * buf,size_t len)423 static int my_send( void *ctx, const unsigned char *buf, size_t len )
424 {
425 static int first_try = 1;
426 int ret;
427
428 if( first_try )
429 {
430 first_try = 0;
431 return( MBEDTLS_ERR_SSL_WANT_WRITE );
432 }
433
434 ret = mbedtls_net_send( ctx, buf, len );
435 if( ret != MBEDTLS_ERR_SSL_WANT_WRITE )
436 first_try = 1; /* Next call will be a new operation */
437 return( ret );
438 }
439
440 #if defined(MBEDTLS_X509_CRT_PARSE_C)
441 /*
442 * Enabled if debug_level > 1 in code below
443 */
my_verify(void * data,mbedtls_x509_crt * crt,int depth,uint32_t * flags)444 static int my_verify( void *data, mbedtls_x509_crt *crt,
445 int depth, uint32_t *flags )
446 {
447 char buf[1024];
448 ((void) data);
449
450 mbedtls_printf( "\nVerify requested for (Depth %d):\n", depth );
451 mbedtls_x509_crt_info( buf, sizeof( buf ) - 1, "", crt );
452 mbedtls_printf( "%s", buf );
453
454 if ( ( *flags ) == 0 )
455 mbedtls_printf( " This certificate has no flags\n" );
456 else
457 {
458 mbedtls_x509_crt_verify_info( buf, sizeof( buf ), " ! ", *flags );
459 mbedtls_printf( "%s\n", buf );
460 }
461
462 return( 0 );
463 }
464
465 static int ssl_sig_hashes_for_test[] = {
466 #if defined(MBEDTLS_SHA512_C)
467 MBEDTLS_MD_SHA512,
468 MBEDTLS_MD_SHA384,
469 #endif
470 #if defined(MBEDTLS_SHA256_C)
471 MBEDTLS_MD_SHA256,
472 MBEDTLS_MD_SHA224,
473 #endif
474 #if defined(MBEDTLS_SHA1_C)
475 /* Allow SHA-1 as we use it extensively in tests. */
476 MBEDTLS_MD_SHA1,
477 #endif
478 MBEDTLS_MD_NONE
479 };
480 #endif /* MBEDTLS_X509_CRT_PARSE_C */
481
482 /*
483 * Wait for an event from the underlying transport or the timer
484 * (Used in event-driven IO mode).
485 */
486 #if !defined(MBEDTLS_TIMING_C)
idle(mbedtls_net_context * fd,int idle_reason)487 int idle( mbedtls_net_context *fd,
488 int idle_reason )
489 #else
490 int idle( mbedtls_net_context *fd,
491 mbedtls_timing_delay_context *timer,
492 int idle_reason )
493 #endif
494 {
495
496 int ret;
497 int poll_type = 0;
498
499 if( idle_reason == MBEDTLS_ERR_SSL_WANT_WRITE )
500 poll_type = MBEDTLS_NET_POLL_WRITE;
501 else if( idle_reason == MBEDTLS_ERR_SSL_WANT_READ )
502 poll_type = MBEDTLS_NET_POLL_READ;
503 #if !defined(MBEDTLS_TIMING_C)
504 else
505 return( 0 );
506 #endif
507
508 while( 1 )
509 {
510 /* Check if timer has expired */
511 #if defined(MBEDTLS_TIMING_C)
512 if( timer != NULL &&
513 mbedtls_timing_get_delay( timer ) == 2 )
514 {
515 break;
516 }
517 #endif /* MBEDTLS_TIMING_C */
518
519 /* Check if underlying transport became available */
520 if( poll_type != 0 )
521 {
522 ret = mbedtls_net_poll( fd, poll_type, 0 );
523 if( ret < 0 )
524 return( ret );
525 if( ret == poll_type )
526 break;
527 }
528 }
529
530 return( 0 );
531 }
532
main(int argc,char * argv[])533 int main( int argc, char *argv[] )
534 {
535 int ret = 0, len, tail_len, i, written, frags, retry_left;
536 mbedtls_net_context server_fd;
537
538 unsigned char buf[MAX_REQUEST_SIZE + 1];
539
540 #if defined(MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED)
541 unsigned char psk[MBEDTLS_PSK_MAX_LEN];
542 size_t psk_len = 0;
543 #endif
544 #if defined(MBEDTLS_SSL_ALPN)
545 const char *alpn_list[ALPN_LIST_SIZE];
546 #endif
547 #if defined(MBEDTLS_ECP_C)
548 mbedtls_ecp_group_id curve_list[CURVE_LIST_SIZE];
549 const mbedtls_ecp_curve_info *curve_cur;
550 #endif
551
552 const char *pers = "ssl_client2";
553
554 #if defined(MBEDTLS_X509_CRT_PARSE_C)
555 mbedtls_x509_crt_profile crt_profile_for_test = mbedtls_x509_crt_profile_default;
556 #endif
557 mbedtls_entropy_context entropy;
558 mbedtls_ctr_drbg_context ctr_drbg;
559 mbedtls_ssl_context ssl;
560 mbedtls_ssl_config conf;
561 mbedtls_ssl_session saved_session;
562 #if defined(MBEDTLS_TIMING_C)
563 mbedtls_timing_delay_context timer;
564 #endif
565 #if defined(MBEDTLS_X509_CRT_PARSE_C)
566 uint32_t flags;
567 mbedtls_x509_crt cacert;
568 mbedtls_x509_crt clicert;
569 mbedtls_pk_context pkey;
570 #endif
571 char *p, *q;
572 const int *list;
573
574 /*
575 * Make sure memory references are valid.
576 */
577 mbedtls_net_init( &server_fd );
578 mbedtls_ssl_init( &ssl );
579 mbedtls_ssl_config_init( &conf );
580 memset( &saved_session, 0, sizeof( mbedtls_ssl_session ) );
581 mbedtls_ctr_drbg_init( &ctr_drbg );
582 #if defined(MBEDTLS_X509_CRT_PARSE_C)
583 mbedtls_x509_crt_init( &cacert );
584 mbedtls_x509_crt_init( &clicert );
585 mbedtls_pk_init( &pkey );
586 #endif
587 #if defined(MBEDTLS_SSL_ALPN)
588 memset( (void * ) alpn_list, 0, sizeof( alpn_list ) );
589 #endif
590
591 if( argc == 0 )
592 {
593 usage:
594 if( ret == 0 )
595 ret = 1;
596
597 mbedtls_printf( USAGE );
598
599 list = mbedtls_ssl_list_ciphersuites();
600 while( *list )
601 {
602 mbedtls_printf(" %-42s", mbedtls_ssl_get_ciphersuite_name( *list ) );
603 list++;
604 if( !*list )
605 break;
606 mbedtls_printf(" %s\n", mbedtls_ssl_get_ciphersuite_name( *list ) );
607 list++;
608 }
609 mbedtls_printf("\n");
610 goto exit;
611 }
612
613 opt.server_name = DFL_SERVER_NAME;
614 opt.server_addr = DFL_SERVER_ADDR;
615 opt.server_port = DFL_SERVER_PORT;
616 opt.debug_level = DFL_DEBUG_LEVEL;
617 opt.nbio = DFL_NBIO;
618 opt.event = DFL_EVENT;
619 opt.read_timeout = DFL_READ_TIMEOUT;
620 opt.max_resend = DFL_MAX_RESEND;
621 opt.request_page = DFL_REQUEST_PAGE;
622 opt.request_size = DFL_REQUEST_SIZE;
623 opt.ca_file = DFL_CA_FILE;
624 opt.ca_path = DFL_CA_PATH;
625 opt.crt_file = DFL_CRT_FILE;
626 opt.key_file = DFL_KEY_FILE;
627 opt.psk = DFL_PSK;
628 opt.psk_identity = DFL_PSK_IDENTITY;
629 opt.ecjpake_pw = DFL_ECJPAKE_PW;
630 opt.ec_max_ops = DFL_EC_MAX_OPS;
631 opt.force_ciphersuite[0]= DFL_FORCE_CIPHER;
632 opt.renegotiation = DFL_RENEGOTIATION;
633 opt.allow_legacy = DFL_ALLOW_LEGACY;
634 opt.renegotiate = DFL_RENEGOTIATE;
635 opt.exchanges = DFL_EXCHANGES;
636 opt.min_version = DFL_MIN_VERSION;
637 opt.max_version = DFL_MAX_VERSION;
638 opt.arc4 = DFL_ARC4;
639 opt.allow_sha1 = DFL_SHA1;
640 opt.auth_mode = DFL_AUTH_MODE;
641 opt.mfl_code = DFL_MFL_CODE;
642 opt.trunc_hmac = DFL_TRUNC_HMAC;
643 opt.recsplit = DFL_RECSPLIT;
644 opt.dhmlen = DFL_DHMLEN;
645 opt.reconnect = DFL_RECONNECT;
646 opt.reco_delay = DFL_RECO_DELAY;
647 opt.reconnect_hard = DFL_RECONNECT_HARD;
648 opt.tickets = DFL_TICKETS;
649 opt.alpn_string = DFL_ALPN_STRING;
650 opt.curves = DFL_CURVES;
651 opt.transport = DFL_TRANSPORT;
652 opt.hs_to_min = DFL_HS_TO_MIN;
653 opt.hs_to_max = DFL_HS_TO_MAX;
654 opt.dtls_mtu = DFL_DTLS_MTU;
655 opt.fallback = DFL_FALLBACK;
656 opt.extended_ms = DFL_EXTENDED_MS;
657 opt.etm = DFL_ETM;
658 opt.dgram_packing = DFL_DGRAM_PACKING;
659
660 for( i = 1; i < argc; i++ )
661 {
662 p = argv[i];
663 if( ( q = strchr( p, '=' ) ) == NULL )
664 goto usage;
665 *q++ = '\0';
666
667 if( strcmp( p, "server_name" ) == 0 )
668 opt.server_name = q;
669 else if( strcmp( p, "server_addr" ) == 0 )
670 opt.server_addr = q;
671 else if( strcmp( p, "server_port" ) == 0 )
672 opt.server_port = q;
673 else if( strcmp( p, "dtls" ) == 0 )
674 {
675 int t = atoi( q );
676 if( t == 0 )
677 opt.transport = MBEDTLS_SSL_TRANSPORT_STREAM;
678 else if( t == 1 )
679 opt.transport = MBEDTLS_SSL_TRANSPORT_DATAGRAM;
680 else
681 goto usage;
682 }
683 else if( strcmp( p, "debug_level" ) == 0 )
684 {
685 opt.debug_level = atoi( q );
686 if( opt.debug_level < 0 || opt.debug_level > 65535 )
687 goto usage;
688 }
689 else if( strcmp( p, "nbio" ) == 0 )
690 {
691 opt.nbio = atoi( q );
692 if( opt.nbio < 0 || opt.nbio > 2 )
693 goto usage;
694 }
695 else if( strcmp( p, "event" ) == 0 )
696 {
697 opt.event = atoi( q );
698 if( opt.event < 0 || opt.event > 2 )
699 goto usage;
700 }
701 else if( strcmp( p, "read_timeout" ) == 0 )
702 opt.read_timeout = atoi( q );
703 else if( strcmp( p, "max_resend" ) == 0 )
704 {
705 opt.max_resend = atoi( q );
706 if( opt.max_resend < 0 )
707 goto usage;
708 }
709 else if( strcmp( p, "request_page" ) == 0 )
710 opt.request_page = q;
711 else if( strcmp( p, "request_size" ) == 0 )
712 {
713 opt.request_size = atoi( q );
714 if( opt.request_size < 0 ||
715 opt.request_size > MAX_REQUEST_SIZE )
716 goto usage;
717 }
718 else if( strcmp( p, "ca_file" ) == 0 )
719 opt.ca_file = q;
720 else if( strcmp( p, "ca_path" ) == 0 )
721 opt.ca_path = q;
722 else if( strcmp( p, "crt_file" ) == 0 )
723 opt.crt_file = q;
724 else if( strcmp( p, "key_file" ) == 0 )
725 opt.key_file = q;
726 else if( strcmp( p, "psk" ) == 0 )
727 opt.psk = q;
728 else if( strcmp( p, "psk_identity" ) == 0 )
729 opt.psk_identity = q;
730 else if( strcmp( p, "ecjpake_pw" ) == 0 )
731 opt.ecjpake_pw = q;
732 else if( strcmp( p, "ec_max_ops" ) == 0 )
733 opt.ec_max_ops = atoi( q );
734 else if( strcmp( p, "force_ciphersuite" ) == 0 )
735 {
736 opt.force_ciphersuite[0] = mbedtls_ssl_get_ciphersuite_id( q );
737
738 if( opt.force_ciphersuite[0] == 0 )
739 {
740 ret = 2;
741 goto usage;
742 }
743 opt.force_ciphersuite[1] = 0;
744 }
745 else if( strcmp( p, "renegotiation" ) == 0 )
746 {
747 opt.renegotiation = (atoi( q )) ?
748 MBEDTLS_SSL_RENEGOTIATION_ENABLED :
749 MBEDTLS_SSL_RENEGOTIATION_DISABLED;
750 }
751 else if( strcmp( p, "allow_legacy" ) == 0 )
752 {
753 switch( atoi( q ) )
754 {
755 case -1:
756 opt.allow_legacy = MBEDTLS_SSL_LEGACY_BREAK_HANDSHAKE;
757 break;
758 case 0:
759 opt.allow_legacy = MBEDTLS_SSL_LEGACY_NO_RENEGOTIATION;
760 break;
761 case 1:
762 opt.allow_legacy = MBEDTLS_SSL_LEGACY_ALLOW_RENEGOTIATION;
763 break;
764 default: goto usage;
765 }
766 }
767 else if( strcmp( p, "renegotiate" ) == 0 )
768 {
769 opt.renegotiate = atoi( q );
770 if( opt.renegotiate < 0 || opt.renegotiate > 1 )
771 goto usage;
772 }
773 else if( strcmp( p, "exchanges" ) == 0 )
774 {
775 opt.exchanges = atoi( q );
776 if( opt.exchanges < 1 )
777 goto usage;
778 }
779 else if( strcmp( p, "reconnect" ) == 0 )
780 {
781 opt.reconnect = atoi( q );
782 if( opt.reconnect < 0 || opt.reconnect > 2 )
783 goto usage;
784 }
785 else if( strcmp( p, "reco_delay" ) == 0 )
786 {
787 opt.reco_delay = atoi( q );
788 if( opt.reco_delay < 0 )
789 goto usage;
790 }
791 else if( strcmp( p, "reconnect_hard" ) == 0 )
792 {
793 opt.reconnect_hard = atoi( q );
794 if( opt.reconnect_hard < 0 || opt.reconnect_hard > 1 )
795 goto usage;
796 }
797 else if( strcmp( p, "tickets" ) == 0 )
798 {
799 opt.tickets = atoi( q );
800 if( opt.tickets < 0 || opt.tickets > 2 )
801 goto usage;
802 }
803 else if( strcmp( p, "alpn" ) == 0 )
804 {
805 opt.alpn_string = q;
806 }
807 else if( strcmp( p, "fallback" ) == 0 )
808 {
809 switch( atoi( q ) )
810 {
811 case 0: opt.fallback = MBEDTLS_SSL_IS_NOT_FALLBACK; break;
812 case 1: opt.fallback = MBEDTLS_SSL_IS_FALLBACK; break;
813 default: goto usage;
814 }
815 }
816 else if( strcmp( p, "extended_ms" ) == 0 )
817 {
818 switch( atoi( q ) )
819 {
820 case 0:
821 opt.extended_ms = MBEDTLS_SSL_EXTENDED_MS_DISABLED;
822 break;
823 case 1:
824 opt.extended_ms = MBEDTLS_SSL_EXTENDED_MS_ENABLED;
825 break;
826 default: goto usage;
827 }
828 }
829 else if( strcmp( p, "curves" ) == 0 )
830 opt.curves = q;
831 else if( strcmp( p, "etm" ) == 0 )
832 {
833 switch( atoi( q ) )
834 {
835 case 0: opt.etm = MBEDTLS_SSL_ETM_DISABLED; break;
836 case 1: opt.etm = MBEDTLS_SSL_ETM_ENABLED; break;
837 default: goto usage;
838 }
839 }
840 else if( strcmp( p, "min_version" ) == 0 )
841 {
842 if( strcmp( q, "ssl3" ) == 0 )
843 opt.min_version = MBEDTLS_SSL_MINOR_VERSION_0;
844 else if( strcmp( q, "tls1" ) == 0 )
845 opt.min_version = MBEDTLS_SSL_MINOR_VERSION_1;
846 else if( strcmp( q, "tls1_1" ) == 0 ||
847 strcmp( q, "dtls1" ) == 0 )
848 opt.min_version = MBEDTLS_SSL_MINOR_VERSION_2;
849 else if( strcmp( q, "tls1_2" ) == 0 ||
850 strcmp( q, "dtls1_2" ) == 0 )
851 opt.min_version = MBEDTLS_SSL_MINOR_VERSION_3;
852 else
853 goto usage;
854 }
855 else if( strcmp( p, "max_version" ) == 0 )
856 {
857 if( strcmp( q, "ssl3" ) == 0 )
858 opt.max_version = MBEDTLS_SSL_MINOR_VERSION_0;
859 else if( strcmp( q, "tls1" ) == 0 )
860 opt.max_version = MBEDTLS_SSL_MINOR_VERSION_1;
861 else if( strcmp( q, "tls1_1" ) == 0 ||
862 strcmp( q, "dtls1" ) == 0 )
863 opt.max_version = MBEDTLS_SSL_MINOR_VERSION_2;
864 else if( strcmp( q, "tls1_2" ) == 0 ||
865 strcmp( q, "dtls1_2" ) == 0 )
866 opt.max_version = MBEDTLS_SSL_MINOR_VERSION_3;
867 else
868 goto usage;
869 }
870 else if( strcmp( p, "arc4" ) == 0 )
871 {
872 switch( atoi( q ) )
873 {
874 case 0: opt.arc4 = MBEDTLS_SSL_ARC4_DISABLED; break;
875 case 1: opt.arc4 = MBEDTLS_SSL_ARC4_ENABLED; break;
876 default: goto usage;
877 }
878 }
879 else if( strcmp( p, "allow_sha1" ) == 0 )
880 {
881 switch( atoi( q ) )
882 {
883 case 0: opt.allow_sha1 = 0; break;
884 case 1: opt.allow_sha1 = 1; break;
885 default: goto usage;
886 }
887 }
888 else if( strcmp( p, "force_version" ) == 0 )
889 {
890 if( strcmp( q, "ssl3" ) == 0 )
891 {
892 opt.min_version = MBEDTLS_SSL_MINOR_VERSION_0;
893 opt.max_version = MBEDTLS_SSL_MINOR_VERSION_0;
894 }
895 else if( strcmp( q, "tls1" ) == 0 )
896 {
897 opt.min_version = MBEDTLS_SSL_MINOR_VERSION_1;
898 opt.max_version = MBEDTLS_SSL_MINOR_VERSION_1;
899 }
900 else if( strcmp( q, "tls1_1" ) == 0 )
901 {
902 opt.min_version = MBEDTLS_SSL_MINOR_VERSION_2;
903 opt.max_version = MBEDTLS_SSL_MINOR_VERSION_2;
904 }
905 else if( strcmp( q, "tls1_2" ) == 0 )
906 {
907 opt.min_version = MBEDTLS_SSL_MINOR_VERSION_3;
908 opt.max_version = MBEDTLS_SSL_MINOR_VERSION_3;
909 }
910 else if( strcmp( q, "dtls1" ) == 0 )
911 {
912 opt.min_version = MBEDTLS_SSL_MINOR_VERSION_2;
913 opt.max_version = MBEDTLS_SSL_MINOR_VERSION_2;
914 opt.transport = MBEDTLS_SSL_TRANSPORT_DATAGRAM;
915 }
916 else if( strcmp( q, "dtls1_2" ) == 0 )
917 {
918 opt.min_version = MBEDTLS_SSL_MINOR_VERSION_3;
919 opt.max_version = MBEDTLS_SSL_MINOR_VERSION_3;
920 opt.transport = MBEDTLS_SSL_TRANSPORT_DATAGRAM;
921 }
922 else
923 goto usage;
924 }
925 else if( strcmp( p, "auth_mode" ) == 0 )
926 {
927 if( strcmp( q, "none" ) == 0 )
928 opt.auth_mode = MBEDTLS_SSL_VERIFY_NONE;
929 else if( strcmp( q, "optional" ) == 0 )
930 opt.auth_mode = MBEDTLS_SSL_VERIFY_OPTIONAL;
931 else if( strcmp( q, "required" ) == 0 )
932 opt.auth_mode = MBEDTLS_SSL_VERIFY_REQUIRED;
933 else
934 goto usage;
935 }
936 else if( strcmp( p, "max_frag_len" ) == 0 )
937 {
938 if( strcmp( q, "512" ) == 0 )
939 opt.mfl_code = MBEDTLS_SSL_MAX_FRAG_LEN_512;
940 else if( strcmp( q, "1024" ) == 0 )
941 opt.mfl_code = MBEDTLS_SSL_MAX_FRAG_LEN_1024;
942 else if( strcmp( q, "2048" ) == 0 )
943 opt.mfl_code = MBEDTLS_SSL_MAX_FRAG_LEN_2048;
944 else if( strcmp( q, "4096" ) == 0 )
945 opt.mfl_code = MBEDTLS_SSL_MAX_FRAG_LEN_4096;
946 else
947 goto usage;
948 }
949 else if( strcmp( p, "trunc_hmac" ) == 0 )
950 {
951 switch( atoi( q ) )
952 {
953 case 0: opt.trunc_hmac = MBEDTLS_SSL_TRUNC_HMAC_DISABLED; break;
954 case 1: opt.trunc_hmac = MBEDTLS_SSL_TRUNC_HMAC_ENABLED; break;
955 default: goto usage;
956 }
957 }
958 else if( strcmp( p, "hs_timeout" ) == 0 )
959 {
960 if( ( p = strchr( q, '-' ) ) == NULL )
961 goto usage;
962 *p++ = '\0';
963 opt.hs_to_min = atoi( q );
964 opt.hs_to_max = atoi( p );
965 if( opt.hs_to_min == 0 || opt.hs_to_max < opt.hs_to_min )
966 goto usage;
967 }
968 else if( strcmp( p, "mtu" ) == 0 )
969 {
970 opt.dtls_mtu = atoi( q );
971 if( opt.dtls_mtu < 0 )
972 goto usage;
973 }
974 else if( strcmp( p, "dgram_packing" ) == 0 )
975 {
976 opt.dgram_packing = atoi( q );
977 if( opt.dgram_packing != 0 &&
978 opt.dgram_packing != 1 )
979 {
980 goto usage;
981 }
982 }
983 else if( strcmp( p, "recsplit" ) == 0 )
984 {
985 opt.recsplit = atoi( q );
986 if( opt.recsplit < 0 || opt.recsplit > 1 )
987 goto usage;
988 }
989 else if( strcmp( p, "dhmlen" ) == 0 )
990 {
991 opt.dhmlen = atoi( q );
992 if( opt.dhmlen < 0 )
993 goto usage;
994 }
995 else
996 goto usage;
997 }
998
999 /* Event-driven IO is incompatible with the above custom
1000 * receive and send functions, as the polling builds on
1001 * refers to the underlying net_context. */
1002 if( opt.event == 1 && opt.nbio != 1 )
1003 {
1004 mbedtls_printf( "Warning: event-driven IO mandates nbio=1 - overwrite\n" );
1005 opt.nbio = 1;
1006 }
1007
1008 #if defined(MBEDTLS_DEBUG_C)
1009 mbedtls_debug_set_threshold( opt.debug_level );
1010 #endif
1011
1012 if( opt.force_ciphersuite[0] > 0 )
1013 {
1014 const mbedtls_ssl_ciphersuite_t *ciphersuite_info;
1015 ciphersuite_info =
1016 mbedtls_ssl_ciphersuite_from_id( opt.force_ciphersuite[0] );
1017
1018 if( opt.max_version != -1 &&
1019 ciphersuite_info->min_minor_ver > opt.max_version )
1020 {
1021 mbedtls_printf( "forced ciphersuite not allowed with this protocol version\n" );
1022 ret = 2;
1023 goto usage;
1024 }
1025 if( opt.min_version != -1 &&
1026 ciphersuite_info->max_minor_ver < opt.min_version )
1027 {
1028 mbedtls_printf( "forced ciphersuite not allowed with this protocol version\n" );
1029 ret = 2;
1030 goto usage;
1031 }
1032
1033 /* If the server selects a version that's not supported by
1034 * this suite, then there will be no common ciphersuite... */
1035 if( opt.max_version == -1 ||
1036 opt.max_version > ciphersuite_info->max_minor_ver )
1037 {
1038 opt.max_version = ciphersuite_info->max_minor_ver;
1039 }
1040 if( opt.min_version < ciphersuite_info->min_minor_ver )
1041 {
1042 opt.min_version = ciphersuite_info->min_minor_ver;
1043 /* DTLS starts with TLS 1.1 */
1044 if( opt.transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM &&
1045 opt.min_version < MBEDTLS_SSL_MINOR_VERSION_2 )
1046 opt.min_version = MBEDTLS_SSL_MINOR_VERSION_2;
1047 }
1048
1049 /* Enable RC4 if needed and not explicitly disabled */
1050 if( ciphersuite_info->cipher == MBEDTLS_CIPHER_ARC4_128 )
1051 {
1052 if( opt.arc4 == MBEDTLS_SSL_ARC4_DISABLED )
1053 {
1054 mbedtls_printf( "forced RC4 ciphersuite with RC4 disabled\n" );
1055 ret = 2;
1056 goto usage;
1057 }
1058
1059 opt.arc4 = MBEDTLS_SSL_ARC4_ENABLED;
1060 }
1061 }
1062
1063 #if defined(MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED)
1064 /*
1065 * Unhexify the pre-shared key if any is given
1066 */
1067 if( strlen( opt.psk ) )
1068 {
1069 unsigned char c;
1070 size_t j;
1071
1072 if( strlen( opt.psk ) % 2 != 0 )
1073 {
1074 mbedtls_printf( "pre-shared key not valid hex\n" );
1075 goto exit;
1076 }
1077
1078 psk_len = strlen( opt.psk ) / 2;
1079
1080 for( j = 0; j < strlen( opt.psk ); j += 2 )
1081 {
1082 c = opt.psk[j];
1083 if( c >= '0' && c <= '9' )
1084 c -= '0';
1085 else if( c >= 'a' && c <= 'f' )
1086 c -= 'a' - 10;
1087 else if( c >= 'A' && c <= 'F' )
1088 c -= 'A' - 10;
1089 else
1090 {
1091 mbedtls_printf( "pre-shared key not valid hex\n" );
1092 goto exit;
1093 }
1094 psk[ j / 2 ] = c << 4;
1095
1096 c = opt.psk[j + 1];
1097 if( c >= '0' && c <= '9' )
1098 c -= '0';
1099 else if( c >= 'a' && c <= 'f' )
1100 c -= 'a' - 10;
1101 else if( c >= 'A' && c <= 'F' )
1102 c -= 'A' - 10;
1103 else
1104 {
1105 mbedtls_printf( "pre-shared key not valid hex\n" );
1106 goto exit;
1107 }
1108 psk[ j / 2 ] |= c;
1109 }
1110 }
1111 #endif /* MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED */
1112
1113 #if defined(MBEDTLS_ECP_C)
1114 if( opt.curves != NULL )
1115 {
1116 p = (char *) opt.curves;
1117 i = 0;
1118
1119 if( strcmp( p, "none" ) == 0 )
1120 {
1121 curve_list[0] = MBEDTLS_ECP_DP_NONE;
1122 }
1123 else if( strcmp( p, "default" ) != 0 )
1124 {
1125 /* Leave room for a final NULL in curve list */
1126 while( i < CURVE_LIST_SIZE - 1 && *p != '\0' )
1127 {
1128 q = p;
1129
1130 /* Terminate the current string */
1131 while( *p != ',' && *p != '\0' )
1132 p++;
1133 if( *p == ',' )
1134 *p++ = '\0';
1135
1136 if( ( curve_cur = mbedtls_ecp_curve_info_from_name( q ) ) != NULL )
1137 {
1138 curve_list[i++] = curve_cur->grp_id;
1139 }
1140 else
1141 {
1142 mbedtls_printf( "unknown curve %s\n", q );
1143 mbedtls_printf( "supported curves: " );
1144 for( curve_cur = mbedtls_ecp_curve_list();
1145 curve_cur->grp_id != MBEDTLS_ECP_DP_NONE;
1146 curve_cur++ )
1147 {
1148 mbedtls_printf( "%s ", curve_cur->name );
1149 }
1150 mbedtls_printf( "\n" );
1151 goto exit;
1152 }
1153 }
1154
1155 mbedtls_printf("Number of curves: %d\n", i );
1156
1157 if( i == CURVE_LIST_SIZE - 1 && *p != '\0' )
1158 {
1159 mbedtls_printf( "curves list too long, maximum %d",
1160 CURVE_LIST_SIZE - 1 );
1161 goto exit;
1162 }
1163
1164 curve_list[i] = MBEDTLS_ECP_DP_NONE;
1165 }
1166 }
1167 #endif /* MBEDTLS_ECP_C */
1168
1169 #if defined(MBEDTLS_SSL_ALPN)
1170 if( opt.alpn_string != NULL )
1171 {
1172 p = (char *) opt.alpn_string;
1173 i = 0;
1174
1175 /* Leave room for a final NULL in alpn_list */
1176 while( i < ALPN_LIST_SIZE - 1 && *p != '\0' )
1177 {
1178 alpn_list[i++] = p;
1179
1180 /* Terminate the current string and move on to next one */
1181 while( *p != ',' && *p != '\0' )
1182 p++;
1183 if( *p == ',' )
1184 *p++ = '\0';
1185 }
1186 }
1187 #endif /* MBEDTLS_SSL_ALPN */
1188
1189 /*
1190 * 0. Initialize the RNG and the session data
1191 */
1192 mbedtls_printf( "\n . Seeding the random number generator..." );
1193 fflush( stdout );
1194
1195 mbedtls_entropy_init( &entropy );
1196 if( ( ret = mbedtls_ctr_drbg_seed( &ctr_drbg, mbedtls_entropy_func,
1197 &entropy, (const unsigned char *) pers,
1198 strlen( pers ) ) ) != 0 )
1199 {
1200 mbedtls_printf( " failed\n ! mbedtls_ctr_drbg_seed returned -0x%x\n",
1201 -ret );
1202 goto exit;
1203 }
1204
1205 mbedtls_printf( " ok\n" );
1206
1207 #if defined(MBEDTLS_X509_CRT_PARSE_C)
1208 /*
1209 * 1.1. Load the trusted CA
1210 */
1211 mbedtls_printf( " . Loading the CA root certificate ..." );
1212 fflush( stdout );
1213
1214 #if defined(MBEDTLS_FS_IO)
1215 if( strlen( opt.ca_path ) )
1216 if( strcmp( opt.ca_path, "none" ) == 0 )
1217 ret = 0;
1218 else
1219 ret = mbedtls_x509_crt_parse_path( &cacert, opt.ca_path );
1220 else if( strlen( opt.ca_file ) )
1221 if( strcmp( opt.ca_file, "none" ) == 0 )
1222 ret = 0;
1223 else
1224 ret = mbedtls_x509_crt_parse_file( &cacert, opt.ca_file );
1225 else
1226 #endif
1227 #if defined(MBEDTLS_CERTS_C)
1228 for( i = 0; mbedtls_test_cas[i] != NULL; i++ )
1229 {
1230 ret = mbedtls_x509_crt_parse( &cacert,
1231 (const unsigned char *) mbedtls_test_cas[i],
1232 mbedtls_test_cas_len[i] );
1233 if( ret != 0 )
1234 break;
1235 }
1236 #else
1237 {
1238 ret = 1;
1239 mbedtls_printf( "MBEDTLS_CERTS_C not defined." );
1240 }
1241 #endif
1242 if( ret < 0 )
1243 {
1244 mbedtls_printf( " failed\n ! mbedtls_x509_crt_parse returned -0x%x\n\n",
1245 -ret );
1246 goto exit;
1247 }
1248
1249 mbedtls_printf( " ok (%d skipped)\n", ret );
1250
1251 /*
1252 * 1.2. Load own certificate and private key
1253 *
1254 * (can be skipped if client authentication is not required)
1255 */
1256 mbedtls_printf( " . Loading the client cert. and key..." );
1257 fflush( stdout );
1258
1259 #if defined(MBEDTLS_FS_IO)
1260 if( strlen( opt.crt_file ) )
1261 if( strcmp( opt.crt_file, "none" ) == 0 )
1262 ret = 0;
1263 else
1264 ret = mbedtls_x509_crt_parse_file( &clicert, opt.crt_file );
1265 else
1266 #endif
1267 #if defined(MBEDTLS_CERTS_C)
1268 ret = mbedtls_x509_crt_parse( &clicert,
1269 (const unsigned char *) mbedtls_test_cli_crt,
1270 mbedtls_test_cli_crt_len );
1271 #else
1272 {
1273 ret = 1;
1274 mbedtls_printf("MBEDTLS_CERTS_C not defined.");
1275 }
1276 #endif
1277 if( ret != 0 )
1278 {
1279 mbedtls_printf( " failed\n ! mbedtls_x509_crt_parse returned -0x%x\n\n",
1280 -ret );
1281 goto exit;
1282 }
1283
1284 #if defined(MBEDTLS_FS_IO)
1285 if( strlen( opt.key_file ) )
1286 if( strcmp( opt.key_file, "none" ) == 0 )
1287 ret = 0;
1288 else
1289 ret = mbedtls_pk_parse_keyfile( &pkey, opt.key_file, "" );
1290 else
1291 #endif
1292 #if defined(MBEDTLS_CERTS_C)
1293 ret = mbedtls_pk_parse_key( &pkey,
1294 (const unsigned char *) mbedtls_test_cli_key,
1295 mbedtls_test_cli_key_len, NULL, 0 );
1296 #else
1297 {
1298 ret = 1;
1299 mbedtls_printf("MBEDTLS_CERTS_C not defined.");
1300 }
1301 #endif
1302 if( ret != 0 )
1303 {
1304 mbedtls_printf( " failed\n ! mbedtls_pk_parse_key returned -0x%x\n\n",
1305 -ret );
1306 goto exit;
1307 }
1308
1309 mbedtls_printf( " ok\n" );
1310 #endif /* MBEDTLS_X509_CRT_PARSE_C */
1311
1312 /*
1313 * 2. Start the connection
1314 */
1315 if( opt.server_addr == NULL)
1316 opt.server_addr = opt.server_name;
1317
1318 mbedtls_printf( " . Connecting to %s/%s/%s...",
1319 opt.transport == MBEDTLS_SSL_TRANSPORT_STREAM ? "tcp" : "udp",
1320 opt.server_addr, opt.server_port );
1321 fflush( stdout );
1322
1323 if( ( ret = mbedtls_net_connect( &server_fd,
1324 opt.server_addr, opt.server_port,
1325 opt.transport == MBEDTLS_SSL_TRANSPORT_STREAM ?
1326 MBEDTLS_NET_PROTO_TCP : MBEDTLS_NET_PROTO_UDP ) ) != 0 )
1327 {
1328 mbedtls_printf( " failed\n ! mbedtls_net_connect returned -0x%x\n\n",
1329 -ret );
1330 goto exit;
1331 }
1332
1333 if( opt.nbio > 0 )
1334 ret = mbedtls_net_set_nonblock( &server_fd );
1335 else
1336 ret = mbedtls_net_set_block( &server_fd );
1337 if( ret != 0 )
1338 {
1339 mbedtls_printf( " failed\n ! net_set_(non)block() returned -0x%x\n\n",
1340 -ret );
1341 goto exit;
1342 }
1343
1344 mbedtls_printf( " ok\n" );
1345
1346 /*
1347 * 3. Setup stuff
1348 */
1349 mbedtls_printf( " . Setting up the SSL/TLS structure..." );
1350 fflush( stdout );
1351
1352 if( ( ret = mbedtls_ssl_config_defaults( &conf,
1353 MBEDTLS_SSL_IS_CLIENT,
1354 opt.transport,
1355 MBEDTLS_SSL_PRESET_DEFAULT ) ) != 0 )
1356 {
1357 mbedtls_printf( " failed\n ! mbedtls_ssl_config_defaults returned -0x%x\n\n",
1358 -ret );
1359 goto exit;
1360 }
1361
1362 #if defined(MBEDTLS_X509_CRT_PARSE_C)
1363 /* The default algorithms profile disables SHA-1, but our tests still
1364 rely on it heavily. */
1365 if( opt.allow_sha1 > 0 )
1366 {
1367 crt_profile_for_test.allowed_mds |= MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA1 );
1368 mbedtls_ssl_conf_cert_profile( &conf, &crt_profile_for_test );
1369 mbedtls_ssl_conf_sig_hashes( &conf, ssl_sig_hashes_for_test );
1370 }
1371
1372 if( opt.debug_level > 0 )
1373 mbedtls_ssl_conf_verify( &conf, my_verify, NULL );
1374 #endif /* MBEDTLS_X509_CRT_PARSE_C */
1375
1376 if( opt.auth_mode != DFL_AUTH_MODE )
1377 mbedtls_ssl_conf_authmode( &conf, opt.auth_mode );
1378
1379 #if defined(MBEDTLS_SSL_PROTO_DTLS)
1380 if( opt.hs_to_min != DFL_HS_TO_MIN || opt.hs_to_max != DFL_HS_TO_MAX )
1381 mbedtls_ssl_conf_handshake_timeout( &conf, opt.hs_to_min,
1382 opt.hs_to_max );
1383
1384 if( opt.dgram_packing != DFL_DGRAM_PACKING )
1385 mbedtls_ssl_set_datagram_packing( &ssl, opt.dgram_packing );
1386 #endif /* MBEDTLS_SSL_PROTO_DTLS */
1387
1388 #if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
1389 if( ( ret = mbedtls_ssl_conf_max_frag_len( &conf, opt.mfl_code ) ) != 0 )
1390 {
1391 mbedtls_printf( " failed\n ! mbedtls_ssl_conf_max_frag_len returned %d\n\n",
1392 ret );
1393 goto exit;
1394 }
1395 #endif
1396
1397 #if defined(MBEDTLS_SSL_TRUNCATED_HMAC)
1398 if( opt.trunc_hmac != DFL_TRUNC_HMAC )
1399 mbedtls_ssl_conf_truncated_hmac( &conf, opt.trunc_hmac );
1400 #endif
1401
1402 #if defined(MBEDTLS_SSL_EXTENDED_MASTER_SECRET)
1403 if( opt.extended_ms != DFL_EXTENDED_MS )
1404 mbedtls_ssl_conf_extended_master_secret( &conf, opt.extended_ms );
1405 #endif
1406
1407 #if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
1408 if( opt.etm != DFL_ETM )
1409 mbedtls_ssl_conf_encrypt_then_mac( &conf, opt.etm );
1410 #endif
1411
1412 #if defined(MBEDTLS_SSL_CBC_RECORD_SPLITTING)
1413 if( opt.recsplit != DFL_RECSPLIT )
1414 mbedtls_ssl_conf_cbc_record_splitting( &conf, opt.recsplit
1415 ? MBEDTLS_SSL_CBC_RECORD_SPLITTING_ENABLED
1416 : MBEDTLS_SSL_CBC_RECORD_SPLITTING_DISABLED );
1417 #endif
1418
1419 #if defined(MBEDTLS_DHM_C)
1420 if( opt.dhmlen != DFL_DHMLEN )
1421 mbedtls_ssl_conf_dhm_min_bitlen( &conf, opt.dhmlen );
1422 #endif
1423
1424 #if defined(MBEDTLS_SSL_ALPN)
1425 if( opt.alpn_string != NULL )
1426 if( ( ret = mbedtls_ssl_conf_alpn_protocols( &conf, alpn_list ) ) != 0 )
1427 {
1428 mbedtls_printf( " failed\n ! mbedtls_ssl_conf_alpn_protocols returned %d\n\n",
1429 ret );
1430 goto exit;
1431 }
1432 #endif
1433
1434 mbedtls_ssl_conf_rng( &conf, mbedtls_ctr_drbg_random, &ctr_drbg );
1435 mbedtls_ssl_conf_dbg( &conf, my_debug, stdout );
1436
1437 mbedtls_ssl_conf_read_timeout( &conf, opt.read_timeout );
1438
1439 #if defined(MBEDTLS_SSL_SESSION_TICKETS)
1440 mbedtls_ssl_conf_session_tickets( &conf, opt.tickets );
1441 #endif
1442
1443 if( opt.force_ciphersuite[0] != DFL_FORCE_CIPHER )
1444 mbedtls_ssl_conf_ciphersuites( &conf, opt.force_ciphersuite );
1445
1446 #if defined(MBEDTLS_ARC4_C)
1447 if( opt.arc4 != DFL_ARC4 )
1448 mbedtls_ssl_conf_arc4_support( &conf, opt.arc4 );
1449 #endif
1450
1451 if( opt.allow_legacy != DFL_ALLOW_LEGACY )
1452 mbedtls_ssl_conf_legacy_renegotiation( &conf, opt.allow_legacy );
1453 #if defined(MBEDTLS_SSL_RENEGOTIATION)
1454 mbedtls_ssl_conf_renegotiation( &conf, opt.renegotiation );
1455 #endif
1456
1457 #if defined(MBEDTLS_X509_CRT_PARSE_C)
1458 if( strcmp( opt.ca_path, "none" ) != 0 &&
1459 strcmp( opt.ca_file, "none" ) != 0 )
1460 {
1461 mbedtls_ssl_conf_ca_chain( &conf, &cacert, NULL );
1462 }
1463 if( strcmp( opt.crt_file, "none" ) != 0 &&
1464 strcmp( opt.key_file, "none" ) != 0 )
1465 {
1466 if( ( ret = mbedtls_ssl_conf_own_cert( &conf, &clicert, &pkey ) ) != 0 )
1467 {
1468 mbedtls_printf( " failed\n ! mbedtls_ssl_conf_own_cert returned %d\n\n",
1469 ret );
1470 goto exit;
1471 }
1472 }
1473 #endif
1474
1475 #if defined(MBEDTLS_ECP_C)
1476 if( opt.curves != NULL &&
1477 strcmp( opt.curves, "default" ) != 0 )
1478 {
1479 mbedtls_ssl_conf_curves( &conf, curve_list );
1480 }
1481 #endif
1482
1483 #if defined(MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED)
1484 if( ( ret = mbedtls_ssl_conf_psk( &conf, psk, psk_len,
1485 (const unsigned char *) opt.psk_identity,
1486 strlen( opt.psk_identity ) ) ) != 0 )
1487 {
1488 mbedtls_printf( " failed\n ! mbedtls_ssl_conf_psk returned %d\n\n",
1489 ret );
1490 goto exit;
1491 }
1492 #endif
1493
1494 if( opt.min_version != DFL_MIN_VERSION )
1495 mbedtls_ssl_conf_min_version( &conf, MBEDTLS_SSL_MAJOR_VERSION_3,
1496 opt.min_version );
1497
1498 if( opt.max_version != DFL_MAX_VERSION )
1499 mbedtls_ssl_conf_max_version( &conf, MBEDTLS_SSL_MAJOR_VERSION_3,
1500 opt.max_version );
1501
1502 #if defined(MBEDTLS_SSL_FALLBACK_SCSV)
1503 if( opt.fallback != DFL_FALLBACK )
1504 mbedtls_ssl_conf_fallback( &conf, opt.fallback );
1505 #endif
1506
1507 if( ( ret = mbedtls_ssl_setup( &ssl, &conf ) ) != 0 )
1508 {
1509 mbedtls_printf( " failed\n ! mbedtls_ssl_setup returned -0x%x\n\n",
1510 -ret );
1511 goto exit;
1512 }
1513
1514 #if defined(MBEDTLS_X509_CRT_PARSE_C)
1515 if( ( ret = mbedtls_ssl_set_hostname( &ssl, opt.server_name ) ) != 0 )
1516 {
1517 mbedtls_printf( " failed\n ! mbedtls_ssl_set_hostname returned %d\n\n",
1518 ret );
1519 goto exit;
1520 }
1521 #endif
1522
1523 #if defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
1524 if( opt.ecjpake_pw != DFL_ECJPAKE_PW )
1525 {
1526 if( ( ret = mbedtls_ssl_set_hs_ecjpake_password( &ssl,
1527 (const unsigned char *) opt.ecjpake_pw,
1528 strlen( opt.ecjpake_pw ) ) ) != 0 )
1529 {
1530 mbedtls_printf( " failed\n ! mbedtls_ssl_set_hs_ecjpake_password returned %d\n\n",
1531 ret );
1532 goto exit;
1533 }
1534 }
1535 #endif
1536
1537 if( opt.nbio == 2 )
1538 mbedtls_ssl_set_bio( &ssl, &server_fd, my_send, my_recv, NULL );
1539 else
1540 mbedtls_ssl_set_bio( &ssl, &server_fd,
1541 mbedtls_net_send, mbedtls_net_recv,
1542 opt.nbio == 0 ? mbedtls_net_recv_timeout : NULL );
1543
1544 #if defined(MBEDTLS_SSL_PROTO_DTLS)
1545 if( opt.dtls_mtu != DFL_DTLS_MTU )
1546 mbedtls_ssl_set_mtu( &ssl, opt.dtls_mtu );
1547 #endif
1548
1549 #if defined(MBEDTLS_TIMING_C)
1550 mbedtls_ssl_set_timer_cb( &ssl, &timer, mbedtls_timing_set_delay,
1551 mbedtls_timing_get_delay );
1552 #endif
1553
1554 #if defined(MBEDTLS_ECP_RESTARTABLE)
1555 if( opt.ec_max_ops != DFL_EC_MAX_OPS )
1556 mbedtls_ecp_set_max_ops( opt.ec_max_ops );
1557 #endif
1558
1559 mbedtls_printf( " ok\n" );
1560
1561 /*
1562 * 4. Handshake
1563 */
1564 mbedtls_printf( " . Performing the SSL/TLS handshake..." );
1565 fflush( stdout );
1566
1567 while( ( ret = mbedtls_ssl_handshake( &ssl ) ) != 0 )
1568 {
1569 if( ret != MBEDTLS_ERR_SSL_WANT_READ &&
1570 ret != MBEDTLS_ERR_SSL_WANT_WRITE &&
1571 ret != MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS )
1572 {
1573 mbedtls_printf( " failed\n ! mbedtls_ssl_handshake returned -0x%x\n",
1574 -ret );
1575 if( ret == MBEDTLS_ERR_X509_CERT_VERIFY_FAILED )
1576 mbedtls_printf(
1577 " Unable to verify the server's certificate. "
1578 "Either it is invalid,\n"
1579 " or you didn't set ca_file or ca_path "
1580 "to an appropriate value.\n"
1581 " Alternatively, you may want to use "
1582 "auth_mode=optional for testing purposes.\n" );
1583 mbedtls_printf( "\n" );
1584 goto exit;
1585 }
1586
1587 #if defined(MBEDTLS_ECP_RESTARTABLE)
1588 if( ret == MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS )
1589 continue;
1590 #endif
1591
1592 /* For event-driven IO, wait for socket to become available */
1593 if( opt.event == 1 /* level triggered IO */ )
1594 {
1595 #if defined(MBEDTLS_TIMING_C)
1596 ret = idle( &server_fd, &timer, ret );
1597 #else
1598 ret = idle( &server_fd, ret );
1599 #endif
1600 if( ret != 0 )
1601 goto exit;
1602 }
1603 }
1604
1605 mbedtls_printf( " ok\n [ Protocol is %s ]\n [ Ciphersuite is %s ]\n",
1606 mbedtls_ssl_get_version( &ssl ),
1607 mbedtls_ssl_get_ciphersuite( &ssl ) );
1608
1609 if( ( ret = mbedtls_ssl_get_record_expansion( &ssl ) ) >= 0 )
1610 mbedtls_printf( " [ Record expansion is %d ]\n", ret );
1611 else
1612 mbedtls_printf( " [ Record expansion is unknown (compression) ]\n" );
1613
1614 #if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
1615 mbedtls_printf( " [ Maximum fragment length is %u ]\n",
1616 (unsigned int) mbedtls_ssl_get_max_frag_len( &ssl ) );
1617 #endif
1618
1619 #if defined(MBEDTLS_SSL_ALPN)
1620 if( opt.alpn_string != NULL )
1621 {
1622 const char *alp = mbedtls_ssl_get_alpn_protocol( &ssl );
1623 mbedtls_printf( " [ Application Layer Protocol is %s ]\n",
1624 alp ? alp : "(none)" );
1625 }
1626 #endif
1627
1628 if( opt.reconnect != 0 )
1629 {
1630 mbedtls_printf(" . Saving session for reuse..." );
1631 fflush( stdout );
1632
1633 if( ( ret = mbedtls_ssl_get_session( &ssl, &saved_session ) ) != 0 )
1634 {
1635 mbedtls_printf( " failed\n ! mbedtls_ssl_get_session returned -0x%x\n\n",
1636 -ret );
1637 goto exit;
1638 }
1639
1640 mbedtls_printf( " ok\n" );
1641 }
1642
1643 #if defined(MBEDTLS_X509_CRT_PARSE_C)
1644 /*
1645 * 5. Verify the server certificate
1646 */
1647 mbedtls_printf( " . Verifying peer X.509 certificate..." );
1648
1649 if( ( flags = mbedtls_ssl_get_verify_result( &ssl ) ) != 0 )
1650 {
1651 char vrfy_buf[512];
1652
1653 mbedtls_printf( " failed\n" );
1654
1655 mbedtls_x509_crt_verify_info( vrfy_buf, sizeof( vrfy_buf ),
1656 " ! ", flags );
1657
1658 mbedtls_printf( "%s\n", vrfy_buf );
1659 }
1660 else
1661 mbedtls_printf( " ok\n" );
1662
1663 if( mbedtls_ssl_get_peer_cert( &ssl ) != NULL )
1664 {
1665 mbedtls_printf( " . Peer certificate information ...\n" );
1666 mbedtls_x509_crt_info( (char *) buf, sizeof( buf ) - 1, " ",
1667 mbedtls_ssl_get_peer_cert( &ssl ) );
1668 mbedtls_printf( "%s\n", buf );
1669 }
1670 #endif /* MBEDTLS_X509_CRT_PARSE_C */
1671
1672 #if defined(MBEDTLS_SSL_RENEGOTIATION)
1673 if( opt.renegotiate )
1674 {
1675 /*
1676 * Perform renegotiation (this must be done when the server is waiting
1677 * for input from our side).
1678 */
1679 mbedtls_printf( " . Performing renegotiation..." );
1680 fflush( stdout );
1681 while( ( ret = mbedtls_ssl_renegotiate( &ssl ) ) != 0 )
1682 {
1683 if( ret != MBEDTLS_ERR_SSL_WANT_READ &&
1684 ret != MBEDTLS_ERR_SSL_WANT_WRITE &&
1685 ret != MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS )
1686 {
1687 mbedtls_printf( " failed\n ! mbedtls_ssl_renegotiate returned %d\n\n",
1688 ret );
1689 goto exit;
1690 }
1691
1692 #if defined(MBEDTLS_ECP_RESTARTABLE)
1693 if( ret == MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS )
1694 continue;
1695 #endif
1696
1697 /* For event-driven IO, wait for socket to become available */
1698 if( opt.event == 1 /* level triggered IO */ )
1699 {
1700 #if defined(MBEDTLS_TIMING_C)
1701 idle( &server_fd, &timer, ret );
1702 #else
1703 idle( &server_fd, ret );
1704 #endif
1705 }
1706
1707 }
1708 mbedtls_printf( " ok\n" );
1709 }
1710 #endif /* MBEDTLS_SSL_RENEGOTIATION */
1711
1712 /*
1713 * 6. Write the GET request
1714 */
1715 retry_left = opt.max_resend;
1716 send_request:
1717 mbedtls_printf( " > Write to server:" );
1718 fflush( stdout );
1719
1720 len = mbedtls_snprintf( (char *) buf, sizeof( buf ) - 1, GET_REQUEST,
1721 opt.request_page );
1722 tail_len = (int) strlen( GET_REQUEST_END );
1723
1724 /* Add padding to GET request to reach opt.request_size in length */
1725 if( opt.request_size != DFL_REQUEST_SIZE &&
1726 len + tail_len < opt.request_size )
1727 {
1728 memset( buf + len, 'A', opt.request_size - len - tail_len );
1729 len += opt.request_size - len - tail_len;
1730 }
1731
1732 strncpy( (char *) buf + len, GET_REQUEST_END, sizeof( buf ) - len - 1 );
1733 len += tail_len;
1734
1735 /* Truncate if request size is smaller than the "natural" size */
1736 if( opt.request_size != DFL_REQUEST_SIZE &&
1737 len > opt.request_size )
1738 {
1739 len = opt.request_size;
1740
1741 /* Still end with \r\n unless that's really not possible */
1742 if( len >= 2 ) buf[len - 2] = '\r';
1743 if( len >= 1 ) buf[len - 1] = '\n';
1744 }
1745
1746 if( opt.transport == MBEDTLS_SSL_TRANSPORT_STREAM )
1747 {
1748 written = 0;
1749 frags = 0;
1750
1751 do
1752 {
1753 while( ( ret = mbedtls_ssl_write( &ssl, buf + written,
1754 len - written ) ) < 0 )
1755 {
1756 if( ret != MBEDTLS_ERR_SSL_WANT_READ &&
1757 ret != MBEDTLS_ERR_SSL_WANT_WRITE &&
1758 ret != MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS )
1759 {
1760 mbedtls_printf( " failed\n ! mbedtls_ssl_write returned -0x%x\n\n",
1761 -ret );
1762 goto exit;
1763 }
1764
1765 /* For event-driven IO, wait for socket to become available */
1766 if( opt.event == 1 /* level triggered IO */ )
1767 {
1768 #if defined(MBEDTLS_TIMING_C)
1769 idle( &server_fd, &timer, ret );
1770 #else
1771 idle( &server_fd, ret );
1772 #endif
1773 }
1774 }
1775
1776 frags++;
1777 written += ret;
1778 }
1779 while( written < len );
1780 }
1781 else /* Not stream, so datagram */
1782 {
1783 while( 1 )
1784 {
1785 ret = mbedtls_ssl_write( &ssl, buf, len );
1786
1787 #if defined(MBEDTLS_ECP_RESTARTABLE)
1788 if( ret == MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS )
1789 continue;
1790 #endif
1791
1792 if( ret != MBEDTLS_ERR_SSL_WANT_READ &&
1793 ret != MBEDTLS_ERR_SSL_WANT_WRITE )
1794 break;
1795
1796 /* For event-driven IO, wait for socket to become available */
1797 if( opt.event == 1 /* level triggered IO */ )
1798 {
1799 #if defined(MBEDTLS_TIMING_C)
1800 idle( &server_fd, &timer, ret );
1801 #else
1802 idle( &server_fd, ret );
1803 #endif
1804 }
1805 }
1806
1807 if( ret < 0 )
1808 {
1809 mbedtls_printf( " failed\n ! mbedtls_ssl_write returned %d\n\n",
1810 ret );
1811 goto exit;
1812 }
1813
1814 frags = 1;
1815 written = ret;
1816
1817 if( written < len )
1818 {
1819 mbedtls_printf( " warning\n ! request didn't fit into single datagram and "
1820 "was truncated to size %u", (unsigned) written );
1821 }
1822 }
1823
1824 buf[written] = '\0';
1825 mbedtls_printf( " %d bytes written in %d fragments\n\n%s\n",
1826 written, frags, (char *) buf );
1827
1828 /* Send a non-empty request if request_size == 0 */
1829 if ( len == 0 )
1830 {
1831 opt.request_size = DFL_REQUEST_SIZE;
1832 goto send_request;
1833 }
1834
1835 /*
1836 * 7. Read the HTTP response
1837 */
1838 mbedtls_printf( " < Read from server:" );
1839 fflush( stdout );
1840
1841 /*
1842 * TLS and DTLS need different reading styles (stream vs datagram)
1843 */
1844 if( opt.transport == MBEDTLS_SSL_TRANSPORT_STREAM )
1845 {
1846 do
1847 {
1848 len = sizeof( buf ) - 1;
1849 memset( buf, 0, sizeof( buf ) );
1850 ret = mbedtls_ssl_read( &ssl, buf, len );
1851
1852 #if defined(MBEDTLS_ECP_RESTARTABLE)
1853 if( ret == MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS )
1854 continue;
1855 #endif
1856
1857 if( ret == MBEDTLS_ERR_SSL_WANT_READ ||
1858 ret == MBEDTLS_ERR_SSL_WANT_WRITE )
1859 {
1860 /* For event-driven IO, wait for socket to become available */
1861 if( opt.event == 1 /* level triggered IO */ )
1862 {
1863 #if defined(MBEDTLS_TIMING_C)
1864 idle( &server_fd, &timer, ret );
1865 #else
1866 idle( &server_fd, ret );
1867 #endif
1868 }
1869 continue;
1870 }
1871
1872 if( ret <= 0 )
1873 {
1874 switch( ret )
1875 {
1876 case MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY:
1877 mbedtls_printf( " connection was closed gracefully\n" );
1878 ret = 0;
1879 goto close_notify;
1880
1881 case 0:
1882 case MBEDTLS_ERR_NET_CONN_RESET:
1883 mbedtls_printf( " connection was reset by peer\n" );
1884 ret = 0;
1885 goto reconnect;
1886
1887 default:
1888 mbedtls_printf( " mbedtls_ssl_read returned -0x%x\n",
1889 -ret );
1890 goto exit;
1891 }
1892 }
1893
1894 len = ret;
1895 buf[len] = '\0';
1896 mbedtls_printf( " %d bytes read\n\n%s", len, (char *) buf );
1897
1898 /* End of message should be detected according to the syntax of the
1899 * application protocol (eg HTTP), just use a dummy test here. */
1900 if( ret > 0 && buf[len-1] == '\n' )
1901 {
1902 ret = 0;
1903 break;
1904 }
1905 }
1906 while( 1 );
1907 }
1908 else /* Not stream, so datagram */
1909 {
1910 len = sizeof( buf ) - 1;
1911 memset( buf, 0, sizeof( buf ) );
1912
1913 while( 1 )
1914 {
1915 ret = mbedtls_ssl_read( &ssl, buf, len );
1916
1917 #if defined(MBEDTLS_ECP_RESTARTABLE)
1918 if( ret == MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS )
1919 continue;
1920 #endif
1921
1922 if( ret != MBEDTLS_ERR_SSL_WANT_READ &&
1923 ret != MBEDTLS_ERR_SSL_WANT_WRITE )
1924 break;
1925
1926 /* For event-driven IO, wait for socket to become available */
1927 if( opt.event == 1 /* level triggered IO */ )
1928 {
1929 #if defined(MBEDTLS_TIMING_C)
1930 idle( &server_fd, &timer, ret );
1931 #else
1932 idle( &server_fd, ret );
1933 #endif
1934 }
1935 }
1936
1937 if( ret <= 0 )
1938 {
1939 switch( ret )
1940 {
1941 case MBEDTLS_ERR_SSL_TIMEOUT:
1942 mbedtls_printf( " timeout\n" );
1943 if( retry_left-- > 0 )
1944 goto send_request;
1945 goto exit;
1946
1947 case MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY:
1948 mbedtls_printf( " connection was closed gracefully\n" );
1949 ret = 0;
1950 goto close_notify;
1951
1952 default:
1953 mbedtls_printf( " mbedtls_ssl_read returned -0x%x\n", -ret );
1954 goto exit;
1955 }
1956 }
1957
1958 len = ret;
1959 buf[len] = '\0';
1960 mbedtls_printf( " %d bytes read\n\n%s", len, (char *) buf );
1961 ret = 0;
1962 }
1963
1964 /*
1965 * 7b. Simulate hard reset and reconnect from same port?
1966 */
1967 if( opt.reconnect_hard != 0 )
1968 {
1969 opt.reconnect_hard = 0;
1970
1971 mbedtls_printf( " . Restarting connection from same port..." );
1972 fflush( stdout );
1973
1974 if( ( ret = mbedtls_ssl_session_reset( &ssl ) ) != 0 )
1975 {
1976 mbedtls_printf( " failed\n ! mbedtls_ssl_session_reset returned -0x%x\n\n",
1977 -ret );
1978 goto exit;
1979 }
1980
1981 while( ( ret = mbedtls_ssl_handshake( &ssl ) ) != 0 )
1982 {
1983 if( ret != MBEDTLS_ERR_SSL_WANT_READ &&
1984 ret != MBEDTLS_ERR_SSL_WANT_WRITE &&
1985 ret != MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS )
1986 {
1987 mbedtls_printf( " failed\n ! mbedtls_ssl_handshake returned -0x%x\n\n",
1988 -ret );
1989 goto exit;
1990 }
1991
1992 /* For event-driven IO, wait for socket to become available */
1993 if( opt.event == 1 /* level triggered IO */ )
1994 {
1995 #if defined(MBEDTLS_TIMING_C)
1996 idle( &server_fd, &timer, ret );
1997 #else
1998 idle( &server_fd, ret );
1999 #endif
2000 }
2001 }
2002
2003 mbedtls_printf( " ok\n" );
2004
2005 goto send_request;
2006 }
2007
2008 /*
2009 * 7c. Continue doing data exchanges?
2010 */
2011 if( --opt.exchanges > 0 )
2012 goto send_request;
2013
2014 /*
2015 * 8. Done, cleanly close the connection
2016 */
2017 close_notify:
2018 mbedtls_printf( " . Closing the connection..." );
2019 fflush( stdout );
2020
2021 /* No error checking, the connection might be closed already */
2022 do ret = mbedtls_ssl_close_notify( &ssl );
2023 while( ret == MBEDTLS_ERR_SSL_WANT_WRITE );
2024 ret = 0;
2025
2026 mbedtls_printf( " done\n" );
2027
2028 /*
2029 * 9. Reconnect?
2030 */
2031 reconnect:
2032 if( opt.reconnect != 0 )
2033 {
2034 --opt.reconnect;
2035
2036 mbedtls_net_free( &server_fd );
2037
2038 #if defined(MBEDTLS_TIMING_C)
2039 if( opt.reco_delay > 0 )
2040 mbedtls_net_usleep( 1000000 * opt.reco_delay );
2041 #endif
2042
2043 mbedtls_printf( " . Reconnecting with saved session..." );
2044
2045 if( ( ret = mbedtls_ssl_session_reset( &ssl ) ) != 0 )
2046 {
2047 mbedtls_printf( " failed\n ! mbedtls_ssl_session_reset returned -0x%x\n\n",
2048 -ret );
2049 goto exit;
2050 }
2051
2052 if( ( ret = mbedtls_ssl_set_session( &ssl, &saved_session ) ) != 0 )
2053 {
2054 mbedtls_printf( " failed\n ! mbedtls_ssl_conf_session returned %d\n\n",
2055 ret );
2056 goto exit;
2057 }
2058
2059 if( ( ret = mbedtls_net_connect( &server_fd,
2060 opt.server_addr, opt.server_port,
2061 opt.transport == MBEDTLS_SSL_TRANSPORT_STREAM ?
2062 MBEDTLS_NET_PROTO_TCP : MBEDTLS_NET_PROTO_UDP ) ) != 0 )
2063 {
2064 mbedtls_printf( " failed\n ! mbedtls_net_connect returned -0x%x\n\n",
2065 -ret );
2066 goto exit;
2067 }
2068
2069 if( opt.nbio > 0 )
2070 ret = mbedtls_net_set_nonblock( &server_fd );
2071 else
2072 ret = mbedtls_net_set_block( &server_fd );
2073 if( ret != 0 )
2074 {
2075 mbedtls_printf( " failed\n ! net_set_(non)block() returned -0x%x\n\n",
2076 -ret );
2077 goto exit;
2078 }
2079
2080 while( ( ret = mbedtls_ssl_handshake( &ssl ) ) != 0 )
2081 {
2082 if( ret != MBEDTLS_ERR_SSL_WANT_READ &&
2083 ret != MBEDTLS_ERR_SSL_WANT_WRITE &&
2084 ret != MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS )
2085 {
2086 mbedtls_printf( " failed\n ! mbedtls_ssl_handshake returned -0x%x\n\n",
2087 -ret );
2088 goto exit;
2089 }
2090 }
2091
2092 mbedtls_printf( " ok\n" );
2093
2094 goto send_request;
2095 }
2096
2097 /*
2098 * Cleanup and exit
2099 */
2100 exit:
2101 #ifdef MBEDTLS_ERROR_C
2102 if( ret != 0 )
2103 {
2104 char error_buf[100];
2105 mbedtls_strerror( ret, error_buf, 100 );
2106 mbedtls_printf("Last error was: -0x%X - %s\n\n", -ret, error_buf );
2107 }
2108 #endif
2109
2110 mbedtls_net_free( &server_fd );
2111
2112 #if defined(MBEDTLS_X509_CRT_PARSE_C)
2113 mbedtls_x509_crt_free( &clicert );
2114 mbedtls_x509_crt_free( &cacert );
2115 mbedtls_pk_free( &pkey );
2116 #endif
2117 mbedtls_ssl_session_free( &saved_session );
2118 mbedtls_ssl_free( &ssl );
2119 mbedtls_ssl_config_free( &conf );
2120 mbedtls_ctr_drbg_free( &ctr_drbg );
2121 mbedtls_entropy_free( &entropy );
2122
2123 #if defined(_WIN32)
2124 mbedtls_printf( " + Press Enter to exit this program.\n" );
2125 fflush( stdout ); getchar();
2126 #endif
2127
2128 // Shell can not handle large exit numbers -> 1 for errors
2129 if( ret < 0 )
2130 ret = 1;
2131
2132 return( ret );
2133 }
2134 #endif /* MBEDTLS_BIGNUM_C && MBEDTLS_ENTROPY_C && MBEDTLS_SSL_TLS_C &&
2135 MBEDTLS_SSL_CLI_C && MBEDTLS_NET_C && MBEDTLS_RSA_C &&
2136 MBEDTLS_CTR_DRBG_C MBEDTLS_TIMING_C */
2137