blob: 68d844252a2909d3acbbc18b5509247558c52290 [file] [log] [blame]
Manuel Pégourié-Gonnard4956fd72014-09-24 11:13:44 +02001/* BEGIN_HEADER */
Manuel Pégourié-Gonnard7f809972015-03-09 17:05:11 +00002#include <mbedtls/ssl.h>
Manuel Pégourié-Gonnard5e94dde2015-05-26 11:57:05 +02003#include <mbedtls/ssl_internal.h>
Hanno Becker4a2f8e52019-02-06 15:23:38 +00004#include <mbedtls/md.h>
Hanno Becker611a83b2018-01-03 14:27:32 +00005
6/*
7 * Helper function setting up inverse record transformations
8 * using given cipher, hash, EtM mode, authentication tag length,
9 * and version.
10 */
11
12#define CHK( x ) \
13 do \
14 { \
15 if( !( x ) ) \
Hanno Becker5c1176e2019-03-01 11:21:44 +000016 { \
Hanno Becker1acadb72019-04-05 09:55:37 +010017 ret = -1; \
Hanno Becker5c1176e2019-03-01 11:21:44 +000018 goto cleanup; \
19 } \
Hanno Becker611a83b2018-01-03 14:27:32 +000020 } while( 0 )
21
Hanno Beckerd8f753b2019-04-29 17:30:59 +010022#if MBEDTLS_SSL_CID_OUT_LEN_MAX > MBEDTLS_SSL_CID_IN_LEN_MAX
23#define SSL_CID_LEN_MIN MBEDTLS_SSL_CID_IN_LEN_MAX
24#else
25#define SSL_CID_LEN_MIN MBEDTLS_SSL_CID_OUT_LEN_MAX
26#endif
Hanno Becker611a83b2018-01-03 14:27:32 +000027
28static int build_transforms( mbedtls_ssl_transform *t_in,
29 mbedtls_ssl_transform *t_out,
30 int cipher_type, int hash_id,
Hanno Beckerd8f753b2019-04-29 17:30:59 +010031 int etm, int tag_mode, int ver,
32 size_t cid0_len,
33 size_t cid1_len )
Hanno Becker611a83b2018-01-03 14:27:32 +000034{
35 mbedtls_cipher_info_t const *cipher_info;
Hanno Becker1acadb72019-04-05 09:55:37 +010036 int ret = 0;
Hanno Becker611a83b2018-01-03 14:27:32 +000037
38 size_t keylen, maclen, ivlen;
Hanno Becker5c1176e2019-03-01 11:21:44 +000039 unsigned char *key0 = NULL, *key1 = NULL;
Hanno Becker611a83b2018-01-03 14:27:32 +000040 unsigned char iv_enc[16], iv_dec[16];
41
Hanno Beckera5a2b082019-05-15 14:03:01 +010042#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
Hanno Beckerd8f753b2019-04-29 17:30:59 +010043 unsigned char cid0[ SSL_CID_LEN_MIN ];
44 unsigned char cid1[ SSL_CID_LEN_MIN ];
45
46 rnd_std_rand( NULL, cid0, sizeof( cid0 ) );
47 rnd_std_rand( NULL, cid1, sizeof( cid1 ) );
Hanno Becker505089d2019-05-01 09:45:57 +010048#else
49 ((void) cid0_len);
50 ((void) cid1_len);
Hanno Beckera5a2b082019-05-15 14:03:01 +010051#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
Hanno Beckerd8f753b2019-04-29 17:30:59 +010052
Hanno Becker611a83b2018-01-03 14:27:32 +000053 maclen = 0;
54
55 /* Pick cipher */
56 cipher_info = mbedtls_cipher_info_from_type( cipher_type );
57 CHK( cipher_info != NULL );
58 CHK( cipher_info->iv_size <= 16 );
59 CHK( cipher_info->key_bitlen % 8 == 0 );
60
61 /* Pick keys */
62 keylen = cipher_info->key_bitlen / 8;
Hanno Beckera1317662019-04-05 09:56:10 +010063 /* Allocate `keylen + 1` bytes to ensure that we get
64 * a non-NULL pointers from `mbedtls_calloc` even if
65 * `keylen == 0` in the case of the NULL cipher. */
66 CHK( ( key0 = mbedtls_calloc( 1, keylen + 1 ) ) != NULL );
67 CHK( ( key1 = mbedtls_calloc( 1, keylen + 1 ) ) != NULL );
Hanno Becker611a83b2018-01-03 14:27:32 +000068 memset( key0, 0x1, keylen );
69 memset( key1, 0x2, keylen );
70
Andrzej Kurek11750442020-09-17 07:12:06 -040071#if defined(MBEDTLS_SSL_TRANSFORM_OPTIMIZE_CIPHERS)
72 t_in->key_enc = mbedtls_calloc( 1, keylen );
73 t_in->key_dec = mbedtls_calloc( 1, keylen );
74
75 t_out->key_enc = mbedtls_calloc( 1, keylen );
76 t_out->key_dec = mbedtls_calloc( 1, keylen );
77
78 memcpy( t_in->key_enc, key0, keylen);
79 memcpy( t_in->key_dec, key1, keylen);
80 t_in->key_bitlen = cipher_info->key_bitlen;
81
82 memcpy( t_out->key_enc, key1, keylen);
83 memcpy( t_out->key_dec, key0, keylen);
84 t_out->key_bitlen = cipher_info->key_bitlen;
85
Andrzej Kureka7932372020-09-19 07:56:06 +020086#if defined(MBEDTLS_VALIDATE_SSL_KEYS_INTEGRITY)
87 t_in->key_enc_hash = mbedtls_hash( t_in->key_enc, t_in->key_bitlen >> 3 );
88 t_in->key_dec_hash = mbedtls_hash( t_in->key_dec, t_in->key_bitlen >> 3 );
89
90 t_out->key_enc_hash = mbedtls_hash( t_out->key_enc, t_out->key_bitlen >> 3 );
91 t_out->key_dec_hash = mbedtls_hash( t_out->key_dec, t_out->key_bitlen >> 3 );
92#endif
93
Andrzej Kurek11750442020-09-17 07:12:06 -040094 /* Setup cipher contexts */
95 CHK( mbedtls_cipher_setup( &t_in->cipher_ctx, cipher_info ) == 0 );
96 CHK( mbedtls_cipher_setup( &t_out->cipher_ctx, cipher_info ) == 0 );
97#else
Hanno Becker611a83b2018-01-03 14:27:32 +000098 /* Setup cipher contexts */
99 CHK( mbedtls_cipher_setup( &t_in->cipher_ctx_enc, cipher_info ) == 0 );
100 CHK( mbedtls_cipher_setup( &t_in->cipher_ctx_dec, cipher_info ) == 0 );
101 CHK( mbedtls_cipher_setup( &t_out->cipher_ctx_enc, cipher_info ) == 0 );
102 CHK( mbedtls_cipher_setup( &t_out->cipher_ctx_dec, cipher_info ) == 0 );
Andrzej Kurek11750442020-09-17 07:12:06 -0400103#endif
Hanno Becker611a83b2018-01-03 14:27:32 +0000104
105#if defined(MBEDTLS_CIPHER_MODE_CBC)
106 if( cipher_info->mode == MBEDTLS_MODE_CBC )
107 {
Andrzej Kurek11750442020-09-17 07:12:06 -0400108#if defined(MBEDTLS_SSL_TRANSFORM_OPTIMIZE_CIPHERS)
109 CHK( mbedtls_cipher_set_padding_mode( &t_in->cipher_ctx,
110 MBEDTLS_PADDING_NONE ) == 0 );
111 CHK( mbedtls_cipher_set_padding_mode( &t_out->cipher_ctx,
112 MBEDTLS_PADDING_NONE ) == 0 );
113#else
Hanno Becker611a83b2018-01-03 14:27:32 +0000114 CHK( mbedtls_cipher_set_padding_mode( &t_in->cipher_ctx_enc,
115 MBEDTLS_PADDING_NONE ) == 0 );
116 CHK( mbedtls_cipher_set_padding_mode( &t_in->cipher_ctx_dec,
117 MBEDTLS_PADDING_NONE ) == 0 );
118 CHK( mbedtls_cipher_set_padding_mode( &t_out->cipher_ctx_enc,
119 MBEDTLS_PADDING_NONE ) == 0 );
120 CHK( mbedtls_cipher_set_padding_mode( &t_out->cipher_ctx_dec,
121 MBEDTLS_PADDING_NONE ) == 0 );
Andrzej Kurek11750442020-09-17 07:12:06 -0400122#endif
Hanno Becker611a83b2018-01-03 14:27:32 +0000123 }
124#endif /* MBEDTLS_CIPHER_MODE_CBC */
125
Andrzej Kurek11750442020-09-17 07:12:06 -0400126#if !defined(MBEDTLS_SSL_TRANSFORM_OPTIMIZE_CIPHERS)
Hanno Becker611a83b2018-01-03 14:27:32 +0000127 CHK( mbedtls_cipher_setkey( &t_in->cipher_ctx_enc, key0,
128 keylen << 3, MBEDTLS_ENCRYPT ) == 0 );
129 CHK( mbedtls_cipher_setkey( &t_in->cipher_ctx_dec, key1,
130 keylen << 3, MBEDTLS_DECRYPT ) == 0 );
131 CHK( mbedtls_cipher_setkey( &t_out->cipher_ctx_enc, key1,
132 keylen << 3, MBEDTLS_ENCRYPT ) == 0 );
133 CHK( mbedtls_cipher_setkey( &t_out->cipher_ctx_dec, key0,
134 keylen << 3, MBEDTLS_DECRYPT ) == 0 );
Andrzej Kurek11750442020-09-17 07:12:06 -0400135#endif
Hanno Becker611a83b2018-01-03 14:27:32 +0000136 /* Setup MAC contexts */
137#if defined(MBEDTLS_SSL_SOME_MODES_USE_MAC)
138 if( cipher_info->mode == MBEDTLS_MODE_CBC ||
139 cipher_info->mode == MBEDTLS_MODE_STREAM )
140 {
Hanno Beckera5cedbc2019-07-17 11:21:02 +0100141 mbedtls_md_handle_t md_info;
Hanno Becker611a83b2018-01-03 14:27:32 +0000142 unsigned char *md0, *md1;
143
144 /* Pick hash */
145 md_info = mbedtls_md_info_from_type( hash_id );
Hanno Beckera5cedbc2019-07-17 11:21:02 +0100146 CHK( md_info != MBEDTLS_MD_INVALID_HANDLE );
Hanno Becker611a83b2018-01-03 14:27:32 +0000147
148 /* Pick hash keys */
149 maclen = mbedtls_md_get_size( md_info );
Hanno Beckerafc528a2019-04-04 16:31:26 +0100150 CHK( ( md0 = mbedtls_calloc( 1, maclen ) ) != NULL );
151 CHK( ( md1 = mbedtls_calloc( 1, maclen ) ) != NULL );
Hanno Becker611a83b2018-01-03 14:27:32 +0000152 memset( md0, 0x5, maclen );
153 memset( md1, 0x6, maclen );
154
155 CHK( mbedtls_md_setup( &t_out->md_ctx_enc, md_info, 1 ) == 0 );
156 CHK( mbedtls_md_setup( &t_out->md_ctx_dec, md_info, 1 ) == 0 );
157 CHK( mbedtls_md_setup( &t_in->md_ctx_enc, md_info, 1 ) == 0 );
158 CHK( mbedtls_md_setup( &t_in->md_ctx_dec, md_info, 1 ) == 0 );
159
Hanno Becker7bcf2b52019-07-26 09:02:40 +0100160 if( mbedtls_ssl_ver_gt( ver, MBEDTLS_SSL_MINOR_VERSION_0 ) )
Hanno Becker611a83b2018-01-03 14:27:32 +0000161 {
162 CHK( mbedtls_md_hmac_starts( &t_in->md_ctx_enc,
163 md0, maclen ) == 0 );
164 CHK( mbedtls_md_hmac_starts( &t_in->md_ctx_dec,
165 md1, maclen ) == 0 );
166 CHK( mbedtls_md_hmac_starts( &t_out->md_ctx_enc,
167 md1, maclen ) == 0 );
168 CHK( mbedtls_md_hmac_starts( &t_out->md_ctx_dec,
169 md0, maclen ) == 0 );
170 }
171#if defined(MBEDTLS_SSL_PROTO_SSL3)
172 else
173 {
174 memcpy( &t_in->mac_enc, md0, maclen );
175 memcpy( &t_in->mac_dec, md1, maclen );
176 memcpy( &t_out->mac_enc, md1, maclen );
177 memcpy( &t_out->mac_dec, md0, maclen );
178 }
179#endif
180
Hanno Beckerafc528a2019-04-04 16:31:26 +0100181 mbedtls_free( md0 );
182 mbedtls_free( md1 );
Hanno Becker611a83b2018-01-03 14:27:32 +0000183 }
184#else
185 ((void) hash_id);
186#endif /* MBEDTLS_SSL_SOME_MODES_USE_MAC */
187
188
189 /* Pick IV's (regardless of whether they
190 * are being used by the transform). */
191 ivlen = cipher_info->iv_size;
192 memset( iv_enc, 0x3, sizeof( iv_enc ) );
193 memset( iv_dec, 0x4, sizeof( iv_dec ) );
194
195 /*
196 * Setup transforms
197 */
198
Jaeden Amero2eaf2c72019-06-05 13:32:08 +0100199#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC) && \
200 defined(MBEDTLS_SSL_SOME_MODES_USE_MAC)
Hanno Becker611a83b2018-01-03 14:27:32 +0000201 t_out->encrypt_then_mac = etm;
202 t_in->encrypt_then_mac = etm;
203#else
204 ((void) etm);
205#endif
206
Hanno Beckerac8c9842019-07-05 13:53:06 +0100207#if !defined(MBEDTLS_SSL_CONF_FIXED_MINOR_VER)
Hanno Becker611a83b2018-01-03 14:27:32 +0000208 t_out->minor_ver = ver;
209 t_in->minor_ver = ver;
Hanno Becker90f7b752019-07-08 11:29:13 +0100210#else
211 ((void) ver);
Hanno Beckerac8c9842019-07-05 13:53:06 +0100212#endif
Hanno Becker611a83b2018-01-03 14:27:32 +0000213 t_out->ivlen = ivlen;
214 t_in->ivlen = ivlen;
215
216 switch( cipher_info->mode )
217 {
218 case MBEDTLS_MODE_GCM:
219 case MBEDTLS_MODE_CCM:
220 t_out->fixed_ivlen = 4;
221 t_in->fixed_ivlen = 4;
222 t_out->maclen = 0;
223 t_in->maclen = 0;
224 switch( tag_mode )
225 {
226 case 0: /* Full tag */
227 t_out->taglen = 16;
228 t_in->taglen = 16;
229 break;
230 case 1: /* Partial tag */
231 t_out->taglen = 8;
232 t_in->taglen = 8;
233 break;
234 default:
235 return( 1 );
236 }
237 break;
238
239 case MBEDTLS_MODE_CHACHAPOLY:
240 t_out->fixed_ivlen = 12;
241 t_in->fixed_ivlen = 12;
242 t_out->maclen = 0;
243 t_in->maclen = 0;
244 switch( tag_mode )
245 {
246 case 0: /* Full tag */
247 t_out->taglen = 16;
248 t_in->taglen = 16;
249 break;
250 case 1: /* Partial tag */
251 t_out->taglen = 8;
252 t_in->taglen = 8;
253 break;
254 default:
255 return( 1 );
256 }
257 break;
258
259 case MBEDTLS_MODE_STREAM:
260 case MBEDTLS_MODE_CBC:
261 t_out->fixed_ivlen = 0; /* redundant, must be 0 */
262 t_in->fixed_ivlen = 0; /* redundant, must be 0 */
263 t_out->taglen = 0;
264 t_in->taglen = 0;
265 switch( tag_mode )
266 {
267 case 0: /* Full tag */
268 t_out->maclen = maclen;
269 t_in->maclen = maclen;
270 break;
271 case 1: /* Partial tag */
272 t_out->maclen = 10;
273 t_in->maclen = 10;
274 break;
275 default:
276 return( 1 );
277 }
278 break;
279 default:
280 return( 1 );
281 break;
282 }
283
284 /* Setup IV's */
285
286 memcpy( &t_in->iv_dec, iv_dec, sizeof( iv_dec ) );
287 memcpy( &t_in->iv_enc, iv_enc, sizeof( iv_enc ) );
288 memcpy( &t_out->iv_dec, iv_enc, sizeof( iv_enc ) );
289 memcpy( &t_out->iv_enc, iv_dec, sizeof( iv_dec ) );
290
Hanno Beckera5a2b082019-05-15 14:03:01 +0100291#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
Hanno Beckerd8f753b2019-04-29 17:30:59 +0100292 /* Add CID */
293 memcpy( &t_in->in_cid, cid0, cid0_len );
294 memcpy( &t_in->out_cid, cid1, cid1_len );
295 t_in->in_cid_len = cid0_len;
296 t_in->out_cid_len = cid1_len;
297 memcpy( &t_out->in_cid, cid1, cid1_len );
298 memcpy( &t_out->out_cid, cid0, cid0_len );
299 t_out->in_cid_len = cid1_len;
300 t_out->out_cid_len = cid0_len;
Hanno Beckera5a2b082019-05-15 14:03:01 +0100301#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
Hanno Beckerd8f753b2019-04-29 17:30:59 +0100302
Hanno Becker5c1176e2019-03-01 11:21:44 +0000303cleanup:
304
Hanno Beckerafc528a2019-04-04 16:31:26 +0100305 mbedtls_free( key0 );
306 mbedtls_free( key1 );
Hanno Becker5c1176e2019-03-01 11:21:44 +0000307
Hanno Becker1acadb72019-04-05 09:55:37 +0100308 return( ret );
Hanno Becker611a83b2018-01-03 14:27:32 +0000309}
310
Manuel Pégourié-Gonnard16f6bb12019-05-23 10:06:14 +0200311/*
Manuel Pégourié-Gonnard35ccdbb2019-06-03 09:55:16 +0200312 * Populate a session structure for serialization tests.
Manuel Pégourié-Gonnard16f6bb12019-05-23 10:06:14 +0200313 * Choose dummy values, mostly non-0 to distinguish from the init default.
314 */
315static int ssl_populate_session( mbedtls_ssl_session *session,
Manuel Pégourié-Gonnardd1a54512019-05-24 09:54:21 +0200316 int ticket_len,
317 const char *crt_file )
Manuel Pégourié-Gonnard16f6bb12019-05-23 10:06:14 +0200318{
319#if defined(MBEDTLS_HAVE_TIME)
320 session->start = mbedtls_time( NULL ) - 42;
321#endif
Hanno Beckere02758c2019-06-26 15:31:31 +0100322#if !defined(MBEDTLS_SSL_CONF_SINGLE_CIPHERSUITE)
Manuel Pégourié-Gonnard16f6bb12019-05-23 10:06:14 +0200323 session->ciphersuite = 0xabcd;
Hanno Beckere02758c2019-06-26 15:31:31 +0100324#endif
Hanno Becker88440552019-07-03 14:16:13 +0100325#if defined(MBEDTLS_ZLIB_SUPPORT)
Manuel Pégourié-Gonnard16f6bb12019-05-23 10:06:14 +0200326 session->compression = 1;
Hanno Becker88440552019-07-03 14:16:13 +0100327#endif
Manuel Pégourié-Gonnard16f6bb12019-05-23 10:06:14 +0200328 session->id_len = sizeof( session->id );
329 memset( session->id, 66, session->id_len );
Manuel Pégourié-Gonnardd1a54512019-05-24 09:54:21 +0200330 memset( session->master, 17, sizeof( session->master ) );
Manuel Pégourié-Gonnard16f6bb12019-05-23 10:06:14 +0200331
Manuel Pégourié-Gonnard749312f2019-05-24 10:17:52 +0200332#if defined(MBEDTLS_X509_CRT_PARSE_C) && defined(MBEDTLS_FS_IO)
Manuel Pégourié-Gonnard16f6bb12019-05-23 10:06:14 +0200333 if( strlen( crt_file ) != 0 )
334 {
Hanno Becker4a2f8e52019-02-06 15:23:38 +0000335 mbedtls_x509_crt tmp_crt;
Manuel Pégourié-Gonnard16f6bb12019-05-23 10:06:14 +0200336 int ret;
Manuel Pégourié-Gonnardaab62042019-05-24 09:40:17 +0200337
Hanno Becker4a2f8e52019-02-06 15:23:38 +0000338 mbedtls_x509_crt_init( &tmp_crt );
339 ret = mbedtls_x509_crt_parse_file( &tmp_crt, crt_file );
340 if( ret != 0 )
341 return( ret );
342
Hanno Becker5882dd02019-06-06 16:25:57 +0100343#if defined(MBEDTLS_SSL_KEEP_PEER_CERTIFICATE)
344 /* Move temporary CRT. */
345 session->peer_cert = mbedtls_calloc( 1, sizeof( *session->peer_cert ) );
346 if( session->peer_cert == NULL )
347 return( -1 );
348 *session->peer_cert = tmp_crt;
349 memset( &tmp_crt, 0, sizeof( tmp_crt ) );
350#elif defined(MBEDTLS_SSL_RENEGOTIATION)
Hanno Becker4a2f8e52019-02-06 15:23:38 +0000351 /* Calculate digest of temporary CRT. */
352 session->peer_cert_digest =
353 mbedtls_calloc( 1, MBEDTLS_SSL_PEER_CERT_DIGEST_DFL_LEN );
354 if( session->peer_cert_digest == NULL )
355 return( -1 );
356 ret = mbedtls_md( mbedtls_md_info_from_type(
357 MBEDTLS_SSL_PEER_CERT_DIGEST_DFL_TYPE ),
358 tmp_crt.raw.p, tmp_crt.raw.len,
359 session->peer_cert_digest );
360 if( ret != 0 )
361 return( ret );
362 session->peer_cert_digest_type =
363 MBEDTLS_SSL_PEER_CERT_DIGEST_DFL_TYPE;
364 session->peer_cert_digest_len =
365 MBEDTLS_SSL_PEER_CERT_DIGEST_DFL_LEN;
Hanno Becker5882dd02019-06-06 16:25:57 +0100366#endif /* !MBEDTLS_SSL_KEEP_PEER_CERTIFICATE && MBEDTLS_SSL_RENEGOTIATION */
Manuel Pégourié-Gonnardaab62042019-05-24 09:40:17 +0200367
Hanno Becker4a2f8e52019-02-06 15:23:38 +0000368 mbedtls_x509_crt_free( &tmp_crt );
Manuel Pégourié-Gonnard16f6bb12019-05-23 10:06:14 +0200369 }
370#else
371 (void) crt_file;
372#endif
373 session->verify_result = 0xdeadbeef;
374
375#if defined(MBEDTLS_SSL_SESSION_TICKETS) && defined(MBEDTLS_SSL_CLI_C)
376 if( ticket_len != 0 )
377 {
378 session->ticket = mbedtls_calloc( 1, ticket_len );
Manuel Pégourié-Gonnardd1a54512019-05-24 09:54:21 +0200379 if( session->ticket == NULL )
Manuel Pégourié-Gonnard16f6bb12019-05-23 10:06:14 +0200380 return( -1 );
381 memset( session->ticket, 33, ticket_len );
382 }
383 session->ticket_len = ticket_len;
384 session->ticket_lifetime = 86401;
385#else
386 (void) ticket_len;
387#endif
388
389#if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
390 session->mfl_code = 1;
391#endif
392#if defined(MBEDTLS_SSL_TRUNCATED_HMAC)
393 session->trunc_hmac = 1;
394#endif
395#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
396 session->encrypt_then_mac = 1;
397#endif
398
399 return( 0 );
400}
401
Manuel Pégourié-Gonnard4956fd72014-09-24 11:13:44 +0200402/* END_HEADER */
403
404/* BEGIN_DEPENDENCIES
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200405 * depends_on:MBEDTLS_SSL_TLS_C
Manuel Pégourié-Gonnard4956fd72014-09-24 11:13:44 +0200406 * END_DEPENDENCIES
407 */
408
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200409/* BEGIN_CASE depends_on:MBEDTLS_SSL_DTLS_ANTI_REPLAY */
Azim Khan5fcca462018-06-29 11:05:32 +0100410void ssl_dtls_replay( data_t * prevs, data_t * new, int ret )
Manuel Pégourié-Gonnard4956fd72014-09-24 11:13:44 +0200411{
Azim Khand30ca132017-06-09 04:32:58 +0100412 uint32_t len = 0;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200413 mbedtls_ssl_context ssl;
Manuel Pégourié-Gonnarddef0bbe2015-05-04 14:56:36 +0200414 mbedtls_ssl_config conf;
Manuel Pégourié-Gonnard4956fd72014-09-24 11:13:44 +0200415
Manuel Pégourié-Gonnard41d479e2015-04-29 00:48:22 +0200416 mbedtls_ssl_init( &ssl );
Manuel Pégourié-Gonnarddef0bbe2015-05-04 14:56:36 +0200417 mbedtls_ssl_config_init( &conf );
Manuel Pégourié-Gonnard41d479e2015-04-29 00:48:22 +0200418
Manuel Pégourié-Gonnard419d5ae2015-05-04 19:32:36 +0200419 TEST_ASSERT( mbedtls_ssl_config_defaults( &conf,
420 MBEDTLS_SSL_IS_CLIENT,
Manuel Pégourié-Gonnardb31c5f62015-06-17 13:53:47 +0200421 MBEDTLS_SSL_TRANSPORT_DATAGRAM,
422 MBEDTLS_SSL_PRESET_DEFAULT ) == 0 );
Manuel Pégourié-Gonnarddef0bbe2015-05-04 14:56:36 +0200423 TEST_ASSERT( mbedtls_ssl_setup( &ssl, &conf ) == 0 );
Manuel Pégourié-Gonnard4956fd72014-09-24 11:13:44 +0200424
425 /* Read previous record numbers */
Azim Khand30ca132017-06-09 04:32:58 +0100426 for( len = 0; len < prevs->len; len += 6 )
Manuel Pégourié-Gonnard4956fd72014-09-24 11:13:44 +0200427 {
Azim Khand30ca132017-06-09 04:32:58 +0100428 memcpy( ssl.in_ctr + 2, prevs->x + len, 6 );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200429 mbedtls_ssl_dtls_replay_update( &ssl );
Manuel Pégourié-Gonnard4956fd72014-09-24 11:13:44 +0200430 }
431
432 /* Check new number */
Azim Khand30ca132017-06-09 04:32:58 +0100433 memcpy( ssl.in_ctr + 2, new->x, 6 );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200434 TEST_ASSERT( mbedtls_ssl_dtls_replay_check( &ssl ) == ret );
Manuel Pégourié-Gonnard4956fd72014-09-24 11:13:44 +0200435
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200436 mbedtls_ssl_free( &ssl );
Manuel Pégourié-Gonnarddef0bbe2015-05-04 14:56:36 +0200437 mbedtls_ssl_config_free( &conf );
Manuel Pégourié-Gonnard4956fd72014-09-24 11:13:44 +0200438}
439/* END_CASE */
Hanno Beckerb25c0c72017-05-05 11:24:30 +0100440
Teppo Järvelin4009d8f2019-08-19 14:48:09 +0300441/* BEGIN_CASE depends_on:MBEDTLS_X509_CRT_PARSE_C:!MBEDTLS_X509_REMOVE_HOSTNAME_VERIFICATION */
Hanno Beckerb25c0c72017-05-05 11:24:30 +0100442void ssl_set_hostname_twice( char *hostname0, char *hostname1 )
443{
444 mbedtls_ssl_context ssl;
445 mbedtls_ssl_init( &ssl );
446
447 TEST_ASSERT( mbedtls_ssl_set_hostname( &ssl, hostname0 ) == 0 );
448 TEST_ASSERT( mbedtls_ssl_set_hostname( &ssl, hostname1 ) == 0 );
449
450 mbedtls_ssl_free( &ssl );
451}
Darryl Green11999bb2018-03-13 15:22:58 +0000452/* END_CASE */
Hanno Becker611a83b2018-01-03 14:27:32 +0000453
454/* BEGIN_CASE */
455void ssl_crypt_record( int cipher_type, int hash_id,
Hanno Beckerd8f753b2019-04-29 17:30:59 +0100456 int etm, int tag_mode, int ver,
457 int cid0_len, int cid1_len )
Hanno Becker611a83b2018-01-03 14:27:32 +0000458{
459 /*
460 * Test several record encryptions and decryptions
461 * with plenty of space before and after the data
462 * within the record buffer.
463 */
464
465 int ret;
466 int num_records = 16;
467 mbedtls_ssl_context ssl; /* ONLY for debugging */
468
469 mbedtls_ssl_transform t0, t1;
Hanno Becker5c1176e2019-03-01 11:21:44 +0000470 unsigned char *buf = NULL;
Hanno Becker611a83b2018-01-03 14:27:32 +0000471 size_t const buflen = 512;
472 mbedtls_record rec, rec_backup;
473
474 mbedtls_ssl_init( &ssl );
475 mbedtls_ssl_transform_init( &t0 );
476 mbedtls_ssl_transform_init( &t1 );
Hanno Beckerac8c9842019-07-05 13:53:06 +0100477
478#if defined(MBEDTLS_SSL_CONF_FIXED_MINOR_VER)
479 TEST_ASSUME( ver == MBEDTLS_SSL_CONF_FIXED_MINOR_VER );
480#endif
481
Hanno Becker611a83b2018-01-03 14:27:32 +0000482 TEST_ASSERT( build_transforms( &t0, &t1, cipher_type, hash_id,
Hanno Beckerd8f753b2019-04-29 17:30:59 +0100483 etm, tag_mode, ver,
484 (size_t) cid0_len,
485 (size_t) cid1_len ) == 0 );
Hanno Becker611a83b2018-01-03 14:27:32 +0000486
Hanno Beckerafc528a2019-04-04 16:31:26 +0100487 TEST_ASSERT( ( buf = mbedtls_calloc( 1, buflen ) ) != NULL );
Hanno Becker611a83b2018-01-03 14:27:32 +0000488
489 while( num_records-- > 0 )
490 {
491 mbedtls_ssl_transform *t_dec, *t_enc;
492 /* Take turns in who's sending and who's receiving. */
493 if( num_records % 3 == 0 )
494 {
495 t_dec = &t0;
496 t_enc = &t1;
497 }
498 else
499 {
500 t_dec = &t1;
501 t_enc = &t0;
502 }
503
504 /*
505 * The record header affects the transformation in two ways:
506 * 1) It determines the AEAD additional data
507 * 2) The record counter sometimes determines the IV.
508 *
509 * Apart from that, the fields don't have influence.
510 * In particular, it is currently not the responsibility
511 * of ssl_encrypt/decrypt_buf to check if the transform
512 * version matches the record version, or that the
513 * type is sensible.
514 */
515
516 memset( rec.ctr, num_records, sizeof( rec.ctr ) );
517 rec.type = 42;
518 rec.ver[0] = num_records;
519 rec.ver[1] = num_records;
Hanno Beckera5a2b082019-05-15 14:03:01 +0100520#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
Hanno Beckerd8f753b2019-04-29 17:30:59 +0100521 rec.cid_len = 0;
Hanno Beckera5a2b082019-05-15 14:03:01 +0100522#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
Hanno Becker611a83b2018-01-03 14:27:32 +0000523
524 rec.buf = buf;
525 rec.buf_len = buflen;
526 rec.data_offset = 16;
527 /* Make sure to vary the length to exercise different
528 * paddings. */
529 rec.data_len = 1 + num_records;
530
531 memset( rec.buf + rec.data_offset, 42, rec.data_len );
532
533 /* Make a copy for later comparison */
534 rec_backup = rec;
535
536 /* Encrypt record */
537 ret = mbedtls_ssl_encrypt_buf( &ssl, t_enc, &rec,
538 rnd_std_rand, NULL );
539 TEST_ASSERT( ret == 0 || ret == MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL );
540 if( ret != 0 )
541 {
542 continue;
543 }
544
545 /* Decrypt record with t_dec */
Hanno Beckerd8f753b2019-04-29 17:30:59 +0100546 ret = mbedtls_ssl_decrypt_buf( &ssl, t_dec, &rec );
547 TEST_ASSERT( ret == 0 );
Hanno Becker611a83b2018-01-03 14:27:32 +0000548
549 /* Compare results */
550 TEST_ASSERT( rec.type == rec_backup.type );
551 TEST_ASSERT( memcmp( rec.ctr, rec_backup.ctr, 8 ) == 0 );
552 TEST_ASSERT( rec.ver[0] == rec_backup.ver[0] );
553 TEST_ASSERT( rec.ver[1] == rec_backup.ver[1] );
554 TEST_ASSERT( rec.data_len == rec_backup.data_len );
555 TEST_ASSERT( rec.data_offset == rec_backup.data_offset );
556 TEST_ASSERT( memcmp( rec.buf + rec.data_offset,
557 rec_backup.buf + rec_backup.data_offset,
558 rec.data_len ) == 0 );
559 }
560
Hanno Becker5c1176e2019-03-01 11:21:44 +0000561exit:
562
Hanno Becker611a83b2018-01-03 14:27:32 +0000563 /* Cleanup */
564 mbedtls_ssl_free( &ssl );
565 mbedtls_ssl_transform_free( &t0 );
566 mbedtls_ssl_transform_free( &t1 );
567
Hanno Beckerafc528a2019-04-04 16:31:26 +0100568 mbedtls_free( buf );
Hanno Becker611a83b2018-01-03 14:27:32 +0000569}
570/* END_CASE */
Hanno Beckerd3000032018-01-05 15:20:24 +0000571
572/* BEGIN_CASE */
573void ssl_crypt_record_small( int cipher_type, int hash_id,
Hanno Beckerd8f753b2019-04-29 17:30:59 +0100574 int etm, int tag_mode, int ver,
575 int cid0_len, int cid1_len )
Hanno Beckerd3000032018-01-05 15:20:24 +0000576{
577 /*
578 * Test pairs of encryption and decryption with an increasing
579 * amount of space in the record buffer - in more detail:
580 * 1) Try to encrypt with 0, 1, 2, ... bytes available
581 * in front of the plaintext, and expect the encryption
582 * to succeed starting from some offset. Always keep
583 * enough space in the end of the buffer.
584 * 2) Try to encrypt with 0, 1, 2, ... bytes available
585 * at the end of the plaintext, and expect the encryption
586 * to succeed starting from some offset. Always keep
587 * enough space at the beginning of the buffer.
588 * 3) Try to encrypt with 0, 1, 2, ... bytes available
589 * both at the front and end of the plaintext,
590 * and expect the encryption to succeed starting from
591 * some offset.
592 *
593 * If encryption succeeds, check that decryption succeeds
594 * and yields the original record.
595 */
596
597 mbedtls_ssl_context ssl; /* ONLY for debugging */
598
599 mbedtls_ssl_transform t0, t1;
Hanno Becker5c1176e2019-03-01 11:21:44 +0000600 unsigned char *buf = NULL;
Hanno Beckerd8f753b2019-04-29 17:30:59 +0100601 size_t const buflen = 256;
Hanno Beckerd3000032018-01-05 15:20:24 +0000602 mbedtls_record rec, rec_backup;
603
604 int ret;
Hanno Beckerd8f753b2019-04-29 17:30:59 +0100605 int mode; /* Mode 1, 2 or 3 as explained above */
606 size_t offset; /* Available space at beginning/end/both */
607 size_t threshold = 96; /* Maximum offset to test against */
Hanno Beckerd3000032018-01-05 15:20:24 +0000608
Hanno Beckerd8f753b2019-04-29 17:30:59 +0100609 size_t default_pre_padding = 64; /* Pre-padding to use in mode 2 */
610 size_t default_post_padding = 128; /* Post-padding to use in mode 1 */
Hanno Beckerd3000032018-01-05 15:20:24 +0000611
612 int seen_success; /* Indicates if in the current mode we've
613 * already seen a successful test. */
614
615 mbedtls_ssl_init( &ssl );
616 mbedtls_ssl_transform_init( &t0 );
617 mbedtls_ssl_transform_init( &t1 );
618 TEST_ASSERT( build_transforms( &t0, &t1, cipher_type, hash_id,
Hanno Beckerd8f753b2019-04-29 17:30:59 +0100619 etm, tag_mode, ver,
620 (size_t) cid0_len,
621 (size_t) cid1_len ) == 0 );
Hanno Beckerd3000032018-01-05 15:20:24 +0000622
Hanno Beckerac8c9842019-07-05 13:53:06 +0100623#if defined(MBEDTLS_SSL_CONF_FIXED_MINOR_VER)
624 TEST_ASSUME( ver == MBEDTLS_SSL_CONF_FIXED_MINOR_VER );
625#endif
626
Hanno Beckerafc528a2019-04-04 16:31:26 +0100627 TEST_ASSERT( ( buf = mbedtls_calloc( 1, buflen ) ) != NULL );
Hanno Beckerd3000032018-01-05 15:20:24 +0000628
629 for( mode=1; mode <= 3; mode++ )
630 {
631 seen_success = 0;
632 for( offset=0; offset <= threshold; offset++ )
633 {
634 mbedtls_ssl_transform *t_dec, *t_enc;
Hanno Becker36fb3792019-04-29 17:24:44 +0100635 t_dec = &t0;
636 t_enc = &t1;
Hanno Beckerd3000032018-01-05 15:20:24 +0000637
638 memset( rec.ctr, offset, sizeof( rec.ctr ) );
639 rec.type = 42;
640 rec.ver[0] = offset;
641 rec.ver[1] = offset;
642 rec.buf = buf;
643 rec.buf_len = buflen;
Hanno Beckera5a2b082019-05-15 14:03:01 +0100644#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
Hanno Beckerd8f753b2019-04-29 17:30:59 +0100645 rec.cid_len = 0;
Hanno Beckera5a2b082019-05-15 14:03:01 +0100646#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
Hanno Beckerd3000032018-01-05 15:20:24 +0000647
648 switch( mode )
649 {
650 case 1: /* Space in the beginning */
651 rec.data_offset = offset;
652 rec.data_len = buflen - offset - default_post_padding;
653 break;
654
655 case 2: /* Space in the end */
656 rec.data_offset = default_pre_padding;
657 rec.data_len = buflen - default_pre_padding - offset;
658 break;
659
660 case 3: /* Space in the beginning and end */
661 rec.data_offset = offset;
662 rec.data_len = buflen - 2 * offset;
663 break;
664
665 default:
666 TEST_ASSERT( 0 );
667 break;
668 }
669
670 memset( rec.buf + rec.data_offset, 42, rec.data_len );
671
672 /* Make a copy for later comparison */
673 rec_backup = rec;
674
675 /* Encrypt record */
676 ret = mbedtls_ssl_encrypt_buf( &ssl, t_enc, &rec, rnd_std_rand, NULL );
677
678 if( ( mode == 1 || mode == 2 ) && seen_success )
679 {
680 TEST_ASSERT( ret == 0 );
681 }
682 else
683 {
684 TEST_ASSERT( ret == 0 || ret == MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL );
685 if( ret == 0 )
686 seen_success = 1;
687 }
688
689 if( ret != 0 )
690 continue;
691
692 /* Decrypt record with t_dec */
693 TEST_ASSERT( mbedtls_ssl_decrypt_buf( &ssl, t_dec, &rec ) == 0 );
694
695 /* Compare results */
696 TEST_ASSERT( rec.type == rec_backup.type );
697 TEST_ASSERT( memcmp( rec.ctr, rec_backup.ctr, 8 ) == 0 );
698 TEST_ASSERT( rec.ver[0] == rec_backup.ver[0] );
699 TEST_ASSERT( rec.ver[1] == rec_backup.ver[1] );
700 TEST_ASSERT( rec.data_len == rec_backup.data_len );
701 TEST_ASSERT( rec.data_offset == rec_backup.data_offset );
702 TEST_ASSERT( memcmp( rec.buf + rec.data_offset,
703 rec_backup.buf + rec_backup.data_offset,
704 rec.data_len ) == 0 );
705 }
706
707 TEST_ASSERT( seen_success == 1 );
708 }
709
Hanno Becker5c1176e2019-03-01 11:21:44 +0000710exit:
711
Hanno Beckerd3000032018-01-05 15:20:24 +0000712 /* Cleanup */
713 mbedtls_ssl_free( &ssl );
714 mbedtls_ssl_transform_free( &t0 );
715 mbedtls_ssl_transform_free( &t1 );
716
Hanno Beckerafc528a2019-04-04 16:31:26 +0100717 mbedtls_free( buf );
Hanno Beckerd3000032018-01-05 15:20:24 +0000718}
719/* END_CASE */
Manuel Pégourié-Gonnarddfa5a7a2019-05-23 09:30:55 +0200720
Manuel Pégourié-Gonnard2a62a052019-05-24 09:41:39 +0200721/* BEGIN_CASE */
Manuel Pégourié-Gonnard35ccdbb2019-06-03 09:55:16 +0200722void ssl_serialize_session_save_load( int ticket_len, char *crt_file )
Manuel Pégourié-Gonnard2a62a052019-05-24 09:41:39 +0200723{
724 mbedtls_ssl_session original, restored;
725 unsigned char *buf = NULL;
726 size_t len;
727
728 /*
729 * Test that a save-load pair is the identity
730 */
731
732 mbedtls_ssl_session_init( &original );
733 mbedtls_ssl_session_init( &restored );
734
735 /* Prepare a dummy session to work on */
736 TEST_ASSERT( ssl_populate_session( &original, ticket_len, crt_file ) == 0 );
737
Manuel Pégourié-Gonnard35ccdbb2019-06-03 09:55:16 +0200738 /* Serialize it */
Manuel Pégourié-Gonnard2a62a052019-05-24 09:41:39 +0200739 TEST_ASSERT( mbedtls_ssl_session_save( &original, NULL, 0, &len )
740 == MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL );
741 TEST_ASSERT( ( buf = mbedtls_calloc( 1, len ) ) != NULL );
742 TEST_ASSERT( mbedtls_ssl_session_save( &original, buf, len, &len )
743 == 0 );
744
Manuel Pégourié-Gonnard35ccdbb2019-06-03 09:55:16 +0200745 /* Restore session from serialized data */
Manuel Pégourié-Gonnard2a62a052019-05-24 09:41:39 +0200746 TEST_ASSERT( mbedtls_ssl_session_load( &restored, buf, len) == 0 );
747
748 /*
749 * Make sure both session structures are identical
750 */
751#if defined(MBEDTLS_HAVE_TIME)
752 TEST_ASSERT( original.start == restored.start );
753#endif
Hanno Beckere02758c2019-06-26 15:31:31 +0100754#if !defined(MBEDTLS_SSL_CONF_SINGLE_CIPHERSUITE)
Manuel Pégourié-Gonnard2a62a052019-05-24 09:41:39 +0200755 TEST_ASSERT( original.ciphersuite == restored.ciphersuite );
Hanno Beckere02758c2019-06-26 15:31:31 +0100756#endif
Hanno Becker88440552019-07-03 14:16:13 +0100757#if defined(MBEDTLS_ZLIB_SUPPORT)
Manuel Pégourié-Gonnard2a62a052019-05-24 09:41:39 +0200758 TEST_ASSERT( original.compression == restored.compression );
Hanno Becker88440552019-07-03 14:16:13 +0100759#endif
Manuel Pégourié-Gonnard2a62a052019-05-24 09:41:39 +0200760 TEST_ASSERT( original.id_len == restored.id_len );
761 TEST_ASSERT( memcmp( original.id,
762 restored.id, sizeof( original.id ) ) == 0 );
763 TEST_ASSERT( memcmp( original.master,
764 restored.master, sizeof( original.master ) ) == 0 );
765
766#if defined(MBEDTLS_X509_CRT_PARSE_C)
Hanno Becker2e6d3472019-02-06 15:40:27 +0000767#if defined(MBEDTLS_SSL_KEEP_PEER_CERTIFICATE)
Manuel Pégourié-Gonnard2a62a052019-05-24 09:41:39 +0200768 TEST_ASSERT( ( original.peer_cert == NULL ) ==
769 ( restored.peer_cert == NULL ) );
770 if( original.peer_cert != NULL )
771 {
772 TEST_ASSERT( original.peer_cert->raw.len ==
773 restored.peer_cert->raw.len );
774 TEST_ASSERT( memcmp( original.peer_cert->raw.p,
775 restored.peer_cert->raw.p,
776 original.peer_cert->raw.len ) == 0 );
777 }
Hanno Becker5882dd02019-06-06 16:25:57 +0100778#elif defined(MBEDTLS_SSL_RENEGOTIATION)
Hanno Becker4a2f8e52019-02-06 15:23:38 +0000779 TEST_ASSERT( original.peer_cert_digest_type ==
780 restored.peer_cert_digest_type );
781 TEST_ASSERT( original.peer_cert_digest_len ==
782 restored.peer_cert_digest_len );
783 TEST_ASSERT( ( original.peer_cert_digest == NULL ) ==
784 ( restored.peer_cert_digest == NULL ) );
785 if( original.peer_cert_digest != NULL )
786 {
787 TEST_ASSERT( memcmp( original.peer_cert_digest,
788 restored.peer_cert_digest,
789 original.peer_cert_digest_len ) == 0 );
790 }
Hanno Becker5882dd02019-06-06 16:25:57 +0100791#endif /* !MBEDTLS_SSL_KEEP_PEER_CERTIFICATE && MBEDTLS_SSL_RENEGOTIATION */
Hanno Becker4a2f8e52019-02-06 15:23:38 +0000792#endif /* MBEDTLS_X509_CRT_PARSE_C */
Manuel Pégourié-Gonnard2a62a052019-05-24 09:41:39 +0200793 TEST_ASSERT( original.verify_result == restored.verify_result );
794
795#if defined(MBEDTLS_SSL_SESSION_TICKETS) && defined(MBEDTLS_SSL_CLI_C)
796 TEST_ASSERT( original.ticket_len == restored.ticket_len );
797 if( original.ticket_len != 0 )
798 {
799 TEST_ASSERT( original.ticket != NULL );
800 TEST_ASSERT( restored.ticket != NULL );
801 TEST_ASSERT( memcmp( original.ticket,
802 restored.ticket, original.ticket_len ) == 0 );
803 }
804 TEST_ASSERT( original.ticket_lifetime == restored.ticket_lifetime );
805#endif
806
807#if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
808 TEST_ASSERT( original.mfl_code == restored.mfl_code );
809#endif
810
811#if defined(MBEDTLS_SSL_TRUNCATED_HMAC)
812 TEST_ASSERT( original.trunc_hmac == restored.trunc_hmac );
813#endif
814
815#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
816 TEST_ASSERT( original.encrypt_then_mac == restored.encrypt_then_mac );
817#endif
818
819exit:
820 mbedtls_ssl_session_free( &original );
821 mbedtls_ssl_session_free( &restored );
822 mbedtls_free( buf );
823}
824/* END_CASE */
825
Manuel Pégourié-Gonnardc4f50802019-06-03 10:53:47 +0200826/* BEGIN_CASE */
Manuel Pégourié-Gonnard35ccdbb2019-06-03 09:55:16 +0200827void ssl_serialize_session_load_save( int ticket_len, char *crt_file )
Manuel Pégourié-Gonnarddfa5a7a2019-05-23 09:30:55 +0200828{
829 mbedtls_ssl_session session;
830 unsigned char *buf1 = NULL, *buf2 = NULL;
831 size_t len0, len1, len2;
832
833 /*
834 * Test that a load-save pair is the identity
835 */
836
837 mbedtls_ssl_session_init( &session );
838
Manuel Pégourié-Gonnard16f6bb12019-05-23 10:06:14 +0200839 /* Prepare a dummy session to work on */
Manuel Pégourié-Gonnardaab62042019-05-24 09:40:17 +0200840 TEST_ASSERT( ssl_populate_session( &session, ticket_len, crt_file ) == 0 );
Manuel Pégourié-Gonnard16f6bb12019-05-23 10:06:14 +0200841
Manuel Pégourié-Gonnard35ccdbb2019-06-03 09:55:16 +0200842 /* Get desired buffer size for serializing */
Manuel Pégourié-Gonnarddfa5a7a2019-05-23 09:30:55 +0200843 TEST_ASSERT( mbedtls_ssl_session_save( &session, NULL, 0, &len0 )
844 == MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL );
845
846 /* Allocate first buffer */
847 buf1 = mbedtls_calloc( 1, len0 );
848 TEST_ASSERT( buf1 != NULL );
849
Manuel Pégourié-Gonnard35ccdbb2019-06-03 09:55:16 +0200850 /* Serialize to buffer and free live session */
Manuel Pégourié-Gonnarddfa5a7a2019-05-23 09:30:55 +0200851 TEST_ASSERT( mbedtls_ssl_session_save( &session, buf1, len0, &len1 )
852 == 0 );
853 TEST_ASSERT( len0 == len1 );
854 mbedtls_ssl_session_free( &session );
855
Manuel Pégourié-Gonnard35ccdbb2019-06-03 09:55:16 +0200856 /* Restore session from serialized data */
Manuel Pégourié-Gonnardd1a54512019-05-24 09:54:21 +0200857 TEST_ASSERT( mbedtls_ssl_session_load( &session, buf1, len1 ) == 0 );
Manuel Pégourié-Gonnarddfa5a7a2019-05-23 09:30:55 +0200858
Manuel Pégourié-Gonnard35ccdbb2019-06-03 09:55:16 +0200859 /* Allocate second buffer and serialize to it */
Manuel Pégourié-Gonnarddfa5a7a2019-05-23 09:30:55 +0200860 buf2 = mbedtls_calloc( 1, len0 );
Manuel Pégourié-Gonnard081b1522019-05-24 09:52:10 +0200861 TEST_ASSERT( buf2 != NULL );
Manuel Pégourié-Gonnarddfa5a7a2019-05-23 09:30:55 +0200862 TEST_ASSERT( mbedtls_ssl_session_save( &session, buf2, len0, &len2 )
863 == 0 );
864
Manuel Pégourié-Gonnard35ccdbb2019-06-03 09:55:16 +0200865 /* Make sure both serialized versions are identical */
Manuel Pégourié-Gonnarddfa5a7a2019-05-23 09:30:55 +0200866 TEST_ASSERT( len1 == len2 );
867 TEST_ASSERT( memcmp( buf1, buf2, len1 ) == 0 );
868
869exit:
870 mbedtls_ssl_session_free( &session );
871 mbedtls_free( buf1 );
872 mbedtls_free( buf2 );
873}
874/* END_CASE */
Manuel Pégourié-Gonnard98fccc32019-05-23 10:38:11 +0200875
876/* BEGIN_CASE */
Manuel Pégourié-Gonnard35ccdbb2019-06-03 09:55:16 +0200877void ssl_serialize_session_save_buf_size( int ticket_len, char *crt_file )
Manuel Pégourié-Gonnard98fccc32019-05-23 10:38:11 +0200878{
879 mbedtls_ssl_session session;
880 unsigned char *buf = NULL;
881 size_t good_len, bad_len, test_len;
882
883 /*
884 * Test that session_save() fails cleanly on small buffers
885 */
886
887 mbedtls_ssl_session_init( &session );
888
Manuel Pégourié-Gonnard35ccdbb2019-06-03 09:55:16 +0200889 /* Prepare dummy session and get serialized size */
Manuel Pégourié-Gonnardaab62042019-05-24 09:40:17 +0200890 TEST_ASSERT( ssl_populate_session( &session, ticket_len, crt_file ) == 0 );
Manuel Pégourié-Gonnard98fccc32019-05-23 10:38:11 +0200891 TEST_ASSERT( mbedtls_ssl_session_save( &session, NULL, 0, &good_len )
892 == MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL );
893
894 /* Try all possible bad lengths */
895 for( bad_len = 1; bad_len < good_len; bad_len++ )
896 {
897 /* Allocate exact size so that asan/valgrind can detect any overwrite */
898 mbedtls_free( buf );
899 TEST_ASSERT( ( buf = mbedtls_calloc( 1, bad_len ) ) != NULL );
900 TEST_ASSERT( mbedtls_ssl_session_save( &session, buf, bad_len,
901 &test_len )
902 == MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL );
903 TEST_ASSERT( test_len == good_len );
904 }
905
906exit:
907 mbedtls_ssl_session_free( &session );
908 mbedtls_free( buf );
909}
910/* END_CASE */
Manuel Pégourié-Gonnard57098112019-05-23 12:28:45 +0200911
912/* BEGIN_CASE */
Manuel Pégourié-Gonnard35ccdbb2019-06-03 09:55:16 +0200913void ssl_serialize_session_load_buf_size( int ticket_len, char *crt_file )
Manuel Pégourié-Gonnard57098112019-05-23 12:28:45 +0200914{
915 mbedtls_ssl_session session;
916 unsigned char *good_buf = NULL, *bad_buf = NULL;
917 size_t good_len, bad_len;
918
919 /*
920 * Test that session_load() fails cleanly on small buffers
921 */
922
923 mbedtls_ssl_session_init( &session );
924
Manuel Pégourié-Gonnard35ccdbb2019-06-03 09:55:16 +0200925 /* Prepare serialized session data */
Manuel Pégourié-Gonnardaab62042019-05-24 09:40:17 +0200926 TEST_ASSERT( ssl_populate_session( &session, ticket_len, crt_file ) == 0 );
Manuel Pégourié-Gonnard57098112019-05-23 12:28:45 +0200927 TEST_ASSERT( mbedtls_ssl_session_save( &session, NULL, 0, &good_len )
928 == MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL );
929 TEST_ASSERT( ( good_buf = mbedtls_calloc( 1, good_len ) ) != NULL );
930 TEST_ASSERT( mbedtls_ssl_session_save( &session, good_buf, good_len,
931 &good_len ) == 0 );
932 mbedtls_ssl_session_free( &session );
933
934 /* Try all possible bad lengths */
935 for( bad_len = 0; bad_len < good_len; bad_len++ )
936 {
937 /* Allocate exact size so that asan/valgrind can detect any overread */
938 mbedtls_free( bad_buf );
939 bad_buf = mbedtls_calloc( 1, bad_len ? bad_len : 1 );
940 TEST_ASSERT( bad_buf != NULL );
941 memcpy( bad_buf, good_buf, bad_len );
942
943 TEST_ASSERT( mbedtls_ssl_session_load( &session, bad_buf, bad_len )
944 == MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
945 }
946
947exit:
948 mbedtls_ssl_session_free( &session );
949 mbedtls_free( good_buf );
950 mbedtls_free( bad_buf );
951}
952/* END_CASE */
Hanno Beckerf99ec262019-05-21 16:39:30 +0100953
Hanno Becker08ec1292019-05-29 12:44:28 +0100954/* BEGIN_CASE */
955void ssl_session_serialize_version_check( int corrupt_major,
Hanno Beckerf99ec262019-05-21 16:39:30 +0100956 int corrupt_minor,
957 int corrupt_patch,
958 int corrupt_config )
959{
Hanno Becker08ec1292019-05-29 12:44:28 +0100960 unsigned char serialized_session[ 2048 ];
961 size_t serialized_session_len;
Hanno Beckerf78af372019-05-29 12:45:21 +0100962 unsigned cur_byte;
Hanno Beckerf99ec262019-05-21 16:39:30 +0100963 mbedtls_ssl_session session;
Hanno Beckerf78af372019-05-29 12:45:21 +0100964 uint8_t should_corrupt_byte[] = { corrupt_major == 1,
965 corrupt_minor == 1,
966 corrupt_patch == 1,
967 corrupt_config == 1,
968 corrupt_config == 1 };
969
Hanno Beckerf99ec262019-05-21 16:39:30 +0100970 mbedtls_ssl_session_init( &session );
971
Hanno Beckerf78af372019-05-29 12:45:21 +0100972 /* Infer length of serialized session. */
Hanno Beckerf99ec262019-05-21 16:39:30 +0100973 TEST_ASSERT( mbedtls_ssl_session_save( &session,
Hanno Becker08ec1292019-05-29 12:44:28 +0100974 serialized_session,
975 sizeof( serialized_session ),
976 &serialized_session_len ) == 0 );
Hanno Beckerf99ec262019-05-21 16:39:30 +0100977
Hanno Beckerf78af372019-05-29 12:45:21 +0100978 mbedtls_ssl_session_free( &session );
Hanno Beckerf99ec262019-05-21 16:39:30 +0100979
Hanno Beckerf78af372019-05-29 12:45:21 +0100980 /* Without any modification, we should be able to successfully
Hanno Becker08ec1292019-05-29 12:44:28 +0100981 * de-serialize the session - double-check that. */
Hanno Beckerf99ec262019-05-21 16:39:30 +0100982 TEST_ASSERT( mbedtls_ssl_session_load( &session,
Hanno Becker08ec1292019-05-29 12:44:28 +0100983 serialized_session,
984 serialized_session_len ) == 0 );
Hanno Beckerf99ec262019-05-21 16:39:30 +0100985 mbedtls_ssl_session_free( &session );
986
Hanno Beckerf78af372019-05-29 12:45:21 +0100987 /* Go through the bytes in the serialized session header and
988 * corrupt them bit-by-bit. */
989 for( cur_byte = 0; cur_byte < sizeof( should_corrupt_byte ); cur_byte++ )
Hanno Beckerf99ec262019-05-21 16:39:30 +0100990 {
Hanno Beckerf78af372019-05-29 12:45:21 +0100991 int cur_bit;
992 unsigned char * const byte = &serialized_session[ cur_byte ];
993
994 if( should_corrupt_byte[ cur_byte ] == 0 )
995 continue;
996
997 for( cur_bit = 0; cur_bit < CHAR_BIT; cur_bit++ )
998 {
999 unsigned char const corrupted_bit = 0x1u << cur_bit;
1000 /* Modify a single bit in the serialized session. */
1001 *byte ^= corrupted_bit;
1002
1003 /* Attempt to deserialize */
1004 TEST_ASSERT( mbedtls_ssl_session_load( &session,
1005 serialized_session,
1006 serialized_session_len ) ==
Hanno Becker5dbcc9f2019-06-03 12:58:39 +01001007 MBEDTLS_ERR_SSL_VERSION_MISMATCH );
Hanno Beckerf78af372019-05-29 12:45:21 +01001008
1009 /* Undo the change */
1010 *byte ^= corrupted_bit;
1011 }
Hanno Beckerf99ec262019-05-21 16:39:30 +01001012 }
1013
Hanno Beckerf99ec262019-05-21 16:39:30 +01001014}
1015/* END_CASE */