blob: 4ea0a47ecd6171b1022008bcbe09799daae30666 [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>
Chris Jones84a773f2021-03-05 18:38:47 +00003#include <ssl_misc.h>
Piotr Nowicki2a1f1782020-01-13 09:42:10 +01004#include <mbedtls/ctr_drbg.h>
5#include <mbedtls/entropy.h>
Andrzej Kurek941962e2020-02-07 09:20:32 -05006#include <mbedtls/timing.h>
Piotr Nowickibde7ee82020-02-21 10:59:50 +01007#include <mbedtls/debug.h>
Hanno Becker73c825a2020-09-08 10:52:58 +01008#include <ssl_tls13_keys.h>
Gabor Mezeib35759d2022-02-09 16:59:11 +01009#include <ssl_tls13_invasive.h>
Mateusz Starzyk1aec6462021-02-08 15:34:42 +010010#include "test/certs.h"
Piotr Nowickibde7ee82020-02-21 10:59:50 +010011
Hanno Becker6667ffd2021-04-19 21:59:22 +010012#include <psa/crypto.h>
13
Gabor Mezei22c9a6f2021-10-20 12:09:35 +020014#include <constant_time_internal.h>
Manuel Pégourié-Gonnard045f0942020-07-02 11:34:02 +020015
Manuel Pégourié-Gonnard9670a592020-07-10 10:21:46 +020016#include <test/constant_flow.h>
17
Hanno Becker1413bd82020-09-09 12:46:09 +010018enum
19{
20#define MBEDTLS_SSL_TLS1_3_LABEL( name, string ) \
Xiaofei Baid25fab62021-12-02 06:36:27 +000021 tls13_label_ ## name,
Hanno Becker70d7fb02020-09-09 10:11:21 +010022MBEDTLS_SSL_TLS1_3_LABEL_LIST
23#undef MBEDTLS_SSL_TLS1_3_LABEL
Hanno Becker1413bd82020-09-09 12:46:09 +010024};
Hanno Becker70d7fb02020-09-09 10:11:21 +010025
Piotr Nowickibde7ee82020-02-21 10:59:50 +010026typedef struct log_pattern
27{
28 const char *pattern;
29 size_t counter;
30} log_pattern;
31
Piotr Nowicki438bf3b2020-03-10 12:59:10 +010032/*
33 * This function can be passed to mbedtls to receive output logs from it. In
Piotr Nowickibde7ee82020-02-21 10:59:50 +010034 * this case, it will count the instances of a log_pattern in the received
35 * logged messages.
36 */
37void log_analyzer( void *ctx, int level,
38 const char *file, int line,
39 const char *str )
40{
41 log_pattern *p = (log_pattern *) ctx;
42
43 (void) level;
44 (void) line;
45 (void) file;
46
47 if( NULL != p &&
48 NULL != p->pattern &&
49 NULL != strstr( str, p->pattern ) )
50 {
51 p->counter++;
52 }
53}
Janos Follath6264e662019-11-26 11:11:15 +000054
Paul Elliottc8570442020-04-15 17:00:50 +010055/* Invalid minor version used when not specifying a min/max version or expecting a test to fail */
56#define TEST_SSL_MINOR_VERSION_NONE -1
57
Andrzej Kurek8a6ff152020-02-26 09:10:14 -050058typedef struct handshake_test_options
59{
60 const char *cipher;
Paul Elliottc8570442020-04-15 17:00:50 +010061 int client_min_version;
62 int client_max_version;
63 int server_min_version;
64 int server_max_version;
65 int expected_negotiated_version;
Andrzej Kurek8a6ff152020-02-26 09:10:14 -050066 int pk_alg;
67 data_t *psk_str;
68 int dtls;
Piotr Nowickibde7ee82020-02-21 10:59:50 +010069 int srv_auth_mode;
Andrzej Kurek8a6ff152020-02-26 09:10:14 -050070 int serialize;
71 int mfl;
72 int cli_msg_len;
73 int srv_msg_len;
74 int expected_cli_fragments;
75 int expected_srv_fragments;
76 int renegotiate;
77 int legacy_renegotiation;
Piotr Nowickibde7ee82020-02-21 10:59:50 +010078 void *srv_log_obj;
79 void *cli_log_obj;
80 void (*srv_log_fun)(void *, int, const char *, int, const char *);
81 void (*cli_log_fun)(void *, int, const char *, int, const char *);
Andrzej Kurek0afa2a12020-03-03 10:39:58 -050082 int resize_buffers;
Andrzej Kurek8a6ff152020-02-26 09:10:14 -050083} handshake_test_options;
84
85void init_handshake_options( handshake_test_options *opts )
86{
87 opts->cipher = "";
Paul Elliottc8570442020-04-15 17:00:50 +010088 opts->client_min_version = TEST_SSL_MINOR_VERSION_NONE;
89 opts->client_max_version = TEST_SSL_MINOR_VERSION_NONE;
90 opts->server_min_version = TEST_SSL_MINOR_VERSION_NONE;
91 opts->server_max_version = TEST_SSL_MINOR_VERSION_NONE;
92 opts->expected_negotiated_version = MBEDTLS_SSL_MINOR_VERSION_3;
Andrzej Kurek8a6ff152020-02-26 09:10:14 -050093 opts->pk_alg = MBEDTLS_PK_RSA;
94 opts->psk_str = NULL;
95 opts->dtls = 0;
Piotr Nowickibde7ee82020-02-21 10:59:50 +010096 opts->srv_auth_mode = MBEDTLS_SSL_VERIFY_NONE;
Andrzej Kurek8a6ff152020-02-26 09:10:14 -050097 opts->serialize = 0;
98 opts->mfl = MBEDTLS_SSL_MAX_FRAG_LEN_NONE;
99 opts->cli_msg_len = 100;
100 opts->srv_msg_len = 100;
101 opts->expected_cli_fragments = 1;
102 opts->expected_srv_fragments = 1;
103 opts->renegotiate = 0;
104 opts->legacy_renegotiation = MBEDTLS_SSL_LEGACY_NO_RENEGOTIATION;
Piotr Nowickibde7ee82020-02-21 10:59:50 +0100105 opts->srv_log_obj = NULL;
106 opts->srv_log_obj = NULL;
107 opts->srv_log_fun = NULL;
108 opts->cli_log_fun = NULL;
Andrzej Kurek0afa2a12020-03-03 10:39:58 -0500109 opts->resize_buffers = 1;
Andrzej Kurek8a6ff152020-02-26 09:10:14 -0500110}
Janos Follath6264e662019-11-26 11:11:15 +0000111/*
112 * Buffer structure for custom I/O callbacks.
113 */
114
115typedef struct mbedtls_test_buffer
116{
117 size_t start;
118 size_t content_length;
119 size_t capacity;
120 unsigned char *buffer;
121} mbedtls_test_buffer;
122
123/*
124 * Initialises \p buf. After calling this function it is safe to call
125 * `mbedtls_test_buffer_free()` on \p buf.
126 */
127void mbedtls_test_buffer_init( mbedtls_test_buffer *buf )
128{
129 memset( buf, 0, sizeof( *buf ) );
130}
131
132/*
133 * Sets up \p buf. After calling this function it is safe to call
134 * `mbedtls_test_buffer_put()` and `mbedtls_test_buffer_get()` on \p buf.
135 */
136int mbedtls_test_buffer_setup( mbedtls_test_buffer *buf, size_t capacity )
137{
138 buf->buffer = (unsigned char*) mbedtls_calloc( capacity,
139 sizeof(unsigned char) );
140 if( NULL == buf->buffer )
141 return MBEDTLS_ERR_SSL_ALLOC_FAILED;
142 buf->capacity = capacity;
143
144 return 0;
145}
146
147void mbedtls_test_buffer_free( mbedtls_test_buffer *buf )
148{
149 if( buf->buffer != NULL )
150 mbedtls_free( buf->buffer );
151
152 memset( buf, 0, sizeof( *buf ) );
153}
154
155/*
156 * Puts \p input_len bytes from the \p input buffer into the ring buffer \p buf.
157 *
158 * \p buf must have been initialized and set up by calling
159 * `mbedtls_test_buffer_init()` and `mbedtls_test_buffer_setup()`.
160 *
161 * \retval \p input_len, if the data fits.
162 * \retval 0 <= value < \p input_len, if the data does not fit.
163 * \retval -1, if \p buf is NULL, it hasn't been set up or \p input_len is not
164 * zero and \p input is NULL.
165 */
166int mbedtls_test_buffer_put( mbedtls_test_buffer *buf,
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100167 const unsigned char *input, size_t input_len )
Janos Follath6264e662019-11-26 11:11:15 +0000168{
169 size_t overflow = 0;
170
171 if( ( buf == NULL ) || ( buf->buffer == NULL ) )
172 return -1;
173
174 /* Reduce input_len to a number that fits in the buffer. */
175 if ( ( buf->content_length + input_len ) > buf->capacity )
176 {
177 input_len = buf->capacity - buf->content_length;
178 }
179
180 if( input == NULL )
181 {
182 return ( input_len == 0 ) ? 0 : -1;
183 }
184
Piotr Nowickifb437d72020-01-13 16:59:12 +0100185 /* Check if the buffer has not come full circle and free space is not in
186 * the middle */
187 if( buf->start + buf->content_length < buf->capacity )
Janos Follath6264e662019-11-26 11:11:15 +0000188 {
Piotr Nowickifb437d72020-01-13 16:59:12 +0100189
190 /* Calculate the number of bytes that need to be placed at lower memory
191 * address */
192 if( buf->start + buf->content_length + input_len
193 > buf->capacity )
194 {
195 overflow = ( buf->start + buf->content_length + input_len )
196 % buf->capacity;
197 }
198
199 memcpy( buf->buffer + buf->start + buf->content_length, input,
200 input_len - overflow );
201 memcpy( buf->buffer, input + input_len - overflow, overflow );
202
203 }
204 else
205 {
206 /* The buffer has come full circle and free space is in the middle */
207 memcpy( buf->buffer + buf->start + buf->content_length - buf->capacity,
208 input, input_len );
Janos Follath6264e662019-11-26 11:11:15 +0000209 }
210
Janos Follath6264e662019-11-26 11:11:15 +0000211 buf->content_length += input_len;
Janos Follath6264e662019-11-26 11:11:15 +0000212 return input_len;
213}
214
215/*
Andrzej Kurekf7774142020-01-22 06:34:59 -0500216 * Gets \p output_len bytes from the ring buffer \p buf into the
217 * \p output buffer. The output buffer can be NULL, in this case a part of the
218 * ring buffer will be dropped, if the requested length is available.
Janos Follath6264e662019-11-26 11:11:15 +0000219 *
220 * \p buf must have been initialized and set up by calling
221 * `mbedtls_test_buffer_init()` and `mbedtls_test_buffer_setup()`.
222 *
223 * \retval \p output_len, if the data is available.
224 * \retval 0 <= value < \p output_len, if the data is not available.
Andrzej Kurekf7774142020-01-22 06:34:59 -0500225 * \retval -1, if \buf is NULL or it hasn't been set up.
Janos Follath6264e662019-11-26 11:11:15 +0000226 */
227int mbedtls_test_buffer_get( mbedtls_test_buffer *buf,
228 unsigned char* output, size_t output_len )
229{
230 size_t overflow = 0;
231
232 if( ( buf == NULL ) || ( buf->buffer == NULL ) )
233 return -1;
234
Andrzej Kurekf7774142020-01-22 06:34:59 -0500235 if( output == NULL && output_len == 0 )
236 return 0;
Janos Follath6264e662019-11-26 11:11:15 +0000237
238 if( buf->content_length < output_len )
239 output_len = buf->content_length;
240
241 /* Calculate the number of bytes that need to be drawn from lower memory
242 * address */
243 if( buf->start + output_len > buf->capacity )
244 {
245 overflow = ( buf->start + output_len ) % buf->capacity;
246 }
247
Andrzej Kurekf7774142020-01-22 06:34:59 -0500248 if( output != NULL )
249 {
250 memcpy( output, buf->buffer + buf->start, output_len - overflow );
251 memcpy( output + output_len - overflow, buf->buffer, overflow );
252 }
253
Janos Follath6264e662019-11-26 11:11:15 +0000254 buf->content_length -= output_len;
255 buf->start = ( buf->start + output_len ) % buf->capacity;
256
257 return output_len;
258}
259
Hanno Beckera18d1322018-01-03 14:27:32 +0000260/*
Andrzej Kurek13719cd2020-01-22 06:36:39 -0500261 * Errors used in the message transport mock tests
262 */
263 #define MBEDTLS_TEST_ERROR_ARG_NULL -11
Andrzej Kurek13719cd2020-01-22 06:36:39 -0500264 #define MBEDTLS_TEST_ERROR_MESSAGE_TRUNCATED -44
265
266/*
267 * Context for a message metadata queue (fifo) that is on top of the ring buffer.
268 */
269typedef struct mbedtls_test_message_queue
270{
271 size_t *messages;
272 int pos;
273 int num;
274 int capacity;
275} mbedtls_test_message_queue;
276
277/*
278 * Setup and free functions for the message metadata queue.
279 *
280 * \p capacity describes the number of message metadata chunks that can be held
281 * within the queue.
282 *
283 * \retval 0, if a metadata queue of a given length can be allocated.
284 * \retval MBEDTLS_ERR_SSL_ALLOC_FAILED, if allocation failed.
285 */
286int mbedtls_test_message_queue_setup( mbedtls_test_message_queue *queue,
287 size_t capacity )
288{
289 queue->messages = (size_t*) mbedtls_calloc( capacity, sizeof(size_t) );
290 if( NULL == queue->messages )
291 return MBEDTLS_ERR_SSL_ALLOC_FAILED;
292
293 queue->capacity = capacity;
294 queue->pos = 0;
295 queue->num = 0;
296
297 return 0;
298}
299
300void mbedtls_test_message_queue_free( mbedtls_test_message_queue *queue )
301{
302 if( queue == NULL )
303 return;
304
305 if( queue->messages != NULL )
306 mbedtls_free( queue->messages );
307
308 memset( queue, 0, sizeof( *queue ) );
309}
310
311/*
312 * Push message length information onto the message metadata queue.
313 * This will become the last element to leave it (fifo).
314 *
315 * \retval MBEDTLS_TEST_ERROR_ARG_NULL, if the queue is null.
Andrzej Kurekf46b9122020-02-07 08:19:00 -0500316 * \retval MBEDTLS_ERR_SSL_WANT_WRITE, if the queue is full.
Andrzej Kurek13719cd2020-01-22 06:36:39 -0500317 * \retval \p len, if the push was successful.
318 */
319int mbedtls_test_message_queue_push_info( mbedtls_test_message_queue *queue,
320 size_t len )
321{
322 int place;
323 if( queue == NULL )
324 return MBEDTLS_TEST_ERROR_ARG_NULL;
325
326 if( queue->num >= queue->capacity )
Andrzej Kurekf46b9122020-02-07 08:19:00 -0500327 return MBEDTLS_ERR_SSL_WANT_WRITE;
Andrzej Kurek13719cd2020-01-22 06:36:39 -0500328
329 place = ( queue->pos + queue->num ) % queue->capacity;
330 queue->messages[place] = len;
331 queue->num++;
332 return len;
333}
334
335/*
336 * Pop information about the next message length from the queue. This will be
337 * the oldest inserted message length(fifo). \p msg_len can be null, in which
338 * case the data will be popped from the queue but not copied anywhere.
339 *
340 * \retval MBEDTLS_TEST_ERROR_ARG_NULL, if the queue is null.
Andrzej Kurekf46b9122020-02-07 08:19:00 -0500341 * \retval MBEDTLS_ERR_SSL_WANT_READ, if the queue is empty.
Andrzej Kurek13719cd2020-01-22 06:36:39 -0500342 * \retval message length, if the pop was successful, up to the given
343 \p buf_len.
344 */
345int mbedtls_test_message_queue_pop_info( mbedtls_test_message_queue *queue,
346 size_t buf_len )
347{
348 size_t message_length;
349 if( queue == NULL )
350 return MBEDTLS_TEST_ERROR_ARG_NULL;
351 if( queue->num == 0 )
Andrzej Kurekf46b9122020-02-07 08:19:00 -0500352 return MBEDTLS_ERR_SSL_WANT_READ;
Andrzej Kurek13719cd2020-01-22 06:36:39 -0500353
354 message_length = queue->messages[queue->pos];
355 queue->messages[queue->pos] = 0;
356 queue->num--;
357 queue->pos++;
358 queue->pos %= queue->capacity;
359 if( queue->pos < 0 )
360 queue->pos += queue->capacity;
361
362 return ( message_length > buf_len ) ? buf_len : message_length;
363}
364
365/*
366 * Take a peek on the info about the next message length from the queue.
367 * This will be the oldest inserted message length(fifo).
368 *
369 * \retval MBEDTLS_TEST_ERROR_ARG_NULL, if the queue is null.
Andrzej Kurekf46b9122020-02-07 08:19:00 -0500370 * \retval MBEDTLS_ERR_SSL_WANT_READ, if the queue is empty.
Andrzej Kurek13719cd2020-01-22 06:36:39 -0500371 * \retval 0, if the peek was successful.
372 * \retval MBEDTLS_TEST_ERROR_MESSAGE_TRUNCATED, if the given buffer length is
373 * too small to fit the message. In this case the \p msg_len will be
374 * set to the full message length so that the
375 * caller knows what portion of the message can be dropped.
376 */
377int mbedtls_test_message_queue_peek_info( mbedtls_test_message_queue *queue,
378 size_t buf_len, size_t* msg_len )
379{
380 if( queue == NULL || msg_len == NULL )
381 return MBEDTLS_TEST_ERROR_ARG_NULL;
382 if( queue->num == 0 )
Andrzej Kurekf46b9122020-02-07 08:19:00 -0500383 return MBEDTLS_ERR_SSL_WANT_READ;
Andrzej Kurek13719cd2020-01-22 06:36:39 -0500384
385 *msg_len = queue->messages[queue->pos];
386 return ( *msg_len > buf_len ) ? MBEDTLS_TEST_ERROR_MESSAGE_TRUNCATED : 0;
387}
388/*
Janos Follath031827f2019-11-27 11:12:14 +0000389 * Context for the I/O callbacks simulating network connection.
390 */
391
392#define MBEDTLS_MOCK_SOCKET_CONNECTED 1
393
394typedef struct mbedtls_mock_socket
395{
396 int status;
397 mbedtls_test_buffer *input;
398 mbedtls_test_buffer *output;
399 struct mbedtls_mock_socket *peer;
400} mbedtls_mock_socket;
401
402/*
403 * Setup and teardown functions for mock sockets.
404 */
405void mbedtls_mock_socket_init( mbedtls_mock_socket *socket )
406{
407 memset( socket, 0, sizeof( *socket ) );
408}
409
410/*
411 * Closes the socket \p socket.
412 *
413 * \p socket must have been previously initialized by calling
414 * mbedtls_mock_socket_init().
415 *
416 * This function frees all allocated resources and both sockets are aware of the
417 * new connection state.
418 *
419 * That is, this function does not simulate half-open TCP connections and the
420 * phenomenon that when closing a UDP connection the peer is not aware of the
421 * connection having been closed.
422 */
423void mbedtls_mock_socket_close( mbedtls_mock_socket* socket )
424{
425 if( socket == NULL )
426 return;
427
428 if( socket->input != NULL )
429 {
430 mbedtls_test_buffer_free( socket->input );
431 mbedtls_free( socket->input );
432 }
433
434 if( socket->output != NULL )
435 {
436 mbedtls_test_buffer_free( socket->output );
437 mbedtls_free( socket->output );
438 }
439
440 if( socket->peer != NULL )
441 memset( socket->peer, 0, sizeof( *socket->peer ) );
442
443 memset( socket, 0, sizeof( *socket ) );
444}
445
446/*
447 * Establishes a connection between \p peer1 and \p peer2.
448 *
449 * \p peer1 and \p peer2 must have been previously initialized by calling
450 * mbedtls_mock_socket_init().
451 *
452 * The capacites of the internal buffers are set to \p bufsize. Setting this to
453 * the correct value allows for simulation of MTU, sanity testing the mock
454 * implementation and mocking TCP connections with lower memory cost.
455 */
456int mbedtls_mock_socket_connect( mbedtls_mock_socket* peer1,
457 mbedtls_mock_socket* peer2,
458 size_t bufsize )
459{
460 int ret = -1;
461
Piotr Nowickid796e192020-01-28 12:09:47 +0100462 peer1->output =
Janos Follath031827f2019-11-27 11:12:14 +0000463 (mbedtls_test_buffer*) mbedtls_calloc( 1, sizeof(mbedtls_test_buffer) );
464 if( peer1->output == NULL )
465 {
466 ret = MBEDTLS_ERR_SSL_ALLOC_FAILED;
467 goto exit;
468 }
469 mbedtls_test_buffer_init( peer1->output );
470 if( 0 != ( ret = mbedtls_test_buffer_setup( peer1->output, bufsize ) ) )
471 {
472 goto exit;
473 }
474
Piotr Nowickid796e192020-01-28 12:09:47 +0100475 peer2->output =
476 (mbedtls_test_buffer*) mbedtls_calloc( 1, sizeof(mbedtls_test_buffer) );
477 if( peer2->output == NULL )
478 {
479 ret = MBEDTLS_ERR_SSL_ALLOC_FAILED;
480 goto exit;
481 }
482 mbedtls_test_buffer_init( peer2->output );
483 if( 0 != ( ret = mbedtls_test_buffer_setup( peer2->output, bufsize ) ) )
484 {
485 goto exit;
486 }
487
Janos Follath031827f2019-11-27 11:12:14 +0000488 peer1->peer = peer2;
489 peer2->peer = peer1;
Piotr Nowickid796e192020-01-28 12:09:47 +0100490 peer1->input = peer2->output;
491 peer2->input = peer1->output;
Janos Follath031827f2019-11-27 11:12:14 +0000492
493 peer1->status = peer2->status = MBEDTLS_MOCK_SOCKET_CONNECTED;
494 ret = 0;
495
496exit:
497
498 if( ret != 0 )
499 {
500 mbedtls_mock_socket_close( peer1 );
501 mbedtls_mock_socket_close( peer2 );
502 }
503
504 return ret;
505}
506
507/*
508 * Callbacks for simulating blocking I/O over connection-oriented transport.
509 */
510
511int mbedtls_mock_tcp_send_b( void *ctx, const unsigned char *buf, size_t len )
512{
513 mbedtls_mock_socket *socket = (mbedtls_mock_socket*) ctx;
514
515 if( socket == NULL || socket->status != MBEDTLS_MOCK_SOCKET_CONNECTED )
516 return -1;
517
518 return mbedtls_test_buffer_put( socket->output, buf, len );
519}
520
521int mbedtls_mock_tcp_recv_b( void *ctx, unsigned char *buf, size_t len )
522{
523 mbedtls_mock_socket *socket = (mbedtls_mock_socket*) ctx;
524
525 if( socket == NULL || socket->status != MBEDTLS_MOCK_SOCKET_CONNECTED )
526 return -1;
527
528 return mbedtls_test_buffer_get( socket->input, buf, len );
529}
530
531/*
Janos Follath3766ba52019-11-27 13:31:42 +0000532 * Callbacks for simulating non-blocking I/O over connection-oriented transport.
533 */
534
535int mbedtls_mock_tcp_send_nb( void *ctx, const unsigned char *buf, size_t len )
536{
537 mbedtls_mock_socket *socket = (mbedtls_mock_socket*) ctx;
538
539 if( socket == NULL || socket->status != MBEDTLS_MOCK_SOCKET_CONNECTED )
540 return -1;
541
Piotr Nowicki890b5ca2020-01-15 16:19:07 +0100542 if( socket->output->capacity == socket->output->content_length )
Janos Follath3766ba52019-11-27 13:31:42 +0000543 {
Janos Follath3766ba52019-11-27 13:31:42 +0000544 return MBEDTLS_ERR_SSL_WANT_WRITE;
545 }
546
Janos Follath3766ba52019-11-27 13:31:42 +0000547 return mbedtls_test_buffer_put( socket->output, buf, len );
548}
549
550int mbedtls_mock_tcp_recv_nb( void *ctx, unsigned char *buf, size_t len )
551{
552 mbedtls_mock_socket *socket = (mbedtls_mock_socket*) ctx;
553
554 if( socket == NULL || socket->status != MBEDTLS_MOCK_SOCKET_CONNECTED )
555 return -1;
556
Andrzej Kurekf40daa32020-02-04 09:00:01 -0500557 if( socket->input->content_length == 0 )
Janos Follath3766ba52019-11-27 13:31:42 +0000558 {
Janos Follath3766ba52019-11-27 13:31:42 +0000559 return MBEDTLS_ERR_SSL_WANT_READ;
560 }
561
Janos Follath3766ba52019-11-27 13:31:42 +0000562 return mbedtls_test_buffer_get( socket->input, buf, len );
563}
564
Andrzej Kurekbc483de2020-01-22 03:40:00 -0500565/* Errors used in the message socket mocks */
566
567#define MBEDTLS_TEST_ERROR_CONTEXT_ERROR -55
568#define MBEDTLS_TEST_ERROR_SEND_FAILED -66
569#define MBEDTLS_TEST_ERROR_RECV_FAILED -77
570
571/*
572 * Structure used as an addon, or a wrapper, around the mocked sockets.
573 * Contains an input queue, to which the other socket pushes metadata,
574 * and an output queue, to which this one pushes metadata. This context is
575 * considered as an owner of the input queue only, which is initialized and
576 * freed in the respective setup and free calls.
577 */
578typedef struct mbedtls_test_message_socket_context
579{
580 mbedtls_test_message_queue* queue_input;
581 mbedtls_test_message_queue* queue_output;
582 mbedtls_mock_socket* socket;
583} mbedtls_test_message_socket_context;
584
Andrzej Kurek45916ba2020-03-05 14:46:22 -0500585void mbedtls_message_socket_init( mbedtls_test_message_socket_context *ctx )
586{
587 ctx->queue_input = NULL;
588 ctx->queue_output = NULL;
589 ctx->socket = NULL;
590}
591
Andrzej Kurekbc483de2020-01-22 03:40:00 -0500592/*
593 * Setup a given mesasge socket context including initialization of
594 * input/output queues to a chosen capacity of messages. Also set the
595 * corresponding mock socket.
596 *
597 * \retval 0, if everything succeeds.
598 * \retval MBEDTLS_ERR_SSL_ALLOC_FAILED, if allocation of a message
599 * queue failed.
600 */
601int mbedtls_message_socket_setup( mbedtls_test_message_queue* queue_input,
602 mbedtls_test_message_queue* queue_output,
603 size_t queue_capacity,
604 mbedtls_mock_socket* socket,
605 mbedtls_test_message_socket_context* ctx )
606{
607 int ret = mbedtls_test_message_queue_setup( queue_input, queue_capacity );
608 if( ret != 0 )
609 return ret;
610 ctx->queue_input = queue_input;
611 ctx->queue_output = queue_output;
612 ctx->socket = socket;
613 mbedtls_mock_socket_init( socket );
614
615 return 0;
616}
617
618/*
619 * Close a given message socket context, along with the socket itself. Free the
620 * memory allocated by the input queue.
621 */
622void mbedtls_message_socket_close( mbedtls_test_message_socket_context* ctx )
623{
624 if( ctx == NULL )
625 return;
626
627 mbedtls_test_message_queue_free( ctx->queue_input );
628 mbedtls_mock_socket_close( ctx->socket );
629 memset( ctx, 0, sizeof( *ctx ) );
630}
631
632/*
633 * Send one message through a given message socket context.
634 *
635 * \retval \p len, if everything succeeds.
636 * \retval MBEDTLS_TEST_ERROR_CONTEXT_ERROR, if any of the needed context
637 * elements or the context itself is null.
638 * \retval MBEDTLS_TEST_ERROR_SEND_FAILED if mbedtls_mock_tcp_send_b failed.
Andrzej Kurekf46b9122020-02-07 08:19:00 -0500639 * \retval MBEDTLS_ERR_SSL_WANT_WRITE, if the output queue is full.
Andrzej Kurekbc483de2020-01-22 03:40:00 -0500640 *
641 * This function will also return any error from
642 * mbedtls_test_message_queue_push_info.
643 */
644int mbedtls_mock_tcp_send_msg( void *ctx, const unsigned char *buf, size_t len )
645{
646 mbedtls_test_message_queue* queue;
647 mbedtls_mock_socket* socket;
648 mbedtls_test_message_socket_context *context = (mbedtls_test_message_socket_context*) ctx;
649
650 if( context == NULL || context->socket == NULL
651 || context->queue_output == NULL )
652 {
653 return MBEDTLS_TEST_ERROR_CONTEXT_ERROR;
654 }
655
656 queue = context->queue_output;
657 socket = context->socket;
658
659 if( queue->num >= queue->capacity )
Andrzej Kurekf46b9122020-02-07 08:19:00 -0500660 return MBEDTLS_ERR_SSL_WANT_WRITE;
Andrzej Kurekbc483de2020-01-22 03:40:00 -0500661
662 if( mbedtls_mock_tcp_send_b( socket, buf, len ) != (int) len )
663 return MBEDTLS_TEST_ERROR_SEND_FAILED;
664
665 return mbedtls_test_message_queue_push_info( queue, len );
666}
667
668/*
669 * Receive one message from a given message socket context and return message
670 * length or an error.
671 *
672 * \retval message length, if everything succeeds.
673 * \retval MBEDTLS_TEST_ERROR_CONTEXT_ERROR, if any of the needed context
674 * elements or the context itself is null.
675 * \retval MBEDTLS_TEST_ERROR_RECV_FAILED if mbedtls_mock_tcp_recv_b failed.
676 *
677 * This function will also return any error other than
678 * MBEDTLS_TEST_ERROR_MESSAGE_TRUNCATED from mbedtls_test_message_queue_peek_info.
679 */
680int mbedtls_mock_tcp_recv_msg( void *ctx, unsigned char *buf, size_t buf_len )
681{
682 mbedtls_test_message_queue* queue;
683 mbedtls_mock_socket* socket;
684 mbedtls_test_message_socket_context *context = (mbedtls_test_message_socket_context*) ctx;
Gilles Peskine19e841e2020-03-09 20:43:51 +0100685 size_t drop_len = 0;
Andrzej Kurekbc483de2020-01-22 03:40:00 -0500686 size_t msg_len;
687 int ret;
688
689 if( context == NULL || context->socket == NULL
690 || context->queue_input == NULL )
691 {
692 return MBEDTLS_TEST_ERROR_CONTEXT_ERROR;
693 }
694
695 queue = context->queue_input;
696 socket = context->socket;
697
698 /* Peek first, so that in case of a socket error the data remains in
699 * the queue. */
700 ret = mbedtls_test_message_queue_peek_info( queue, buf_len, &msg_len );
701 if( ret == MBEDTLS_TEST_ERROR_MESSAGE_TRUNCATED )
702 {
703 /* Calculate how much to drop */
704 drop_len = msg_len - buf_len;
705
706 /* Set the requested message len to be buffer length */
707 msg_len = buf_len;
708 } else if( ret != 0 )
709 {
710 return ret;
711 }
712
713 if( mbedtls_mock_tcp_recv_b( socket, buf, msg_len ) != (int) msg_len )
714 return MBEDTLS_TEST_ERROR_RECV_FAILED;
715
716 if( ret == MBEDTLS_TEST_ERROR_MESSAGE_TRUNCATED )
717 {
718 /* Drop the remaining part of the message */
719 if( mbedtls_mock_tcp_recv_b( socket, NULL, drop_len ) != (int) drop_len )
720 {
721 /* Inconsistent state - part of the message was read,
722 * and a part couldn't. Not much we can do here, but it should not
723 * happen in test environment, unless forced manually. */
724 }
725 }
726 mbedtls_test_message_queue_pop_info( queue, buf_len );
727
728 return msg_len;
729}
730
Manuel Pégourié-Gonnardd12402f2020-05-20 10:34:25 +0200731#if defined(MBEDTLS_X509_CRT_PARSE_C) && \
732 defined(MBEDTLS_ENTROPY_C) && \
733 defined(MBEDTLS_CTR_DRBG_C)
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100734
735/*
736 * Structure with endpoint's certificates for SSL communication tests.
737 */
738typedef struct mbedtls_endpoint_certificate
739{
740 mbedtls_x509_crt ca_cert;
741 mbedtls_x509_crt cert;
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100742 mbedtls_pk_context pkey;
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100743} mbedtls_endpoint_certificate;
744
745/*
746 * Endpoint structure for SSL communication tests.
747 */
748typedef struct mbedtls_endpoint
749{
750 const char *name;
751 mbedtls_ssl_context ssl;
752 mbedtls_ssl_config conf;
753 mbedtls_ctr_drbg_context ctr_drbg;
754 mbedtls_entropy_context entropy;
755 mbedtls_mock_socket socket;
756 mbedtls_endpoint_certificate cert;
757} mbedtls_endpoint;
758
759/*
760 * Initializes \p ep_cert structure and assigns it to endpoint
761 * represented by \p ep.
762 *
763 * \retval 0 on success, otherwise error code.
764 */
Andrzej Kurekb2980742020-02-02 19:25:26 -0500765int mbedtls_endpoint_certificate_init( mbedtls_endpoint *ep, int pk_alg )
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100766{
767 int i = 0;
768 int ret = -1;
769 mbedtls_endpoint_certificate *cert;
770
771 if( ep == NULL )
772 {
773 return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
774 }
775
776 cert = &( ep->cert );
777 mbedtls_x509_crt_init( &( cert->ca_cert ) );
778 mbedtls_x509_crt_init( &( cert->cert ) );
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100779 mbedtls_pk_init( &( cert->pkey ) );
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100780
781 /* Load the trusted CA */
782
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100783 for( i = 0; mbedtls_test_cas_der[i] != NULL; i++ )
784 {
785 ret = mbedtls_x509_crt_parse_der( &( cert->ca_cert ),
786 (const unsigned char *) mbedtls_test_cas_der[i],
787 mbedtls_test_cas_der_len[i] );
788 TEST_ASSERT( ret == 0 );
789 }
790
791 /* Load own certificate and private key */
792
793 if( ep->conf.endpoint == MBEDTLS_SSL_IS_SERVER )
794 {
Andrzej Kurekb2980742020-02-02 19:25:26 -0500795 if( pk_alg == MBEDTLS_PK_RSA )
796 {
797 ret = mbedtls_x509_crt_parse( &( cert->cert ),
798 (const unsigned char*) mbedtls_test_srv_crt_rsa_sha256_der,
799 mbedtls_test_srv_crt_rsa_sha256_der_len );
800 TEST_ASSERT( ret == 0 );
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100801
Andrzej Kurekb2980742020-02-02 19:25:26 -0500802 ret = mbedtls_pk_parse_key( &( cert->pkey ),
803 (const unsigned char*) mbedtls_test_srv_key_rsa_der,
Manuel Pégourié-Gonnard84dea012021-06-15 11:29:26 +0200804 mbedtls_test_srv_key_rsa_der_len, NULL, 0,
805 mbedtls_test_rnd_std_rand, NULL );
Andrzej Kurekb2980742020-02-02 19:25:26 -0500806 TEST_ASSERT( ret == 0 );
807 }
808 else
809 {
810 ret = mbedtls_x509_crt_parse( &( cert->cert ),
811 (const unsigned char*) mbedtls_test_srv_crt_ec_der,
812 mbedtls_test_srv_crt_ec_der_len );
813 TEST_ASSERT( ret == 0 );
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100814
Andrzej Kurekb2980742020-02-02 19:25:26 -0500815 ret = mbedtls_pk_parse_key( &( cert->pkey ),
816 (const unsigned char*) mbedtls_test_srv_key_ec_der,
Manuel Pégourié-Gonnard84dea012021-06-15 11:29:26 +0200817 mbedtls_test_srv_key_ec_der_len, NULL, 0,
818 mbedtls_test_rnd_std_rand, NULL );
Andrzej Kurekb2980742020-02-02 19:25:26 -0500819 TEST_ASSERT( ret == 0 );
820 }
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100821 }
822 else
823 {
Andrzej Kurekb2980742020-02-02 19:25:26 -0500824 if( pk_alg == MBEDTLS_PK_RSA )
825 {
826 ret = mbedtls_x509_crt_parse( &( cert->cert ),
827 (const unsigned char *) mbedtls_test_cli_crt_rsa_der,
828 mbedtls_test_cli_crt_rsa_der_len );
829 TEST_ASSERT( ret == 0 );
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100830
Andrzej Kurekb2980742020-02-02 19:25:26 -0500831 ret = mbedtls_pk_parse_key( &( cert->pkey ),
832 (const unsigned char *) mbedtls_test_cli_key_rsa_der,
Manuel Pégourié-Gonnard84dea012021-06-15 11:29:26 +0200833 mbedtls_test_cli_key_rsa_der_len, NULL, 0,
834 mbedtls_test_rnd_std_rand, NULL );
Andrzej Kurekb2980742020-02-02 19:25:26 -0500835 TEST_ASSERT( ret == 0 );
836 }
837 else
838 {
839 ret = mbedtls_x509_crt_parse( &( cert->cert ),
840 (const unsigned char *) mbedtls_test_cli_crt_ec_der,
841 mbedtls_test_cli_crt_ec_len );
842 TEST_ASSERT( ret == 0 );
843
844 ret = mbedtls_pk_parse_key( &( cert->pkey ),
845 (const unsigned char *) mbedtls_test_cli_key_ec_der,
Manuel Pégourié-Gonnard84dea012021-06-15 11:29:26 +0200846 mbedtls_test_cli_key_ec_der_len, NULL, 0,
847 mbedtls_test_rnd_std_rand, NULL );
Andrzej Kurekb2980742020-02-02 19:25:26 -0500848 TEST_ASSERT( ret == 0 );
849 }
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100850 }
851
852 mbedtls_ssl_conf_ca_chain( &( ep->conf ), &( cert->ca_cert ), NULL );
853
Andrzej Kurekb2980742020-02-02 19:25:26 -0500854 ret = mbedtls_ssl_conf_own_cert( &( ep->conf ), &( cert->cert ),
855 &( cert->pkey ) );
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100856 TEST_ASSERT( ret == 0 );
857
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100858exit:
859 if( ret != 0 )
860 {
861 mbedtls_x509_crt_free( &( cert->ca_cert ) );
862 mbedtls_x509_crt_free( &( cert->cert ) );
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100863 mbedtls_pk_free( &( cert->pkey ) );
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100864 }
865
866 return ret;
867}
868
869/*
870 * Initializes \p ep structure. It is important to call `mbedtls_endpoint_free()`
871 * after calling this function even if it fails.
872 *
873 * \p endpoint_type must be set as MBEDTLS_SSL_IS_SERVER or
874 * MBEDTLS_SSL_IS_CLIENT.
Andrzej Kurek15daf502020-02-12 09:17:52 -0500875 * \p pk_alg the algorithm to use, currently only MBEDTLS_PK_RSA and
876 * MBEDTLS_PK_ECDSA are supported.
877 * \p dtls_context - in case of DTLS - this is the context handling metadata.
878 * \p input_queue - used only in case of DTLS.
879 * \p output_queue - used only in case of DTLS.
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100880 *
881 * \retval 0 on success, otherwise error code.
882 */
Andrzej Kurek15daf502020-02-12 09:17:52 -0500883int mbedtls_endpoint_init( mbedtls_endpoint *ep, int endpoint_type, int pk_alg,
884 mbedtls_test_message_socket_context *dtls_context,
885 mbedtls_test_message_queue *input_queue,
886 mbedtls_test_message_queue *output_queue )
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100887{
888 int ret = -1;
Gilles Peskine80dae042022-01-21 23:50:39 +0100889 uintptr_t user_data_n;
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100890
Andrzej Kurek15daf502020-02-12 09:17:52 -0500891 if( dtls_context != NULL && ( input_queue == NULL || output_queue == NULL ) )
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100892 return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
Andrzej Kurek15daf502020-02-12 09:17:52 -0500893
894 if( ep == NULL )
895 return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100896
897 memset( ep, 0, sizeof( *ep ) );
898
899 ep->name = ( endpoint_type == MBEDTLS_SSL_IS_SERVER ) ? "Server" : "Client";
900
901 mbedtls_ssl_init( &( ep->ssl ) );
902 mbedtls_ssl_config_init( &( ep->conf ) );
903 mbedtls_ctr_drbg_init( &( ep->ctr_drbg ) );
904 mbedtls_ssl_conf_rng( &( ep->conf ),
905 mbedtls_ctr_drbg_random,
906 &( ep->ctr_drbg ) );
907 mbedtls_entropy_init( &( ep->entropy ) );
Gilles Peskine80dae042022-01-21 23:50:39 +0100908
909 TEST_ASSERT( mbedtls_ssl_conf_get_user_data_p( &ep->conf ) == NULL );
910 TEST_EQUAL( mbedtls_ssl_conf_get_user_data_n( &ep->conf ), 0 );
911 TEST_ASSERT( mbedtls_ssl_get_user_data_p( &ep->ssl ) == NULL );
912 TEST_EQUAL( mbedtls_ssl_get_user_data_n( &ep->ssl ), 0 );
913
914 (void) mbedtls_test_rnd_std_rand( NULL,
915 (void*) &user_data_n,
916 sizeof( user_data_n ) );
917 mbedtls_ssl_conf_set_user_data_n( &ep->conf, user_data_n );
918 mbedtls_ssl_set_user_data_n( &ep->ssl, user_data_n );
919
Andrzej Kurek15daf502020-02-12 09:17:52 -0500920 if( dtls_context != NULL )
921 {
922 TEST_ASSERT( mbedtls_message_socket_setup( input_queue, output_queue,
923 100, &( ep->socket ),
924 dtls_context ) == 0 );
925 }
926 else
927 {
928 mbedtls_mock_socket_init( &( ep->socket ) );
929 }
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100930
931 ret = mbedtls_ctr_drbg_seed( &( ep->ctr_drbg ), mbedtls_entropy_func,
932 &( ep->entropy ), (const unsigned char *) ( ep->name ),
933 strlen( ep->name ) );
934 TEST_ASSERT( ret == 0 );
935
936 /* Non-blocking callbacks without timeout */
Andrzej Kurek15daf502020-02-12 09:17:52 -0500937 if( dtls_context != NULL )
938 {
939 mbedtls_ssl_set_bio( &( ep->ssl ), dtls_context,
940 mbedtls_mock_tcp_send_msg,
941 mbedtls_mock_tcp_recv_msg,
942 NULL );
943 }
944 else
945 {
946 mbedtls_ssl_set_bio( &( ep->ssl ), &( ep->socket ),
947 mbedtls_mock_tcp_send_nb,
948 mbedtls_mock_tcp_recv_nb,
949 NULL );
950 }
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100951
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100952 ret = mbedtls_ssl_config_defaults( &( ep->conf ), endpoint_type,
Andrzej Kurek15daf502020-02-12 09:17:52 -0500953 ( dtls_context != NULL ) ?
954 MBEDTLS_SSL_TRANSPORT_DATAGRAM :
955 MBEDTLS_SSL_TRANSPORT_STREAM,
956 MBEDTLS_SSL_PRESET_DEFAULT );
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100957 TEST_ASSERT( ret == 0 );
958
Andrzej Kurek1a44a152020-02-07 08:21:32 -0500959 ret = mbedtls_ssl_setup( &( ep->ssl ), &( ep->conf ) );
960 TEST_ASSERT( ret == 0 );
Andrzej Kurek15daf502020-02-12 09:17:52 -0500961
962#if defined(MBEDTLS_SSL_PROTO_DTLS) && defined(MBEDTLS_SSL_SRV_C)
963 if( endpoint_type == MBEDTLS_SSL_IS_SERVER && dtls_context != NULL )
964 mbedtls_ssl_conf_dtls_cookies( &( ep->conf ), NULL, NULL, NULL );
965#endif
966
Andrzej Kurekb2980742020-02-02 19:25:26 -0500967 ret = mbedtls_endpoint_certificate_init( ep, pk_alg );
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100968 TEST_ASSERT( ret == 0 );
969
Gilles Peskine80dae042022-01-21 23:50:39 +0100970 TEST_EQUAL( mbedtls_ssl_conf_get_user_data_n( &ep->conf ), user_data_n );
971 mbedtls_ssl_conf_set_user_data_p( &ep->conf, ep );
972 TEST_EQUAL( mbedtls_ssl_get_user_data_n( &ep->ssl ), user_data_n );
973 mbedtls_ssl_set_user_data_p( &ep->ssl, ep );
974
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100975exit:
976 return ret;
977}
978
979/*
980 * Deinitializes certificates from endpoint represented by \p ep.
981 */
982void mbedtls_endpoint_certificate_free( mbedtls_endpoint *ep )
983{
984 mbedtls_endpoint_certificate *cert = &( ep->cert );
985 mbedtls_x509_crt_free( &( cert->ca_cert ) );
986 mbedtls_x509_crt_free( &( cert->cert ) );
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100987 mbedtls_pk_free( &( cert->pkey ) );
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100988}
989
990/*
991 * Deinitializes endpoint represented by \p ep.
992 */
Andrzej Kurek15daf502020-02-12 09:17:52 -0500993void mbedtls_endpoint_free( mbedtls_endpoint *ep,
994 mbedtls_test_message_socket_context *context )
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100995{
996 mbedtls_endpoint_certificate_free( ep );
997
998 mbedtls_ssl_free( &( ep->ssl ) );
999 mbedtls_ssl_config_free( &( ep->conf ) );
1000 mbedtls_ctr_drbg_free( &( ep->ctr_drbg ) );
1001 mbedtls_entropy_free( &( ep->entropy ) );
Andrzej Kurek15daf502020-02-12 09:17:52 -05001002
1003 if( context != NULL )
1004 {
1005 mbedtls_message_socket_close( context );
1006 }
1007 else
1008 {
1009 mbedtls_mock_socket_close( &( ep->socket ) );
1010 }
Piotr Nowicki2a1f1782020-01-13 09:42:10 +01001011}
1012
1013/*
1014 * This function moves ssl handshake from \p ssl to prescribed \p state.
1015 * /p second_ssl is used as second endpoint and their sockets have to be
1016 * connected before calling this function.
1017 *
1018 * \retval 0 on success, otherwise error code.
1019 */
1020int mbedtls_move_handshake_to_state( mbedtls_ssl_context *ssl,
1021 mbedtls_ssl_context *second_ssl,
1022 int state )
1023{
1024 enum { BUFFSIZE = 1024 };
1025 int max_steps = 1000;
1026 int ret = 0;
1027
1028 if( ssl == NULL || second_ssl == NULL )
1029 {
1030 return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
1031 }
1032
1033 /* Perform communication via connected sockets */
1034 while( ( ssl->state != state ) && ( --max_steps >= 0 ) )
1035 {
1036 /* If /p second_ssl ends the handshake procedure before /p ssl then
1037 * there is no need to call the next step */
1038 if( second_ssl->state != MBEDTLS_SSL_HANDSHAKE_OVER )
1039 {
1040 ret = mbedtls_ssl_handshake_step( second_ssl );
1041 if( ret != 0 && ret != MBEDTLS_ERR_SSL_WANT_READ &&
1042 ret != MBEDTLS_ERR_SSL_WANT_WRITE )
1043 {
1044 return ret;
1045 }
1046 }
1047
1048 /* We only care about the \p ssl state and returns, so we call it last,
1049 * to leave the iteration as soon as the state is as expected. */
1050 ret = mbedtls_ssl_handshake_step( ssl );
1051 if( ret != 0 && ret != MBEDTLS_ERR_SSL_WANT_READ &&
1052 ret != MBEDTLS_ERR_SSL_WANT_WRITE )
1053 {
1054 return ret;
1055 }
1056 }
1057
1058 return ( max_steps >= 0 ) ? ret : -1;
1059}
1060
Manuel Pégourié-Gonnardd12402f2020-05-20 10:34:25 +02001061#endif /* MBEDTLS_X509_CRT_PARSE_C && MBEDTLS_ENTROPY_C && MBEDTLS_CTR_DRBG_C */
Piotr Nowicki2a1f1782020-01-13 09:42:10 +01001062
Janos Follath3766ba52019-11-27 13:31:42 +00001063/*
Piotr Nowicki438bf3b2020-03-10 12:59:10 +01001064 * Write application data. Increase write counter if necessary.
Piotr Nowickic3fca5e2020-01-30 15:33:42 +01001065 */
1066int mbedtls_ssl_write_fragment( mbedtls_ssl_context *ssl, unsigned char *buf,
Piotr Nowicki6a7f01c2020-02-12 13:53:36 +01001067 int buf_len, int *written,
Piotr Nowicki438bf3b2020-03-10 12:59:10 +01001068 const int expected_fragments )
Piotr Nowickic3fca5e2020-01-30 15:33:42 +01001069{
Piotr Nowicki6a7f01c2020-02-12 13:53:36 +01001070 int ret = mbedtls_ssl_write( ssl, buf + *written, buf_len - *written );
1071 if( ret > 0 )
Piotr Nowickic3fca5e2020-01-30 15:33:42 +01001072 {
Piotr Nowicki6a7f01c2020-02-12 13:53:36 +01001073 *written += ret;
Piotr Nowickic3fca5e2020-01-30 15:33:42 +01001074 }
Piotr Nowicki6a7f01c2020-02-12 13:53:36 +01001075
1076 if( expected_fragments == 0 )
1077 {
1078 /* Used for DTLS and the message size larger than MFL. In that case
1079 * the message can not be fragmented and the library should return
1080 * MBEDTLS_ERR_SSL_BAD_INPUT_DATA error. This error must be returned
1081 * to prevent a dead loop inside mbedtls_exchange_data(). */
1082 return ret;
1083 }
1084 else if( expected_fragments == 1 )
1085 {
1086 /* Used for TLS/DTLS and the message size lower than MFL */
1087 TEST_ASSERT( ret == buf_len ||
1088 ret == MBEDTLS_ERR_SSL_WANT_READ ||
1089 ret == MBEDTLS_ERR_SSL_WANT_WRITE );
1090 }
1091 else
1092 {
1093 /* Used for TLS and the message size larger than MFL */
1094 TEST_ASSERT( expected_fragments > 1 );
1095 TEST_ASSERT( ( ret >= 0 && ret <= buf_len ) ||
1096 ret == MBEDTLS_ERR_SSL_WANT_READ ||
1097 ret == MBEDTLS_ERR_SSL_WANT_WRITE );
1098 }
1099
1100 return 0;
1101
1102exit:
1103 /* Some of the tests failed */
1104 return -1;
Piotr Nowickic3fca5e2020-01-30 15:33:42 +01001105}
1106
1107/*
Piotr Nowicki438bf3b2020-03-10 12:59:10 +01001108 * Read application data and increase read counter and fragments counter if necessary.
Piotr Nowickic3fca5e2020-01-30 15:33:42 +01001109 */
Piotr Nowicki6a7f01c2020-02-12 13:53:36 +01001110int mbedtls_ssl_read_fragment( mbedtls_ssl_context *ssl, unsigned char *buf,
1111 int buf_len, int *read,
Piotr Nowicki438bf3b2020-03-10 12:59:10 +01001112 int *fragments, const int expected_fragments )
Piotr Nowickic3fca5e2020-01-30 15:33:42 +01001113{
Piotr Nowicki6a7f01c2020-02-12 13:53:36 +01001114 int ret = mbedtls_ssl_read( ssl, buf + *read, buf_len - *read );
1115 if( ret > 0 )
Piotr Nowickic3fca5e2020-01-30 15:33:42 +01001116 {
Piotr Nowicki438bf3b2020-03-10 12:59:10 +01001117 ( *fragments )++;
Piotr Nowickic3fca5e2020-01-30 15:33:42 +01001118 *read += ret;
1119 }
Piotr Nowicki6a7f01c2020-02-12 13:53:36 +01001120
1121 if( expected_fragments == 0 )
1122 {
1123 TEST_ASSERT( ret == 0 );
1124 }
1125 else if( expected_fragments == 1 )
1126 {
1127 TEST_ASSERT( ret == buf_len ||
1128 ret == MBEDTLS_ERR_SSL_WANT_READ ||
1129 ret == MBEDTLS_ERR_SSL_WANT_WRITE );
1130 }
1131 else
1132 {
1133 TEST_ASSERT( expected_fragments > 1 );
1134 TEST_ASSERT( ( ret >= 0 && ret <= buf_len ) ||
1135 ret == MBEDTLS_ERR_SSL_WANT_READ ||
1136 ret == MBEDTLS_ERR_SSL_WANT_WRITE );
1137 }
1138
1139 return 0;
1140
1141exit:
1142 /* Some of the tests failed */
1143 return -1;
Piotr Nowickic3fca5e2020-01-30 15:33:42 +01001144}
1145
1146/*
Hanno Beckera18d1322018-01-03 14:27:32 +00001147 * Helper function setting up inverse record transformations
1148 * using given cipher, hash, EtM mode, authentication tag length,
1149 * and version.
1150 */
1151
1152#define CHK( x ) \
1153 do \
1154 { \
1155 if( !( x ) ) \
Hanno Becker81e16a32019-03-01 11:21:44 +00001156 { \
Hanno Beckera5780f12019-04-05 09:55:37 +01001157 ret = -1; \
Hanno Becker81e16a32019-03-01 11:21:44 +00001158 goto cleanup; \
1159 } \
Hanno Beckera18d1322018-01-03 14:27:32 +00001160 } while( 0 )
1161
Andrzej Kurekf40daa32020-02-04 09:00:01 -05001162void set_ciphersuite( mbedtls_ssl_config *conf, const char *cipher,
1163 int* forced_ciphersuite )
1164{
1165 const mbedtls_ssl_ciphersuite_t *ciphersuite_info;
1166 forced_ciphersuite[0] = mbedtls_ssl_get_ciphersuite_id( cipher );
1167 forced_ciphersuite[1] = 0;
1168
1169 ciphersuite_info =
1170 mbedtls_ssl_ciphersuite_from_id( forced_ciphersuite[0] );
1171
1172 TEST_ASSERT( ciphersuite_info != NULL );
1173 TEST_ASSERT( ciphersuite_info->min_minor_ver <= conf->max_minor_ver );
1174 TEST_ASSERT( ciphersuite_info->max_minor_ver >= conf->min_minor_ver );
1175
1176 if( conf->max_minor_ver > ciphersuite_info->max_minor_ver )
1177 {
1178 conf->max_minor_ver = ciphersuite_info->max_minor_ver;
1179 }
1180 if( conf->min_minor_ver < ciphersuite_info->min_minor_ver )
1181 {
1182 conf->min_minor_ver = ciphersuite_info->min_minor_ver;
1183 }
1184
1185 mbedtls_ssl_conf_ciphersuites( conf, forced_ciphersuite );
1186
1187exit:
1188 return;
1189}
1190
Andrzej Kurekcc5169c2020-02-04 09:04:56 -05001191int psk_dummy_callback( void *p_info, mbedtls_ssl_context *ssl,
1192 const unsigned char *name, size_t name_len )
1193{
1194 (void) p_info;
1195 (void) ssl;
1196 (void) name;
1197 (void) name_len;
1198
1199 return ( 0 );
1200}
1201
Hanno Beckerd856c822019-04-29 17:30:59 +01001202#if MBEDTLS_SSL_CID_OUT_LEN_MAX > MBEDTLS_SSL_CID_IN_LEN_MAX
1203#define SSL_CID_LEN_MIN MBEDTLS_SSL_CID_IN_LEN_MAX
1204#else
1205#define SSL_CID_LEN_MIN MBEDTLS_SSL_CID_OUT_LEN_MAX
1206#endif
Hanno Beckera18d1322018-01-03 14:27:32 +00001207
Jerry Yu53d23e22022-02-09 16:25:09 +08001208#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
Przemyslaw Stekielf4facef2022-02-02 21:31:04 +01001209static int psa_cipher_encrypt_helper( mbedtls_ssl_transform *transform,
1210 const unsigned char *iv, size_t iv_len,
1211 const unsigned char *input, size_t ilen,
1212 unsigned char *output, size_t *olen )
1213{
Przemyslaw Stekiel5648d572022-02-03 14:09:02 +01001214#if defined(MBEDTLS_USE_PSA_CRYPTO)
Przemyslaw Stekield66387f2022-02-03 08:55:33 +01001215 psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
Przemyslaw Stekielf4facef2022-02-02 21:31:04 +01001216 psa_cipher_operation_t cipher_op = PSA_CIPHER_OPERATION_INIT;
1217 size_t part_len;
1218
1219 status = psa_cipher_encrypt_setup( &cipher_op,
1220 transform->psa_key_enc, transform->psa_alg );
1221
1222 if( status != PSA_SUCCESS )
1223 return( psa_ssl_status_to_mbedtls( status ) );
1224
1225 status = psa_cipher_set_iv( &cipher_op, iv, iv_len );
1226
1227 if( status != PSA_SUCCESS )
1228 return( psa_ssl_status_to_mbedtls( status ) );
1229
1230 status = psa_cipher_update( &cipher_op,
1231 input, ilen, output, ilen, olen );
1232
1233 if( status != PSA_SUCCESS )
1234 return( psa_ssl_status_to_mbedtls( status ) );
1235
1236 status = psa_cipher_finish( &cipher_op,
1237 output + *olen, ilen - *olen, &part_len );
1238
1239 if( status != PSA_SUCCESS )
1240 return( psa_ssl_status_to_mbedtls( status ) );
1241
1242 *olen += part_len;
1243 return( 0 );
Przemyslaw Stekiel5648d572022-02-03 14:09:02 +01001244#else
1245 return mbedtls_cipher_crypt( &transform->cipher_ctx_enc,
1246 iv, iv_len, input, ilen, output, olen );
Przemyslaw Stekielf4facef2022-02-02 21:31:04 +01001247#endif /* MBEDTLS_USE_PSA_CRYPTO */
Przemyslaw Stekiel5648d572022-02-03 14:09:02 +01001248}
Jerry Yu53d23e22022-02-09 16:25:09 +08001249#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
Przemyslaw Stekielf4facef2022-02-02 21:31:04 +01001250
Hanno Beckera18d1322018-01-03 14:27:32 +00001251static int build_transforms( mbedtls_ssl_transform *t_in,
1252 mbedtls_ssl_transform *t_out,
1253 int cipher_type, int hash_id,
Hanno Beckerd856c822019-04-29 17:30:59 +01001254 int etm, int tag_mode, int ver,
1255 size_t cid0_len,
1256 size_t cid1_len )
Hanno Beckera18d1322018-01-03 14:27:32 +00001257{
1258 mbedtls_cipher_info_t const *cipher_info;
Hanno Beckera5780f12019-04-05 09:55:37 +01001259 int ret = 0;
Hanno Beckera18d1322018-01-03 14:27:32 +00001260
Przemyslaw Stekiel93cf4ee2022-01-19 16:18:53 +01001261#if defined(MBEDTLS_USE_PSA_CRYPTO)
1262 psa_key_type_t key_type;
1263 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
1264 psa_algorithm_t alg;
1265 size_t key_bits;
Przemyslaw Stekield66387f2022-02-03 08:55:33 +01001266 psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
Przemyslaw Stekiel93cf4ee2022-01-19 16:18:53 +01001267#endif
1268
Hanno Beckera18d1322018-01-03 14:27:32 +00001269 size_t keylen, maclen, ivlen;
Hanno Becker81e16a32019-03-01 11:21:44 +00001270 unsigned char *key0 = NULL, *key1 = NULL;
Paul Elliott6f1eda72020-06-11 20:22:00 +01001271 unsigned char *md0 = NULL, *md1 = NULL;
Hanno Beckera18d1322018-01-03 14:27:32 +00001272 unsigned char iv_enc[16], iv_dec[16];
1273
Hanno Beckera0e20d02019-05-15 14:03:01 +01001274#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
Hanno Beckerd856c822019-04-29 17:30:59 +01001275 unsigned char cid0[ SSL_CID_LEN_MIN ];
1276 unsigned char cid1[ SSL_CID_LEN_MIN ];
1277
Ronald Cron351f0ee2020-06-10 12:12:18 +02001278 mbedtls_test_rnd_std_rand( NULL, cid0, sizeof( cid0 ) );
1279 mbedtls_test_rnd_std_rand( NULL, cid1, sizeof( cid1 ) );
Hanno Becker43c24b82019-05-01 09:45:57 +01001280#else
1281 ((void) cid0_len);
1282 ((void) cid1_len);
Hanno Beckera0e20d02019-05-15 14:03:01 +01001283#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
Hanno Beckerd856c822019-04-29 17:30:59 +01001284
Hanno Beckera18d1322018-01-03 14:27:32 +00001285 maclen = 0;
1286
1287 /* Pick cipher */
1288 cipher_info = mbedtls_cipher_info_from_type( cipher_type );
1289 CHK( cipher_info != NULL );
1290 CHK( cipher_info->iv_size <= 16 );
1291 CHK( cipher_info->key_bitlen % 8 == 0 );
1292
1293 /* Pick keys */
1294 keylen = cipher_info->key_bitlen / 8;
Hanno Becker78d1f702019-04-05 09:56:10 +01001295 /* Allocate `keylen + 1` bytes to ensure that we get
1296 * a non-NULL pointers from `mbedtls_calloc` even if
1297 * `keylen == 0` in the case of the NULL cipher. */
1298 CHK( ( key0 = mbedtls_calloc( 1, keylen + 1 ) ) != NULL );
1299 CHK( ( key1 = mbedtls_calloc( 1, keylen + 1 ) ) != NULL );
Hanno Beckera18d1322018-01-03 14:27:32 +00001300 memset( key0, 0x1, keylen );
1301 memset( key1, 0x2, keylen );
1302
Przemyslaw Stekiel93cf4ee2022-01-19 16:18:53 +01001303#if !defined(MBEDTLS_USE_PSA_CRYPTO)
Hanno Beckera18d1322018-01-03 14:27:32 +00001304 /* Setup cipher contexts */
1305 CHK( mbedtls_cipher_setup( &t_in->cipher_ctx_enc, cipher_info ) == 0 );
1306 CHK( mbedtls_cipher_setup( &t_in->cipher_ctx_dec, cipher_info ) == 0 );
1307 CHK( mbedtls_cipher_setup( &t_out->cipher_ctx_enc, cipher_info ) == 0 );
1308 CHK( mbedtls_cipher_setup( &t_out->cipher_ctx_dec, cipher_info ) == 0 );
1309
1310#if defined(MBEDTLS_CIPHER_MODE_CBC)
1311 if( cipher_info->mode == MBEDTLS_MODE_CBC )
1312 {
1313 CHK( mbedtls_cipher_set_padding_mode( &t_in->cipher_ctx_enc,
1314 MBEDTLS_PADDING_NONE ) == 0 );
1315 CHK( mbedtls_cipher_set_padding_mode( &t_in->cipher_ctx_dec,
1316 MBEDTLS_PADDING_NONE ) == 0 );
1317 CHK( mbedtls_cipher_set_padding_mode( &t_out->cipher_ctx_enc,
1318 MBEDTLS_PADDING_NONE ) == 0 );
1319 CHK( mbedtls_cipher_set_padding_mode( &t_out->cipher_ctx_dec,
1320 MBEDTLS_PADDING_NONE ) == 0 );
1321 }
1322#endif /* MBEDTLS_CIPHER_MODE_CBC */
1323
1324 CHK( mbedtls_cipher_setkey( &t_in->cipher_ctx_enc, key0,
1325 keylen << 3, MBEDTLS_ENCRYPT ) == 0 );
1326 CHK( mbedtls_cipher_setkey( &t_in->cipher_ctx_dec, key1,
1327 keylen << 3, MBEDTLS_DECRYPT ) == 0 );
1328 CHK( mbedtls_cipher_setkey( &t_out->cipher_ctx_enc, key1,
1329 keylen << 3, MBEDTLS_ENCRYPT ) == 0 );
1330 CHK( mbedtls_cipher_setkey( &t_out->cipher_ctx_dec, key0,
1331 keylen << 3, MBEDTLS_DECRYPT ) == 0 );
Przemyslaw Stekiel93cf4ee2022-01-19 16:18:53 +01001332#endif
Hanno Beckera18d1322018-01-03 14:27:32 +00001333
1334 /* Setup MAC contexts */
Hanno Beckerfd86ca82020-11-30 08:54:23 +00001335#if defined(MBEDTLS_SSL_SOME_SUITES_USE_MAC)
Hanno Beckera18d1322018-01-03 14:27:32 +00001336 if( cipher_info->mode == MBEDTLS_MODE_CBC ||
1337 cipher_info->mode == MBEDTLS_MODE_STREAM )
1338 {
1339 mbedtls_md_info_t const *md_info;
Hanno Beckera18d1322018-01-03 14:27:32 +00001340
1341 /* Pick hash */
1342 md_info = mbedtls_md_info_from_type( hash_id );
1343 CHK( md_info != NULL );
1344
1345 /* Pick hash keys */
1346 maclen = mbedtls_md_get_size( md_info );
Hanno Becker3ee54212019-04-04 16:31:26 +01001347 CHK( ( md0 = mbedtls_calloc( 1, maclen ) ) != NULL );
1348 CHK( ( md1 = mbedtls_calloc( 1, maclen ) ) != NULL );
Hanno Beckera18d1322018-01-03 14:27:32 +00001349 memset( md0, 0x5, maclen );
1350 memset( md1, 0x6, maclen );
1351
Neil Armstrongf4cc0622022-02-23 16:21:01 +01001352#if defined(MBEDTLS_USE_PSA_CRYPTO)
1353 alg = mbedtls_psa_translate_md( mbedtls_md_get_type( md_info ) );
1354
1355 CHK( alg != 0 );
1356
1357 t_out->psa_mac_alg = PSA_ALG_HMAC( alg );
1358 t_in->psa_mac_alg = PSA_ALG_HMAC( alg );
1359 t_in->psa_mac_enc = MBEDTLS_SVC_KEY_ID_INIT;
1360 t_out->psa_mac_enc = MBEDTLS_SVC_KEY_ID_INIT;
1361 t_in->psa_mac_dec = MBEDTLS_SVC_KEY_ID_INIT;
1362 t_out->psa_mac_dec = MBEDTLS_SVC_KEY_ID_INIT;
1363
1364 psa_reset_key_attributes( &attributes );
1365 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_SIGN_MESSAGE );
1366 psa_set_key_algorithm( &attributes, PSA_ALG_HMAC( alg ) );
1367 psa_set_key_type( &attributes, PSA_KEY_TYPE_HMAC );
1368
1369 CHK( psa_import_key( &attributes,
1370 md0, maclen,
1371 &t_in->psa_mac_enc ) == PSA_SUCCESS );
1372
1373 CHK( psa_import_key( &attributes,
1374 md1, maclen,
1375 &t_out->psa_mac_enc ) == PSA_SUCCESS );
1376
Neil Armstronge8589962022-02-25 15:14:29 +01001377 /* mbedtls_ct_hmac() requires the key to be exportable */
1378 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_EXPORT |
1379 PSA_KEY_USAGE_VERIFY_HASH );
Neil Armstrongf4cc0622022-02-23 16:21:01 +01001380
1381 CHK( psa_import_key( &attributes,
1382 md1, maclen,
1383 &t_in->psa_mac_dec ) == PSA_SUCCESS );
1384
1385 CHK( psa_import_key( &attributes,
1386 md0, maclen,
1387 &t_out->psa_mac_dec ) == PSA_SUCCESS );
Neil Armstrongcf8841a2022-02-24 11:17:45 +01001388#else
Hanno Beckera18d1322018-01-03 14:27:32 +00001389 CHK( mbedtls_md_setup( &t_out->md_ctx_enc, md_info, 1 ) == 0 );
1390 CHK( mbedtls_md_setup( &t_out->md_ctx_dec, md_info, 1 ) == 0 );
1391 CHK( mbedtls_md_setup( &t_in->md_ctx_enc, md_info, 1 ) == 0 );
1392 CHK( mbedtls_md_setup( &t_in->md_ctx_dec, md_info, 1 ) == 0 );
1393
Mateusz Starzyk06b07fb2021-02-18 13:55:21 +01001394 CHK( mbedtls_md_hmac_starts( &t_in->md_ctx_enc,
1395 md0, maclen ) == 0 );
1396 CHK( mbedtls_md_hmac_starts( &t_in->md_ctx_dec,
1397 md1, maclen ) == 0 );
1398 CHK( mbedtls_md_hmac_starts( &t_out->md_ctx_enc,
1399 md1, maclen ) == 0 );
1400 CHK( mbedtls_md_hmac_starts( &t_out->md_ctx_dec,
1401 md0, maclen ) == 0 );
Neil Armstrongcf8841a2022-02-24 11:17:45 +01001402#endif
Hanno Beckera18d1322018-01-03 14:27:32 +00001403 }
1404#else
1405 ((void) hash_id);
Hanno Beckerfd86ca82020-11-30 08:54:23 +00001406#endif /* MBEDTLS_SSL_SOME_SUITES_USE_MAC */
Hanno Beckera18d1322018-01-03 14:27:32 +00001407
1408
1409 /* Pick IV's (regardless of whether they
1410 * are being used by the transform). */
1411 ivlen = cipher_info->iv_size;
1412 memset( iv_enc, 0x3, sizeof( iv_enc ) );
1413 memset( iv_dec, 0x4, sizeof( iv_dec ) );
1414
1415 /*
1416 * Setup transforms
1417 */
1418
Jaeden Amero2de07f12019-06-05 13:32:08 +01001419#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC) && \
Hanno Beckerfd86ca82020-11-30 08:54:23 +00001420 defined(MBEDTLS_SSL_SOME_SUITES_USE_MAC)
Hanno Beckera18d1322018-01-03 14:27:32 +00001421 t_out->encrypt_then_mac = etm;
1422 t_in->encrypt_then_mac = etm;
1423#else
1424 ((void) etm);
1425#endif
1426
1427 t_out->minor_ver = ver;
1428 t_in->minor_ver = ver;
1429 t_out->ivlen = ivlen;
1430 t_in->ivlen = ivlen;
1431
1432 switch( cipher_info->mode )
1433 {
1434 case MBEDTLS_MODE_GCM:
1435 case MBEDTLS_MODE_CCM:
Ronald Cron6f135e12021-12-08 16:57:54 +01001436#if defined(MBEDTLS_SSL_PROTO_TLS1_3)
Hanno Beckere6832872020-05-28 08:29:58 +01001437 if( ver == MBEDTLS_SSL_MINOR_VERSION_4 )
1438 {
1439 t_out->fixed_ivlen = 12;
1440 t_in->fixed_ivlen = 12;
1441 }
1442 else
Ronald Cron6f135e12021-12-08 16:57:54 +01001443#endif /* MBEDTLS_SSL_PROTO_TLS1_3 */
Hanno Beckere6832872020-05-28 08:29:58 +01001444 {
1445 t_out->fixed_ivlen = 4;
1446 t_in->fixed_ivlen = 4;
1447 }
Hanno Beckera18d1322018-01-03 14:27:32 +00001448 t_out->maclen = 0;
1449 t_in->maclen = 0;
1450 switch( tag_mode )
1451 {
1452 case 0: /* Full tag */
1453 t_out->taglen = 16;
1454 t_in->taglen = 16;
1455 break;
1456 case 1: /* Partial tag */
1457 t_out->taglen = 8;
1458 t_in->taglen = 8;
1459 break;
1460 default:
Paul Elliottc7b53742021-02-03 13:18:33 +00001461 ret = 1;
1462 goto cleanup;
Hanno Beckera18d1322018-01-03 14:27:32 +00001463 }
1464 break;
1465
1466 case MBEDTLS_MODE_CHACHAPOLY:
1467 t_out->fixed_ivlen = 12;
1468 t_in->fixed_ivlen = 12;
1469 t_out->maclen = 0;
1470 t_in->maclen = 0;
1471 switch( tag_mode )
1472 {
1473 case 0: /* Full tag */
1474 t_out->taglen = 16;
1475 t_in->taglen = 16;
1476 break;
1477 case 1: /* Partial tag */
1478 t_out->taglen = 8;
1479 t_in->taglen = 8;
1480 break;
1481 default:
Paul Elliottc7b53742021-02-03 13:18:33 +00001482 ret = 1;
1483 goto cleanup;
Hanno Beckera18d1322018-01-03 14:27:32 +00001484 }
1485 break;
1486
1487 case MBEDTLS_MODE_STREAM:
1488 case MBEDTLS_MODE_CBC:
1489 t_out->fixed_ivlen = 0; /* redundant, must be 0 */
1490 t_in->fixed_ivlen = 0; /* redundant, must be 0 */
1491 t_out->taglen = 0;
1492 t_in->taglen = 0;
1493 switch( tag_mode )
1494 {
1495 case 0: /* Full tag */
1496 t_out->maclen = maclen;
1497 t_in->maclen = maclen;
1498 break;
Hanno Beckera18d1322018-01-03 14:27:32 +00001499 default:
Paul Elliottc7b53742021-02-03 13:18:33 +00001500 ret = 1;
1501 goto cleanup;
Hanno Beckera18d1322018-01-03 14:27:32 +00001502 }
1503 break;
1504 default:
Paul Elliottc7b53742021-02-03 13:18:33 +00001505 ret = 1;
1506 goto cleanup;
Hanno Beckera18d1322018-01-03 14:27:32 +00001507 break;
1508 }
1509
1510 /* Setup IV's */
1511
1512 memcpy( &t_in->iv_dec, iv_dec, sizeof( iv_dec ) );
1513 memcpy( &t_in->iv_enc, iv_enc, sizeof( iv_enc ) );
1514 memcpy( &t_out->iv_dec, iv_enc, sizeof( iv_enc ) );
1515 memcpy( &t_out->iv_enc, iv_dec, sizeof( iv_dec ) );
1516
Hanno Beckera0e20d02019-05-15 14:03:01 +01001517#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
Hanno Beckerd856c822019-04-29 17:30:59 +01001518 /* Add CID */
1519 memcpy( &t_in->in_cid, cid0, cid0_len );
1520 memcpy( &t_in->out_cid, cid1, cid1_len );
1521 t_in->in_cid_len = cid0_len;
1522 t_in->out_cid_len = cid1_len;
1523 memcpy( &t_out->in_cid, cid1, cid1_len );
1524 memcpy( &t_out->out_cid, cid0, cid0_len );
1525 t_out->in_cid_len = cid1_len;
1526 t_out->out_cid_len = cid0_len;
Hanno Beckera0e20d02019-05-15 14:03:01 +01001527#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
Hanno Beckerd856c822019-04-29 17:30:59 +01001528
Przemyslaw Stekiel93cf4ee2022-01-19 16:18:53 +01001529#if defined(MBEDTLS_USE_PSA_CRYPTO)
Przemyslaw Stekielf57b4562022-01-25 00:04:18 +01001530 status = mbedtls_ssl_cipher_to_psa( cipher_type,
Przemyslaw Stekiel93cf4ee2022-01-19 16:18:53 +01001531 t_in->taglen,
1532 &alg,
1533 &key_type,
1534 &key_bits );
1535
Przemyslaw Stekiel8c010eb2022-02-03 10:44:02 +01001536 if ( status != PSA_SUCCESS )
Przemyslaw Stekiel93cf4ee2022-01-19 16:18:53 +01001537 {
Przemyslaw Stekiel77aec8d2022-01-31 20:22:53 +01001538 ret = psa_ssl_status_to_mbedtls( status );
Przemyslaw Stekiel93cf4ee2022-01-19 16:18:53 +01001539 goto cleanup;
1540 }
1541
1542 t_in->psa_alg = alg;
1543 t_out->psa_alg = alg;
1544
1545 if ( alg != MBEDTLS_SSL_NULL_CIPHER )
1546 {
Neil Armstrongf4cc0622022-02-23 16:21:01 +01001547 psa_reset_key_attributes( &attributes );
Przemyslaw Stekielf4ca3f02022-01-25 00:25:59 +01001548 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT );
Przemyslaw Stekiel93cf4ee2022-01-19 16:18:53 +01001549 psa_set_key_algorithm( &attributes, alg );
1550 psa_set_key_type( &attributes, key_type );
1551
1552 status = psa_import_key( &attributes,
1553 key0,
1554 PSA_BITS_TO_BYTES( key_bits ),
1555 &t_in->psa_key_enc );
1556
Przemyslaw Stekiel8c010eb2022-02-03 10:44:02 +01001557 if ( status != PSA_SUCCESS )
Przemyslaw Stekiel93cf4ee2022-01-19 16:18:53 +01001558 {
Przemyslaw Stekiel77aec8d2022-01-31 20:22:53 +01001559 ret = psa_ssl_status_to_mbedtls( status );
Przemyslaw Stekiel93cf4ee2022-01-19 16:18:53 +01001560 goto cleanup;
1561 }
1562
1563 status = psa_import_key( &attributes,
1564 key1,
1565 PSA_BITS_TO_BYTES( key_bits ),
Przemyslaw Stekielf4ca3f02022-01-25 00:25:59 +01001566 &t_out->psa_key_enc );
Przemyslaw Stekiel93cf4ee2022-01-19 16:18:53 +01001567
Przemyslaw Stekiel8c010eb2022-02-03 10:44:02 +01001568 if ( status != PSA_SUCCESS )
Przemyslaw Stekiel93cf4ee2022-01-19 16:18:53 +01001569 {
Przemyslaw Stekiel77aec8d2022-01-31 20:22:53 +01001570 ret = psa_ssl_status_to_mbedtls( status );
Przemyslaw Stekiel93cf4ee2022-01-19 16:18:53 +01001571 goto cleanup;
1572 }
1573
Przemyslaw Stekielf4ca3f02022-01-25 00:25:59 +01001574 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DECRYPT );
1575
Przemyslaw Stekiel93cf4ee2022-01-19 16:18:53 +01001576 status = psa_import_key( &attributes,
1577 key1,
1578 PSA_BITS_TO_BYTES( key_bits ),
Przemyslaw Stekielf4ca3f02022-01-25 00:25:59 +01001579 &t_in->psa_key_dec );
Przemyslaw Stekiel93cf4ee2022-01-19 16:18:53 +01001580
Przemyslaw Stekiel8c010eb2022-02-03 10:44:02 +01001581 if ( status != PSA_SUCCESS )
Przemyslaw Stekiel93cf4ee2022-01-19 16:18:53 +01001582 {
Przemyslaw Stekiel77aec8d2022-01-31 20:22:53 +01001583 ret = psa_ssl_status_to_mbedtls( status );
Przemyslaw Stekiel93cf4ee2022-01-19 16:18:53 +01001584 goto cleanup;
1585 }
1586
1587 status = psa_import_key( &attributes,
1588 key0,
1589 PSA_BITS_TO_BYTES( key_bits ),
1590 &t_out->psa_key_dec );
1591
Przemyslaw Stekiel8c010eb2022-02-03 10:44:02 +01001592 if ( status != PSA_SUCCESS )
Przemyslaw Stekiel93cf4ee2022-01-19 16:18:53 +01001593 {
Przemyslaw Stekiel77aec8d2022-01-31 20:22:53 +01001594 ret = psa_ssl_status_to_mbedtls( status );
Przemyslaw Stekiel93cf4ee2022-01-19 16:18:53 +01001595 goto cleanup;
1596 }
1597 }
1598#endif /* MBEDTLS_USE_PSA_CRYPTO */
1599
Hanno Becker81e16a32019-03-01 11:21:44 +00001600cleanup:
1601
Hanno Becker3ee54212019-04-04 16:31:26 +01001602 mbedtls_free( key0 );
1603 mbedtls_free( key1 );
Hanno Becker81e16a32019-03-01 11:21:44 +00001604
Paul Elliott6f1eda72020-06-11 20:22:00 +01001605 mbedtls_free( md0 );
1606 mbedtls_free( md1 );
1607
Hanno Beckera5780f12019-04-05 09:55:37 +01001608 return( ret );
Hanno Beckera18d1322018-01-03 14:27:32 +00001609}
1610
Manuel Pégourié-Gonnard3caa6ca2019-05-23 10:06:14 +02001611/*
Manuel Pégourié-Gonnard686adb42019-06-03 09:55:16 +02001612 * Populate a session structure for serialization tests.
Manuel Pégourié-Gonnard3caa6ca2019-05-23 10:06:14 +02001613 * Choose dummy values, mostly non-0 to distinguish from the init default.
1614 */
Hanno Beckerfadbdbb2021-07-23 06:25:48 +01001615static int ssl_populate_session_tls12( mbedtls_ssl_session *session,
1616 int ticket_len,
1617 const char *crt_file )
Manuel Pégourié-Gonnard3caa6ca2019-05-23 10:06:14 +02001618{
1619#if defined(MBEDTLS_HAVE_TIME)
1620 session->start = mbedtls_time( NULL ) - 42;
1621#endif
Hanno Beckerfadbdbb2021-07-23 06:25:48 +01001622 session->minor_ver = MBEDTLS_SSL_MINOR_VERSION_3;
Manuel Pégourié-Gonnard3caa6ca2019-05-23 10:06:14 +02001623 session->ciphersuite = 0xabcd;
1624 session->compression = 1;
1625 session->id_len = sizeof( session->id );
1626 memset( session->id, 66, session->id_len );
Manuel Pégourié-Gonnard220403b2019-05-24 09:54:21 +02001627 memset( session->master, 17, sizeof( session->master ) );
Manuel Pégourié-Gonnard3caa6ca2019-05-23 10:06:14 +02001628
Manuel Pégourié-Gonnard1f6033a2019-05-24 10:17:52 +02001629#if defined(MBEDTLS_X509_CRT_PARSE_C) && defined(MBEDTLS_FS_IO)
Hanno Beckerfadbdbb2021-07-23 06:25:48 +01001630 if( crt_file != NULL && strlen( crt_file ) != 0 )
Manuel Pégourié-Gonnard3caa6ca2019-05-23 10:06:14 +02001631 {
Manuel Pégourié-Gonnardee13a732019-07-29 13:00:39 +02001632 mbedtls_x509_crt tmp_crt;
Manuel Pégourié-Gonnard3caa6ca2019-05-23 10:06:14 +02001633 int ret;
Manuel Pégourié-Gonnard6b840702019-05-24 09:40:17 +02001634
Manuel Pégourié-Gonnardee13a732019-07-29 13:00:39 +02001635 mbedtls_x509_crt_init( &tmp_crt );
1636 ret = mbedtls_x509_crt_parse_file( &tmp_crt, crt_file );
1637 if( ret != 0 )
1638 return( ret );
1639
1640#if defined(MBEDTLS_SSL_KEEP_PEER_CERTIFICATE)
1641 /* Move temporary CRT. */
Manuel Pégourié-Gonnard6b840702019-05-24 09:40:17 +02001642 session->peer_cert = mbedtls_calloc( 1, sizeof( *session->peer_cert ) );
1643 if( session->peer_cert == NULL )
1644 return( -1 );
Manuel Pégourié-Gonnardee13a732019-07-29 13:00:39 +02001645 *session->peer_cert = tmp_crt;
1646 memset( &tmp_crt, 0, sizeof( tmp_crt ) );
1647#else /* MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
1648 /* Calculate digest of temporary CRT. */
1649 session->peer_cert_digest =
1650 mbedtls_calloc( 1, MBEDTLS_SSL_PEER_CERT_DIGEST_DFL_LEN );
1651 if( session->peer_cert_digest == NULL )
1652 return( -1 );
1653 ret = mbedtls_md( mbedtls_md_info_from_type(
1654 MBEDTLS_SSL_PEER_CERT_DIGEST_DFL_TYPE ),
1655 tmp_crt.raw.p, tmp_crt.raw.len,
1656 session->peer_cert_digest );
Manuel Pégourié-Gonnard3caa6ca2019-05-23 10:06:14 +02001657 if( ret != 0 )
1658 return( ret );
Manuel Pégourié-Gonnardee13a732019-07-29 13:00:39 +02001659 session->peer_cert_digest_type =
1660 MBEDTLS_SSL_PEER_CERT_DIGEST_DFL_TYPE;
1661 session->peer_cert_digest_len =
1662 MBEDTLS_SSL_PEER_CERT_DIGEST_DFL_LEN;
1663#endif /* MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
1664
1665 mbedtls_x509_crt_free( &tmp_crt );
Manuel Pégourié-Gonnard3caa6ca2019-05-23 10:06:14 +02001666 }
Manuel Pégourié-Gonnardee13a732019-07-29 13:00:39 +02001667#else /* MBEDTLS_X509_CRT_PARSE_C && MBEDTLS_FS_IO */
Manuel Pégourié-Gonnard3caa6ca2019-05-23 10:06:14 +02001668 (void) crt_file;
Manuel Pégourié-Gonnardee13a732019-07-29 13:00:39 +02001669#endif /* MBEDTLS_X509_CRT_PARSE_C && MBEDTLS_FS_IO */
Manuel Pégourié-Gonnard3caa6ca2019-05-23 10:06:14 +02001670 session->verify_result = 0xdeadbeef;
1671
1672#if defined(MBEDTLS_SSL_SESSION_TICKETS) && defined(MBEDTLS_SSL_CLI_C)
1673 if( ticket_len != 0 )
1674 {
1675 session->ticket = mbedtls_calloc( 1, ticket_len );
Manuel Pégourié-Gonnard220403b2019-05-24 09:54:21 +02001676 if( session->ticket == NULL )
Manuel Pégourié-Gonnard3caa6ca2019-05-23 10:06:14 +02001677 return( -1 );
1678 memset( session->ticket, 33, ticket_len );
1679 }
1680 session->ticket_len = ticket_len;
1681 session->ticket_lifetime = 86401;
1682#else
1683 (void) ticket_len;
1684#endif
1685
1686#if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
1687 session->mfl_code = 1;
1688#endif
Manuel Pégourié-Gonnard3caa6ca2019-05-23 10:06:14 +02001689#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
1690 session->encrypt_then_mac = 1;
1691#endif
1692
1693 return( 0 );
1694}
1695
Piotr Nowicki6a7f01c2020-02-12 13:53:36 +01001696/*
1697 * Perform data exchanging between \p ssl_1 and \p ssl_2 and check if the
1698 * message was sent in the correct number of fragments.
1699 *
1700 * /p ssl_1 and /p ssl_2 Endpoints represented by mbedtls_ssl_context. Both
1701 * of them must be initialized and connected beforehand.
1702 * /p msg_len_1 and /p msg_len_2 specify the size of the message to send.
1703 * /p expected_fragments_1 and /p expected_fragments_2 determine in how many
1704 * fragments the message should be sent.
1705 * expected_fragments is 0: can be used for DTLS testing while the message
1706 * size is larger than MFL. In that case the message
1707 * cannot be fragmented and sent to the second endpoint.
1708 * This value can be used for negative tests.
1709 * expected_fragments is 1: can be used for TLS/DTLS testing while the
1710 * message size is below MFL
1711 * expected_fragments > 1: can be used for TLS testing while the message
1712 * size is larger than MFL
1713 *
1714 * \retval 0 on success, otherwise error code.
1715 */
1716int mbedtls_exchange_data( mbedtls_ssl_context *ssl_1,
1717 int msg_len_1, const int expected_fragments_1,
1718 mbedtls_ssl_context *ssl_2,
1719 int msg_len_2, const int expected_fragments_2 )
1720{
1721 unsigned char *msg_buf_1 = malloc( msg_len_1 );
1722 unsigned char *msg_buf_2 = malloc( msg_len_2 );
1723 unsigned char *in_buf_1 = malloc( msg_len_2 );
1724 unsigned char *in_buf_2 = malloc( msg_len_1 );
1725 int msg_type, ret = -1;
1726
1727 /* Perform this test with two message types. At first use a message
1728 * consisting of only 0x00 for the client and only 0xFF for the server.
1729 * At the second time use message with generated data */
1730 for( msg_type = 0; msg_type < 2; msg_type++ )
1731 {
1732 int written_1 = 0;
1733 int written_2 = 0;
1734 int read_1 = 0;
1735 int read_2 = 0;
1736 int fragments_1 = 0;
1737 int fragments_2 = 0;
1738
1739 if( msg_type == 0 )
1740 {
1741 memset( msg_buf_1, 0x00, msg_len_1 );
1742 memset( msg_buf_2, 0xff, msg_len_2 );
1743 }
1744 else
1745 {
1746 int i, j = 0;
1747 for( i = 0; i < msg_len_1; i++ )
1748 {
1749 msg_buf_1[i] = j++ & 0xFF;
1750 }
1751 for( i = 0; i < msg_len_2; i++ )
1752 {
1753 msg_buf_2[i] = ( j -= 5 ) & 0xFF;
1754 }
1755 }
1756
1757 while( read_1 < msg_len_2 || read_2 < msg_len_1 )
1758 {
1759 /* ssl_1 sending */
1760 if( msg_len_1 > written_1 )
1761 {
1762 ret = mbedtls_ssl_write_fragment( ssl_1, msg_buf_1,
1763 msg_len_1, &written_1,
Piotr Nowicki6a7f01c2020-02-12 13:53:36 +01001764 expected_fragments_1 );
1765 if( expected_fragments_1 == 0 )
1766 {
1767 /* This error is expected when the message is too large and
1768 * cannot be fragmented */
1769 TEST_ASSERT( ret == MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
1770 msg_len_1 = 0;
1771 }
1772 else
1773 {
1774 TEST_ASSERT( ret == 0 );
1775 }
1776 }
1777
1778 /* ssl_2 sending */
1779 if( msg_len_2 > written_2 )
1780 {
1781 ret = mbedtls_ssl_write_fragment( ssl_2, msg_buf_2,
1782 msg_len_2, &written_2,
Piotr Nowicki6a7f01c2020-02-12 13:53:36 +01001783 expected_fragments_2 );
1784 if( expected_fragments_2 == 0 )
1785 {
1786 /* This error is expected when the message is too large and
1787 * cannot be fragmented */
1788 TEST_ASSERT( ret == MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
1789 msg_len_2 = 0;
1790 }
1791 else
1792 {
1793 TEST_ASSERT( ret == 0 );
1794 }
1795 }
1796
1797 /* ssl_1 reading */
1798 if( read_1 < msg_len_2 )
1799 {
1800 ret = mbedtls_ssl_read_fragment( ssl_1, in_buf_1,
1801 msg_len_2, &read_1,
Piotr Nowicki438bf3b2020-03-10 12:59:10 +01001802 &fragments_2,
1803 expected_fragments_2 );
Piotr Nowicki6a7f01c2020-02-12 13:53:36 +01001804 TEST_ASSERT( ret == 0 );
1805 }
1806
1807 /* ssl_2 reading */
1808 if( read_2 < msg_len_1 )
1809 {
1810 ret = mbedtls_ssl_read_fragment( ssl_2, in_buf_2,
1811 msg_len_1, &read_2,
Piotr Nowicki438bf3b2020-03-10 12:59:10 +01001812 &fragments_1,
1813 expected_fragments_1 );
Piotr Nowicki6a7f01c2020-02-12 13:53:36 +01001814 TEST_ASSERT( ret == 0 );
1815 }
1816 }
1817
1818 ret = -1;
1819 TEST_ASSERT( 0 == memcmp( msg_buf_1, in_buf_2, msg_len_1 ) );
1820 TEST_ASSERT( 0 == memcmp( msg_buf_2, in_buf_1, msg_len_2 ) );
1821 TEST_ASSERT( fragments_1 == expected_fragments_1 );
1822 TEST_ASSERT( fragments_2 == expected_fragments_2 );
1823 }
1824
1825 ret = 0;
1826
1827exit:
1828 free( msg_buf_1 );
1829 free( in_buf_1 );
1830 free( msg_buf_2 );
1831 free( in_buf_2 );
1832
1833 return ret;
1834}
1835
Piotr Nowicki95e9eb82020-02-14 11:33:34 +01001836/*
1837 * Perform data exchanging between \p ssl_1 and \p ssl_2. Both of endpoints
1838 * must be initialized and connected beforehand.
1839 *
1840 * \retval 0 on success, otherwise error code.
1841 */
1842int exchange_data( mbedtls_ssl_context *ssl_1,
1843 mbedtls_ssl_context *ssl_2 )
1844{
1845 return mbedtls_exchange_data( ssl_1, 256, 1,
1846 ssl_2, 256, 1 );
1847}
1848
Gilles Peskine1255b0d2022-01-13 01:08:48 +01001849int check_ssl_version( int expected_negotiated_version,
1850 const mbedtls_ssl_context *ssl )
1851{
1852 const char *version_string = mbedtls_ssl_get_version( ssl );
1853 mbedtls_ssl_protocol_version version_number =
1854 mbedtls_ssl_get_version_number( ssl );
1855
1856 TEST_EQUAL( ssl->major_ver, MBEDTLS_SSL_MAJOR_VERSION_3 );
1857 TEST_EQUAL( ssl->minor_ver, expected_negotiated_version );
1858
1859 if( ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
1860 {
1861 TEST_EQUAL( version_string[0], 'D' );
1862 ++version_string;
1863 }
1864
1865 switch( expected_negotiated_version )
1866 {
1867 case MBEDTLS_SSL_MINOR_VERSION_3:
1868 TEST_EQUAL( version_number, MBEDTLS_SSL_VERSION_1_2 );
1869 TEST_ASSERT( strcmp( version_string, "TLSv1.2" ) == 0 );
1870 break;
1871
1872 case MBEDTLS_SSL_MINOR_VERSION_4:
1873 TEST_EQUAL( version_number, MBEDTLS_SSL_VERSION_1_3 );
1874 TEST_ASSERT( strcmp( version_string, "TLSv1.3" ) == 0 );
1875 break;
1876
1877 default:
1878 TEST_ASSERT( ! "Version check not implemented for this protocol version" );
1879 }
1880
1881 return( 1 );
1882
1883exit:
1884 return( 0 );
1885}
1886
1887
Manuel Pégourié-Gonnardd12402f2020-05-20 10:34:25 +02001888#if defined(MBEDTLS_X509_CRT_PARSE_C) && \
1889 defined(MBEDTLS_ENTROPY_C) && \
1890 defined(MBEDTLS_CTR_DRBG_C)
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001891void perform_handshake( handshake_test_options* options )
1892{
1893 /* forced_ciphersuite needs to last until the end of the handshake */
1894 int forced_ciphersuite[2];
1895 enum { BUFFSIZE = 17000 };
1896 mbedtls_endpoint client, server;
Gilles Peskineeccd8882020-03-10 12:19:08 +01001897#if defined(MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED)
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001898 const char *psk_identity = "foo";
1899#endif
1900#if defined(MBEDTLS_TIMING_C)
1901 mbedtls_timing_delay_context timer_client, timer_server;
1902#endif
1903#if defined(MBEDTLS_SSL_CONTEXT_SERIALIZATION)
1904 unsigned char *context_buf = NULL;
1905 size_t context_buf_len;
1906#endif
1907#if defined(MBEDTLS_SSL_RENEGOTIATION)
1908 int ret = -1;
1909#endif
Paul Elliottc8570442020-04-15 17:00:50 +01001910 int expected_handshake_result = 0;
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001911
Neil Armstrong46a17602022-02-23 15:11:16 +01001912 USE_PSA_INIT( );
1913
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001914 mbedtls_test_message_queue server_queue, client_queue;
1915 mbedtls_test_message_socket_context server_context, client_context;
Andrzej Kurek45916ba2020-03-05 14:46:22 -05001916 mbedtls_message_socket_init( &server_context );
1917 mbedtls_message_socket_init( &client_context );
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001918
1919 /* Client side */
1920 if( options->dtls != 0 )
1921 {
1922 TEST_ASSERT( mbedtls_endpoint_init( &client, MBEDTLS_SSL_IS_CLIENT,
1923 options->pk_alg, &client_context,
1924 &client_queue,
1925 &server_queue ) == 0 );
1926#if defined(MBEDTLS_TIMING_C)
1927 mbedtls_ssl_set_timer_cb( &client.ssl, &timer_client,
1928 mbedtls_timing_set_delay,
1929 mbedtls_timing_get_delay );
1930#endif
1931 }
1932 else
1933 {
1934 TEST_ASSERT( mbedtls_endpoint_init( &client, MBEDTLS_SSL_IS_CLIENT,
1935 options->pk_alg, NULL, NULL,
1936 NULL ) == 0 );
1937 }
Paul Elliottc8570442020-04-15 17:00:50 +01001938
1939 if( options->client_min_version != TEST_SSL_MINOR_VERSION_NONE )
1940 {
1941 mbedtls_ssl_conf_min_version( &client.conf, MBEDTLS_SSL_MAJOR_VERSION_3,
1942 options->client_min_version );
1943 }
1944
1945 if( options->client_max_version != TEST_SSL_MINOR_VERSION_NONE )
1946 {
1947 mbedtls_ssl_conf_max_version( &client.conf, MBEDTLS_SSL_MAJOR_VERSION_3,
1948 options->client_max_version );
1949 }
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001950
1951 if( strlen( options->cipher ) > 0 )
1952 {
1953 set_ciphersuite( &client.conf, options->cipher, forced_ciphersuite );
1954 }
Piotr Nowickibde7ee82020-02-21 10:59:50 +01001955
1956#if defined (MBEDTLS_DEBUG_C)
1957 if( options->cli_log_fun )
1958 {
1959 mbedtls_debug_set_threshold( 4 );
1960 mbedtls_ssl_conf_dbg( &client.conf, options->cli_log_fun,
1961 options->cli_log_obj );
1962 }
1963#endif
1964
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001965 /* Server side */
1966 if( options->dtls != 0 )
1967 {
1968 TEST_ASSERT( mbedtls_endpoint_init( &server, MBEDTLS_SSL_IS_SERVER,
1969 options->pk_alg, &server_context,
1970 &server_queue,
1971 &client_queue) == 0 );
1972#if defined(MBEDTLS_TIMING_C)
1973 mbedtls_ssl_set_timer_cb( &server.ssl, &timer_server,
1974 mbedtls_timing_set_delay,
1975 mbedtls_timing_get_delay );
1976#endif
1977 }
1978 else
1979 {
1980 TEST_ASSERT( mbedtls_endpoint_init( &server, MBEDTLS_SSL_IS_SERVER,
1981 options->pk_alg, NULL, NULL, NULL ) == 0 );
1982 }
Piotr Nowickibde7ee82020-02-21 10:59:50 +01001983
1984 mbedtls_ssl_conf_authmode( &server.conf, options->srv_auth_mode );
1985
Paul Elliottc8570442020-04-15 17:00:50 +01001986 if( options->server_min_version != TEST_SSL_MINOR_VERSION_NONE )
1987 {
1988 mbedtls_ssl_conf_min_version( &server.conf, MBEDTLS_SSL_MAJOR_VERSION_3,
1989 options->server_min_version );
1990 }
1991
1992 if( options->server_max_version != TEST_SSL_MINOR_VERSION_NONE )
1993 {
1994 mbedtls_ssl_conf_max_version( &server.conf, MBEDTLS_SSL_MAJOR_VERSION_3,
1995 options->server_max_version );
1996 }
1997
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001998#if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
1999 TEST_ASSERT( mbedtls_ssl_conf_max_frag_len( &(server.conf),
2000 (unsigned char) options->mfl ) == 0 );
2001 TEST_ASSERT( mbedtls_ssl_conf_max_frag_len( &(client.conf),
2002 (unsigned char) options->mfl ) == 0 );
2003#else
2004 TEST_ASSERT( MBEDTLS_SSL_MAX_FRAG_LEN_NONE == options->mfl );
2005#endif /* MBEDTLS_SSL_MAX_FRAGMENT_LENGTH */
2006
Gilles Peskineeccd8882020-03-10 12:19:08 +01002007#if defined(MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED)
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05002008 if( options->psk_str != NULL && options->psk_str->len > 0 )
2009 {
2010 TEST_ASSERT( mbedtls_ssl_conf_psk( &client.conf, options->psk_str->x,
2011 options->psk_str->len,
2012 (const unsigned char *) psk_identity,
2013 strlen( psk_identity ) ) == 0 );
2014
2015 TEST_ASSERT( mbedtls_ssl_conf_psk( &server.conf, options->psk_str->x,
2016 options->psk_str->len,
2017 (const unsigned char *) psk_identity,
2018 strlen( psk_identity ) ) == 0 );
2019
2020 mbedtls_ssl_conf_psk_cb( &server.conf, psk_dummy_callback, NULL );
2021 }
2022#endif
2023#if defined(MBEDTLS_SSL_RENEGOTIATION)
2024 if( options->renegotiate )
2025 {
2026 mbedtls_ssl_conf_renegotiation( &(server.conf),
2027 MBEDTLS_SSL_RENEGOTIATION_ENABLED );
2028 mbedtls_ssl_conf_renegotiation( &(client.conf),
2029 MBEDTLS_SSL_RENEGOTIATION_ENABLED );
2030
2031 mbedtls_ssl_conf_legacy_renegotiation( &(server.conf),
2032 options->legacy_renegotiation );
2033 mbedtls_ssl_conf_legacy_renegotiation( &(client.conf),
2034 options->legacy_renegotiation );
2035 }
2036#endif /* MBEDTLS_SSL_RENEGOTIATION */
2037
Piotr Nowickibde7ee82020-02-21 10:59:50 +01002038#if defined (MBEDTLS_DEBUG_C)
2039 if( options->srv_log_fun )
2040 {
2041 mbedtls_debug_set_threshold( 4 );
2042 mbedtls_ssl_conf_dbg( &server.conf, options->srv_log_fun,
2043 options->srv_log_obj );
2044 }
2045#endif
2046
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05002047 TEST_ASSERT( mbedtls_mock_socket_connect( &(client.socket),
2048 &(server.socket),
2049 BUFFSIZE ) == 0 );
2050
Andrzej Kurek0afa2a12020-03-03 10:39:58 -05002051#if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
2052 if( options->resize_buffers != 0 )
2053 {
2054 /* Ensure that the buffer sizes are appropriate before resizes */
2055 TEST_ASSERT( client.ssl.out_buf_len == MBEDTLS_SSL_OUT_BUFFER_LEN );
2056 TEST_ASSERT( client.ssl.in_buf_len == MBEDTLS_SSL_IN_BUFFER_LEN );
2057 TEST_ASSERT( server.ssl.out_buf_len == MBEDTLS_SSL_OUT_BUFFER_LEN );
2058 TEST_ASSERT( server.ssl.in_buf_len == MBEDTLS_SSL_IN_BUFFER_LEN );
2059 }
2060#endif
2061
Paul Elliottc8570442020-04-15 17:00:50 +01002062 if( options->expected_negotiated_version == TEST_SSL_MINOR_VERSION_NONE )
2063 {
Hanno Beckerbc000442021-06-24 09:18:19 +01002064 expected_handshake_result = MBEDTLS_ERR_SSL_BAD_PROTOCOL_VERSION;
Paul Elliottc8570442020-04-15 17:00:50 +01002065 }
2066
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05002067 TEST_ASSERT( mbedtls_move_handshake_to_state( &(client.ssl),
2068 &(server.ssl),
2069 MBEDTLS_SSL_HANDSHAKE_OVER )
Paul Elliottc8570442020-04-15 17:00:50 +01002070 == expected_handshake_result );
2071
2072 if( expected_handshake_result != 0 )
2073 {
2074 /* Connection will have failed by this point, skip to cleanup */
2075 goto exit;
2076 }
2077
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05002078 TEST_ASSERT( client.ssl.state == MBEDTLS_SSL_HANDSHAKE_OVER );
2079 TEST_ASSERT( server.ssl.state == MBEDTLS_SSL_HANDSHAKE_OVER );
2080
Gilles Peskine1255b0d2022-01-13 01:08:48 +01002081 /* Check that both sides have negotiated the expected version. */
2082 mbedtls_test_set_step( 0 );
2083 if( ! check_ssl_version( options->expected_negotiated_version,
2084 &client.ssl ) )
2085 goto exit;
Paul Elliottc8570442020-04-15 17:00:50 +01002086
Gilles Peskine1255b0d2022-01-13 01:08:48 +01002087 mbedtls_test_set_step( 1 );
2088 if( ! check_ssl_version( options->expected_negotiated_version,
2089 &server.ssl ) )
2090 goto exit;
Paul Elliottc8570442020-04-15 17:00:50 +01002091
Andrzej Kurek0afa2a12020-03-03 10:39:58 -05002092#if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
2093 if( options->resize_buffers != 0 )
2094 {
TRodziewicz2abf03c2021-06-25 14:40:09 +02002095 /* A server, when using DTLS, might delay a buffer resize to happen
2096 * after it receives a message, so we force it. */
2097 TEST_ASSERT( exchange_data( &(client.ssl), &(server.ssl) ) == 0 );
Andrzej Kurek0afa2a12020-03-03 10:39:58 -05002098
TRodziewicz2abf03c2021-06-25 14:40:09 +02002099 TEST_ASSERT( client.ssl.out_buf_len ==
2100 mbedtls_ssl_get_output_buflen( &client.ssl ) );
2101 TEST_ASSERT( client.ssl.in_buf_len ==
2102 mbedtls_ssl_get_input_buflen( &client.ssl ) );
2103 TEST_ASSERT( server.ssl.out_buf_len ==
2104 mbedtls_ssl_get_output_buflen( &server.ssl ) );
2105 TEST_ASSERT( server.ssl.in_buf_len ==
2106 mbedtls_ssl_get_input_buflen( &server.ssl ) );
Andrzej Kurek0afa2a12020-03-03 10:39:58 -05002107 }
2108#endif
2109
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05002110 if( options->cli_msg_len != 0 || options->srv_msg_len != 0 )
2111 {
2112 /* Start data exchanging test */
2113 TEST_ASSERT( mbedtls_exchange_data( &(client.ssl), options->cli_msg_len,
2114 options->expected_cli_fragments,
2115 &(server.ssl), options->srv_msg_len,
2116 options->expected_srv_fragments )
2117 == 0 );
2118 }
2119#if defined(MBEDTLS_SSL_CONTEXT_SERIALIZATION)
2120 if( options->serialize == 1 )
2121 {
2122 TEST_ASSERT( options->dtls == 1 );
2123
2124 TEST_ASSERT( mbedtls_ssl_context_save( &(server.ssl), NULL,
2125 0, &context_buf_len )
2126 == MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL );
2127
2128 context_buf = mbedtls_calloc( 1, context_buf_len );
2129 TEST_ASSERT( context_buf != NULL );
2130
2131 TEST_ASSERT( mbedtls_ssl_context_save( &(server.ssl), context_buf,
2132 context_buf_len,
2133 &context_buf_len ) == 0 );
2134
2135 mbedtls_ssl_free( &(server.ssl) );
2136 mbedtls_ssl_init( &(server.ssl) );
2137
2138 TEST_ASSERT( mbedtls_ssl_setup( &(server.ssl), &(server.conf) ) == 0 );
2139
2140 mbedtls_ssl_set_bio( &( server.ssl ), &server_context,
2141 mbedtls_mock_tcp_send_msg,
2142 mbedtls_mock_tcp_recv_msg,
2143 NULL );
2144
Gilles Peskine49d7ddf2022-01-27 23:25:51 +01002145 mbedtls_ssl_set_user_data_p( &server.ssl, &server );
2146
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05002147#if defined(MBEDTLS_TIMING_C)
2148 mbedtls_ssl_set_timer_cb( &server.ssl, &timer_server,
2149 mbedtls_timing_set_delay,
2150 mbedtls_timing_get_delay );
2151#endif
Andrzej Kurek0afa2a12020-03-03 10:39:58 -05002152#if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
2153 if( options->resize_buffers != 0 )
2154 {
2155 /* Ensure that the buffer sizes are appropriate before resizes */
2156 TEST_ASSERT( server.ssl.out_buf_len == MBEDTLS_SSL_OUT_BUFFER_LEN );
2157 TEST_ASSERT( server.ssl.in_buf_len == MBEDTLS_SSL_IN_BUFFER_LEN );
2158 }
2159#endif
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05002160 TEST_ASSERT( mbedtls_ssl_context_load( &( server.ssl ), context_buf,
2161 context_buf_len ) == 0 );
2162
Andrzej Kurek0afa2a12020-03-03 10:39:58 -05002163#if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
2164 /* Validate buffer sizes after context deserialization */
2165 if( options->resize_buffers != 0 )
2166 {
2167 TEST_ASSERT( server.ssl.out_buf_len ==
2168 mbedtls_ssl_get_output_buflen( &server.ssl ) );
2169 TEST_ASSERT( server.ssl.in_buf_len ==
2170 mbedtls_ssl_get_input_buflen( &server.ssl ) );
2171 }
2172#endif
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05002173 /* Retest writing/reading */
2174 if( options->cli_msg_len != 0 || options->srv_msg_len != 0 )
2175 {
2176 TEST_ASSERT( mbedtls_exchange_data( &(client.ssl),
2177 options->cli_msg_len,
2178 options->expected_cli_fragments,
2179 &(server.ssl),
2180 options->srv_msg_len,
2181 options->expected_srv_fragments )
2182 == 0 );
2183 }
2184 }
2185#endif /* MBEDTLS_SSL_CONTEXT_SERIALIZATION */
Andrzej Kurek0afa2a12020-03-03 10:39:58 -05002186
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05002187#if defined(MBEDTLS_SSL_RENEGOTIATION)
2188 if( options->renegotiate )
2189 {
2190 /* Start test with renegotiation */
2191 TEST_ASSERT( server.ssl.renego_status ==
2192 MBEDTLS_SSL_INITIAL_HANDSHAKE );
2193 TEST_ASSERT( client.ssl.renego_status ==
2194 MBEDTLS_SSL_INITIAL_HANDSHAKE );
2195
2196 /* After calling this function for the server, it only sends a handshake
2197 * request. All renegotiation should happen during data exchanging */
2198 TEST_ASSERT( mbedtls_ssl_renegotiate( &(server.ssl) ) == 0 );
2199 TEST_ASSERT( server.ssl.renego_status ==
2200 MBEDTLS_SSL_RENEGOTIATION_PENDING );
2201 TEST_ASSERT( client.ssl.renego_status ==
2202 MBEDTLS_SSL_INITIAL_HANDSHAKE );
2203
2204 TEST_ASSERT( exchange_data( &(client.ssl), &(server.ssl) ) == 0 );
2205 TEST_ASSERT( server.ssl.renego_status ==
2206 MBEDTLS_SSL_RENEGOTIATION_DONE );
2207 TEST_ASSERT( client.ssl.renego_status ==
2208 MBEDTLS_SSL_RENEGOTIATION_DONE );
2209
2210 /* After calling mbedtls_ssl_renegotiate for the client all renegotiation
2211 * should happen inside this function. However in this test, we cannot
2212 * perform simultaneous communication betwen client and server so this
2213 * function will return waiting error on the socket. All rest of
2214 * renegotiation should happen during data exchanging */
2215 ret = mbedtls_ssl_renegotiate( &(client.ssl) );
Andrzej Kurek0afa2a12020-03-03 10:39:58 -05002216#if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
2217 if( options->resize_buffers != 0 )
2218 {
2219 /* Ensure that the buffer sizes are appropriate before resizes */
2220 TEST_ASSERT( client.ssl.out_buf_len == MBEDTLS_SSL_OUT_BUFFER_LEN );
2221 TEST_ASSERT( client.ssl.in_buf_len == MBEDTLS_SSL_IN_BUFFER_LEN );
2222 }
2223#endif
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05002224 TEST_ASSERT( ret == 0 ||
2225 ret == MBEDTLS_ERR_SSL_WANT_READ ||
2226 ret == MBEDTLS_ERR_SSL_WANT_WRITE );
2227 TEST_ASSERT( server.ssl.renego_status ==
2228 MBEDTLS_SSL_RENEGOTIATION_DONE );
2229 TEST_ASSERT( client.ssl.renego_status ==
2230 MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS );
2231
2232 TEST_ASSERT( exchange_data( &(client.ssl), &(server.ssl) ) == 0 );
2233 TEST_ASSERT( server.ssl.renego_status ==
2234 MBEDTLS_SSL_RENEGOTIATION_DONE );
2235 TEST_ASSERT( client.ssl.renego_status ==
2236 MBEDTLS_SSL_RENEGOTIATION_DONE );
Andrzej Kurek0afa2a12020-03-03 10:39:58 -05002237#if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
2238 /* Validate buffer sizes after renegotiation */
2239 if( options->resize_buffers != 0 )
2240 {
2241 TEST_ASSERT( client.ssl.out_buf_len ==
2242 mbedtls_ssl_get_output_buflen( &client.ssl ) );
2243 TEST_ASSERT( client.ssl.in_buf_len ==
2244 mbedtls_ssl_get_input_buflen( &client.ssl ) );
2245 TEST_ASSERT( server.ssl.out_buf_len ==
2246 mbedtls_ssl_get_output_buflen( &server.ssl ) );
2247 TEST_ASSERT( server.ssl.in_buf_len ==
2248 mbedtls_ssl_get_input_buflen( &server.ssl ) );
2249 }
2250#endif /* MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH */
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05002251 }
2252#endif /* MBEDTLS_SSL_RENEGOTIATION */
2253
Gilles Peskine80dae042022-01-21 23:50:39 +01002254 TEST_ASSERT( mbedtls_ssl_conf_get_user_data_p( &client.conf ) == &client );
2255 TEST_ASSERT( mbedtls_ssl_get_user_data_p( &client.ssl ) == &client );
2256 TEST_ASSERT( mbedtls_ssl_conf_get_user_data_p( &server.conf ) == &server );
2257 TEST_ASSERT( mbedtls_ssl_get_user_data_p( &server.ssl ) == &server );
2258
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05002259exit:
2260 mbedtls_endpoint_free( &client, options->dtls != 0 ? &client_context : NULL );
2261 mbedtls_endpoint_free( &server, options->dtls != 0 ? &server_context : NULL );
Piotr Nowickibde7ee82020-02-21 10:59:50 +01002262#if defined (MBEDTLS_DEBUG_C)
2263 if( options->cli_log_fun || options->srv_log_fun )
2264 {
2265 mbedtls_debug_set_threshold( 0 );
2266 }
2267#endif
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05002268#if defined(MBEDTLS_SSL_CONTEXT_SERIALIZATION)
2269 if( context_buf != NULL )
2270 mbedtls_free( context_buf );
2271#endif
Neil Armstrong46a17602022-02-23 15:11:16 +01002272 USE_PSA_DONE( );
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05002273}
Manuel Pégourié-Gonnardd12402f2020-05-20 10:34:25 +02002274#endif /* MBEDTLS_X509_CRT_PARSE_C && MBEDTLS_ENTROPY_C && MBEDTLS_CTR_DRBG_C */
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05002275
Manuel Pégourié-Gonnard4956fd72014-09-24 11:13:44 +02002276/* END_HEADER */
2277
2278/* BEGIN_DEPENDENCIES
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002279 * depends_on:MBEDTLS_SSL_TLS_C
Manuel Pégourié-Gonnard4956fd72014-09-24 11:13:44 +02002280 * END_DEPENDENCIES
2281 */
2282
Janos Follath6264e662019-11-26 11:11:15 +00002283/* BEGIN_CASE */
2284void test_callback_buffer_sanity()
2285{
2286 enum { MSGLEN = 10 };
2287 mbedtls_test_buffer buf;
2288 unsigned char input[MSGLEN];
2289 unsigned char output[MSGLEN];
2290
2291 memset( input, 0, sizeof(input) );
2292
2293 /* Make sure calling put and get on NULL buffer results in error. */
2294 TEST_ASSERT( mbedtls_test_buffer_put( NULL, input, sizeof( input ) )
2295 == -1 );
2296 TEST_ASSERT( mbedtls_test_buffer_get( NULL, output, sizeof( output ) )
2297 == -1 );
2298 TEST_ASSERT( mbedtls_test_buffer_put( NULL, NULL, sizeof( input ) ) == -1 );
Andrzej Kurekf7774142020-01-22 06:34:59 -05002299
Janos Follath6264e662019-11-26 11:11:15 +00002300 TEST_ASSERT( mbedtls_test_buffer_put( NULL, NULL, 0 ) == -1 );
2301 TEST_ASSERT( mbedtls_test_buffer_get( NULL, NULL, 0 ) == -1 );
2302
2303 /* Make sure calling put and get on a buffer that hasn't been set up results
2304 * in eror. */
2305 mbedtls_test_buffer_init( &buf );
2306
2307 TEST_ASSERT( mbedtls_test_buffer_put( &buf, input, sizeof( input ) ) == -1 );
2308 TEST_ASSERT( mbedtls_test_buffer_get( &buf, output, sizeof( output ) )
2309 == -1 );
2310 TEST_ASSERT( mbedtls_test_buffer_put( &buf, NULL, sizeof( input ) ) == -1 );
Andrzej Kurekf7774142020-01-22 06:34:59 -05002311
Janos Follath6264e662019-11-26 11:11:15 +00002312 TEST_ASSERT( mbedtls_test_buffer_put( &buf, NULL, 0 ) == -1 );
2313 TEST_ASSERT( mbedtls_test_buffer_get( &buf, NULL, 0 ) == -1 );
2314
Andrzej Kurekf7774142020-01-22 06:34:59 -05002315 /* Make sure calling put and get on NULL input only results in
2316 * error if the length is not zero, and that a NULL output is valid for data
2317 * dropping.
2318 */
Janos Follath6264e662019-11-26 11:11:15 +00002319
2320 TEST_ASSERT( mbedtls_test_buffer_setup( &buf, sizeof( input ) ) == 0 );
2321
2322 TEST_ASSERT( mbedtls_test_buffer_put( &buf, NULL, sizeof( input ) ) == -1 );
2323 TEST_ASSERT( mbedtls_test_buffer_get( &buf, NULL, sizeof( output ) )
Andrzej Kurekf7774142020-01-22 06:34:59 -05002324 == 0 );
Janos Follath6264e662019-11-26 11:11:15 +00002325 TEST_ASSERT( mbedtls_test_buffer_put( &buf, NULL, 0 ) == 0 );
2326 TEST_ASSERT( mbedtls_test_buffer_get( &buf, NULL, 0 ) == 0 );
2327
Piotr Nowickifb437d72020-01-13 16:59:12 +01002328 /* Make sure calling put several times in the row is safe */
2329
2330 TEST_ASSERT( mbedtls_test_buffer_put( &buf, input, sizeof( input ) )
2331 == sizeof( input ) );
2332 TEST_ASSERT( mbedtls_test_buffer_get( &buf, output, 2 ) == 2 );
2333 TEST_ASSERT( mbedtls_test_buffer_put( &buf, input, 1 ) == 1 );
2334 TEST_ASSERT( mbedtls_test_buffer_put( &buf, input, 2 ) == 1 );
2335 TEST_ASSERT( mbedtls_test_buffer_put( &buf, input, 2 ) == 0 );
2336
2337
Janos Follath6264e662019-11-26 11:11:15 +00002338exit:
2339
2340 mbedtls_test_buffer_free( &buf );
2341}
2342/* END_CASE */
2343
2344/*
2345 * Test if the implementation of `mbedtls_test_buffer` related functions is
2346 * correct and works as expected.
2347 *
2348 * That is
2349 * - If we try to put in \p put1 bytes then we can put in \p put1_ret bytes.
2350 * - Afterwards if we try to get \p get1 bytes then we can get \get1_ret bytes.
2351 * - Next, if we try to put in \p put1 bytes then we can put in \p put1_ret
2352 * bytes.
2353 * - Afterwards if we try to get \p get1 bytes then we can get \get1_ret bytes.
2354 * - All of the bytes we got match the bytes we put in in a FIFO manner.
2355 */
2356
2357/* BEGIN_CASE */
2358void test_callback_buffer( int size, int put1, int put1_ret,
2359 int get1, int get1_ret, int put2, int put2_ret,
2360 int get2, int get2_ret )
2361{
2362 enum { ROUNDS = 2 };
2363 size_t put[ROUNDS];
2364 int put_ret[ROUNDS];
2365 size_t get[ROUNDS];
2366 int get_ret[ROUNDS];
2367 mbedtls_test_buffer buf;
2368 unsigned char* input = NULL;
2369 size_t input_len;
2370 unsigned char* output = NULL;
2371 size_t output_len;
Janos Follath031827f2019-11-27 11:12:14 +00002372 size_t i, j, written, read;
Janos Follath6264e662019-11-26 11:11:15 +00002373
2374 mbedtls_test_buffer_init( &buf );
2375 TEST_ASSERT( mbedtls_test_buffer_setup( &buf, size ) == 0 );
2376
2377 /* Check the sanity of input parameters and initialise local variables. That
2378 * is, ensure that the amount of data is not negative and that we are not
2379 * expecting more to put or get than we actually asked for. */
2380 TEST_ASSERT( put1 >= 0 );
2381 put[0] = put1;
2382 put_ret[0] = put1_ret;
2383 TEST_ASSERT( put1_ret <= put1 );
2384 TEST_ASSERT( put2 >= 0 );
2385 put[1] = put2;
2386 put_ret[1] = put2_ret;
2387 TEST_ASSERT( put2_ret <= put2 );
2388
2389 TEST_ASSERT( get1 >= 0 );
2390 get[0] = get1;
2391 get_ret[0] = get1_ret;
2392 TEST_ASSERT( get1_ret <= get1 );
2393 TEST_ASSERT( get2 >= 0 );
2394 get[1] = get2;
2395 get_ret[1] = get2_ret;
2396 TEST_ASSERT( get2_ret <= get2 );
2397
2398 input_len = 0;
2399 /* Calculate actual input and output lengths */
2400 for( j = 0; j < ROUNDS; j++ )
2401 {
2402 if( put_ret[j] > 0 )
2403 {
2404 input_len += put_ret[j];
2405 }
2406 }
2407 /* In order to always have a valid pointer we always allocate at least 1
2408 * byte. */
2409 if( input_len == 0 )
2410 input_len = 1;
2411 ASSERT_ALLOC( input, input_len );
2412
2413 output_len = 0;
2414 for( j = 0; j < ROUNDS; j++ )
2415 {
2416 if( get_ret[j] > 0 )
2417 {
2418 output_len += get_ret[j];
2419 }
2420 }
2421 TEST_ASSERT( output_len <= input_len );
2422 /* In order to always have a valid pointer we always allocate at least 1
2423 * byte. */
2424 if( output_len == 0 )
2425 output_len = 1;
2426 ASSERT_ALLOC( output, output_len );
2427
2428 /* Fill up the buffer with structured data so that unwanted changes
2429 * can be detected */
2430 for( i = 0; i < input_len; i++ )
2431 {
2432 input[i] = i & 0xFF;
2433 }
2434
2435 written = read = 0;
2436 for( j = 0; j < ROUNDS; j++ )
2437 {
2438 TEST_ASSERT( put_ret[j] == mbedtls_test_buffer_put( &buf,
2439 input + written, put[j] ) );
2440 written += put_ret[j];
2441 TEST_ASSERT( get_ret[j] == mbedtls_test_buffer_get( &buf,
2442 output + read, get[j] ) );
2443 read += get_ret[j];
2444 TEST_ASSERT( read <= written );
2445 if( get_ret[j] > 0 )
2446 {
2447 TEST_ASSERT( memcmp( output + read - get_ret[j],
2448 input + read - get_ret[j], get_ret[j] )
2449 == 0 );
2450 }
2451 }
2452
2453exit:
2454
2455 mbedtls_free( input );
2456 mbedtls_free( output );
2457 mbedtls_test_buffer_free( &buf );
2458}
2459/* END_CASE */
2460
Janos Follath031827f2019-11-27 11:12:14 +00002461/*
Janos Follathc673c2c2019-12-02 15:47:26 +00002462 * Test if the implementation of `mbedtls_mock_socket` related I/O functions is
2463 * correct and works as expected on unconnected sockets.
2464 */
2465
2466/* BEGIN_CASE */
2467void ssl_mock_sanity( )
2468{
2469 enum { MSGLEN = 105 };
Paul Elliott21c8fe52021-11-24 16:54:26 +00002470 unsigned char message[MSGLEN] = { 0 };
2471 unsigned char received[MSGLEN] = { 0 };
Janos Follathc673c2c2019-12-02 15:47:26 +00002472 mbedtls_mock_socket socket;
2473
2474 mbedtls_mock_socket_init( &socket );
2475 TEST_ASSERT( mbedtls_mock_tcp_send_b( &socket, message, MSGLEN ) < 0 );
2476 mbedtls_mock_socket_close( &socket );
2477 mbedtls_mock_socket_init( &socket );
2478 TEST_ASSERT( mbedtls_mock_tcp_recv_b( &socket, received, MSGLEN ) < 0 );
2479 mbedtls_mock_socket_close( &socket );
2480
2481 mbedtls_mock_socket_init( &socket );
2482 TEST_ASSERT( mbedtls_mock_tcp_send_nb( &socket, message, MSGLEN ) < 0 );
2483 mbedtls_mock_socket_close( &socket );
2484 mbedtls_mock_socket_init( &socket );
2485 TEST_ASSERT( mbedtls_mock_tcp_recv_nb( &socket, received, MSGLEN ) < 0 );
2486 mbedtls_mock_socket_close( &socket );
2487
2488exit:
2489
2490 mbedtls_mock_socket_close( &socket );
2491}
2492/* END_CASE */
2493
2494/*
2495 * Test if the implementation of `mbedtls_mock_socket` related functions can
2496 * send a single message from the client to the server.
Janos Follath031827f2019-11-27 11:12:14 +00002497 */
2498
2499/* BEGIN_CASE */
Piotr Nowicki890b5ca2020-01-15 16:19:07 +01002500void ssl_mock_tcp( int blocking )
Janos Follath031827f2019-11-27 11:12:14 +00002501{
Janos Follathc673c2c2019-12-02 15:47:26 +00002502 enum { MSGLEN = 105 };
Piotr Nowicki890b5ca2020-01-15 16:19:07 +01002503 enum { BUFLEN = MSGLEN / 5 };
Janos Follathc673c2c2019-12-02 15:47:26 +00002504 unsigned char message[MSGLEN];
2505 unsigned char received[MSGLEN];
2506 mbedtls_mock_socket client;
2507 mbedtls_mock_socket server;
2508 size_t written, read;
2509 int send_ret, recv_ret;
2510 mbedtls_ssl_send_t *send;
2511 mbedtls_ssl_recv_t *recv;
Janos Follathc673c2c2019-12-02 15:47:26 +00002512 unsigned i;
2513
2514 if( blocking == 0 )
2515 {
2516 send = mbedtls_mock_tcp_send_nb;
2517 recv = mbedtls_mock_tcp_recv_nb;
2518 }
2519 else
2520 {
2521 send = mbedtls_mock_tcp_send_b;
2522 recv = mbedtls_mock_tcp_recv_b;
2523 }
2524
2525 mbedtls_mock_socket_init( &client );
2526 mbedtls_mock_socket_init( &server );
2527
2528 /* Fill up the buffer with structured data so that unwanted changes
2529 * can be detected */
2530 for( i = 0; i < MSGLEN; i++ )
2531 {
2532 message[i] = i & 0xFF;
2533 }
2534
2535 /* Make sure that sending a message takes a few iterations. */
Piotr Nowicki890b5ca2020-01-15 16:19:07 +01002536 TEST_ASSERT( 0 == mbedtls_mock_socket_connect( &client, &server, BUFLEN ) );
Janos Follathc673c2c2019-12-02 15:47:26 +00002537
2538 /* Send the message to the server */
2539 send_ret = recv_ret = 1;
2540 written = read = 0;
2541 while( send_ret != 0 || recv_ret != 0 )
2542 {
2543 send_ret = send( &client, message + written, MSGLEN - written );
2544
Piotr Nowicki890b5ca2020-01-15 16:19:07 +01002545 TEST_ASSERT( send_ret >= 0 );
2546 TEST_ASSERT( send_ret <= BUFLEN );
2547 written += send_ret;
2548
2549 /* If the buffer is full we can test blocking and non-blocking send */
2550 if ( send_ret == BUFLEN )
Janos Follathc673c2c2019-12-02 15:47:26 +00002551 {
Piotr Nowicki890b5ca2020-01-15 16:19:07 +01002552 int blocking_ret = send( &client, message , 1 );
2553 if ( blocking )
2554 {
2555 TEST_ASSERT( blocking_ret == 0 );
2556 }
2557 else
2558 {
2559 TEST_ASSERT( blocking_ret == MBEDTLS_ERR_SSL_WANT_WRITE );
2560 }
Janos Follathc673c2c2019-12-02 15:47:26 +00002561 }
Janos Follathc673c2c2019-12-02 15:47:26 +00002562
2563 recv_ret = recv( &server, received + read, MSGLEN - read );
Piotr Nowicki890b5ca2020-01-15 16:19:07 +01002564
2565 /* The result depends on whether any data was sent */
2566 if ( send_ret > 0 )
Janos Follathc673c2c2019-12-02 15:47:26 +00002567 {
Piotr Nowicki890b5ca2020-01-15 16:19:07 +01002568 TEST_ASSERT( recv_ret > 0 );
2569 TEST_ASSERT( recv_ret <= BUFLEN );
2570 read += recv_ret;
2571 }
2572 else if( blocking )
2573 {
2574 TEST_ASSERT( recv_ret == 0 );
Janos Follathc673c2c2019-12-02 15:47:26 +00002575 }
2576 else
2577 {
Piotr Nowicki890b5ca2020-01-15 16:19:07 +01002578 TEST_ASSERT( recv_ret == MBEDTLS_ERR_SSL_WANT_READ );
2579 recv_ret = 0;
Janos Follathc673c2c2019-12-02 15:47:26 +00002580 }
Piotr Nowicki890b5ca2020-01-15 16:19:07 +01002581
2582 /* If the buffer is empty we can test blocking and non-blocking read */
2583 if ( recv_ret == BUFLEN )
2584 {
2585 int blocking_ret = recv( &server, received, 1 );
2586 if ( blocking )
2587 {
2588 TEST_ASSERT( blocking_ret == 0 );
2589 }
2590 else
2591 {
2592 TEST_ASSERT( blocking_ret == MBEDTLS_ERR_SSL_WANT_READ );
2593 }
2594 }
Janos Follathc673c2c2019-12-02 15:47:26 +00002595 }
2596 TEST_ASSERT( memcmp( message, received, MSGLEN ) == 0 );
2597
2598exit:
2599
2600 mbedtls_mock_socket_close( &client );
2601 mbedtls_mock_socket_close( &server );
2602}
2603/* END_CASE */
2604
2605/*
2606 * Test if the implementation of `mbedtls_mock_socket` related functions can
2607 * send messages in both direction at the same time (with the I/O calls
2608 * interleaving).
2609 */
2610
2611/* BEGIN_CASE */
Piotr Nowicki890b5ca2020-01-15 16:19:07 +01002612void ssl_mock_tcp_interleaving( int blocking )
Janos Follathc673c2c2019-12-02 15:47:26 +00002613{
Janos Follath031827f2019-11-27 11:12:14 +00002614 enum { ROUNDS = 2 };
2615 enum { MSGLEN = 105 };
Piotr Nowicki890b5ca2020-01-15 16:19:07 +01002616 enum { BUFLEN = MSGLEN / 5 };
Janos Follath031827f2019-11-27 11:12:14 +00002617 unsigned char message[ROUNDS][MSGLEN];
2618 unsigned char received[ROUNDS][MSGLEN];
2619 mbedtls_mock_socket client;
2620 mbedtls_mock_socket server;
2621 size_t written[ROUNDS];
2622 size_t read[ROUNDS];
2623 int send_ret[ROUNDS];
2624 int recv_ret[ROUNDS];
2625 unsigned i, j, progress;
Janos Follath3766ba52019-11-27 13:31:42 +00002626 mbedtls_ssl_send_t *send;
2627 mbedtls_ssl_recv_t *recv;
Janos Follath3766ba52019-11-27 13:31:42 +00002628
2629 if( blocking == 0 )
2630 {
2631 send = mbedtls_mock_tcp_send_nb;
2632 recv = mbedtls_mock_tcp_recv_nb;
2633 }
2634 else
2635 {
2636 send = mbedtls_mock_tcp_send_b;
2637 recv = mbedtls_mock_tcp_recv_b;
2638 }
Janos Follath031827f2019-11-27 11:12:14 +00002639
2640 mbedtls_mock_socket_init( &client );
2641 mbedtls_mock_socket_init( &server );
2642
2643 /* Fill up the buffers with structured data so that unwanted changes
2644 * can be detected */
2645 for( i = 0; i < ROUNDS; i++ )
2646 {
2647 for( j = 0; j < MSGLEN; j++ )
2648 {
2649 message[i][j] = ( i * MSGLEN + j ) & 0xFF;
2650 }
2651 }
2652
Janos Follath031827f2019-11-27 11:12:14 +00002653 /* Make sure that sending a message takes a few iterations. */
Piotr Nowicki890b5ca2020-01-15 16:19:07 +01002654 TEST_ASSERT( 0 == mbedtls_mock_socket_connect( &client, &server, BUFLEN ) );
Janos Follath031827f2019-11-27 11:12:14 +00002655
Janos Follath031827f2019-11-27 11:12:14 +00002656 /* Send the message from both sides, interleaving. */
2657 progress = 1;
2658 for( i = 0; i < ROUNDS; i++ )
2659 {
2660 written[i] = 0;
2661 read[i] = 0;
2662 }
2663 /* This loop does not stop as long as there was a successful write or read
2664 * of at least one byte on either side. */
2665 while( progress != 0 )
2666 {
Piotr Nowicki890b5ca2020-01-15 16:19:07 +01002667 mbedtls_mock_socket *socket;
Janos Follath031827f2019-11-27 11:12:14 +00002668
Piotr Nowicki890b5ca2020-01-15 16:19:07 +01002669 for( i = 0; i < ROUNDS; i++ )
Janos Follath3766ba52019-11-27 13:31:42 +00002670 {
Piotr Nowicki890b5ca2020-01-15 16:19:07 +01002671 /* First sending is from the client */
2672 socket = ( i % 2 == 0 ) ? ( &client ) : ( &server );
Janos Follath031827f2019-11-27 11:12:14 +00002673
Piotr Nowicki890b5ca2020-01-15 16:19:07 +01002674 send_ret[i] = send( socket, message[i] + written[i],
2675 MSGLEN - written[i] );
2676 TEST_ASSERT( send_ret[i] >= 0 );
2677 TEST_ASSERT( send_ret[i] <= BUFLEN );
2678 written[i] += send_ret[i];
Janos Follath031827f2019-11-27 11:12:14 +00002679
Piotr Nowicki890b5ca2020-01-15 16:19:07 +01002680 /* If the buffer is full we can test blocking and non-blocking
2681 * send */
2682 if ( send_ret[i] == BUFLEN )
2683 {
2684 int blocking_ret = send( socket, message[i] , 1 );
2685 if ( blocking )
2686 {
2687 TEST_ASSERT( blocking_ret == 0 );
2688 }
2689 else
2690 {
2691 TEST_ASSERT( blocking_ret == MBEDTLS_ERR_SSL_WANT_WRITE );
2692 }
2693 }
Janos Follath3766ba52019-11-27 13:31:42 +00002694 }
Piotr Nowicki890b5ca2020-01-15 16:19:07 +01002695
2696 for( i = 0; i < ROUNDS; i++ )
Janos Follath3766ba52019-11-27 13:31:42 +00002697 {
Piotr Nowicki890b5ca2020-01-15 16:19:07 +01002698 /* First receiving is from the server */
2699 socket = ( i % 2 == 0 ) ? ( &server ) : ( &client );
2700
2701 recv_ret[i] = recv( socket, received[i] + read[i],
2702 MSGLEN - read[i] );
2703
2704 /* The result depends on whether any data was sent */
2705 if ( send_ret[i] > 0 )
2706 {
2707 TEST_ASSERT( recv_ret[i] > 0 );
2708 TEST_ASSERT( recv_ret[i] <= BUFLEN );
2709 read[i] += recv_ret[i];
2710 }
2711 else if( blocking )
2712 {
2713 TEST_ASSERT( recv_ret[i] == 0 );
2714 }
2715 else
2716 {
2717 TEST_ASSERT( recv_ret[i] == MBEDTLS_ERR_SSL_WANT_READ );
2718 recv_ret[i] = 0;
2719 }
2720
2721 /* If the buffer is empty we can test blocking and non-blocking
2722 * read */
2723 if ( recv_ret[i] == BUFLEN )
2724 {
2725 int blocking_ret = recv( socket, received[i], 1 );
2726 if ( blocking )
2727 {
2728 TEST_ASSERT( blocking_ret == 0 );
2729 }
2730 else
2731 {
2732 TEST_ASSERT( blocking_ret == MBEDTLS_ERR_SSL_WANT_READ );
2733 }
2734 }
Janos Follath3766ba52019-11-27 13:31:42 +00002735 }
Janos Follath031827f2019-11-27 11:12:14 +00002736
2737 progress = 0;
2738 for( i = 0; i < ROUNDS; i++ )
2739 {
Piotr Nowicki890b5ca2020-01-15 16:19:07 +01002740 progress += send_ret[i] + recv_ret[i];
Janos Follath031827f2019-11-27 11:12:14 +00002741 }
2742 }
2743
2744 for( i = 0; i < ROUNDS; i++ )
2745 TEST_ASSERT( memcmp( message[i], received[i], MSGLEN ) == 0 );
2746
2747exit:
2748
2749 mbedtls_mock_socket_close( &client );
2750 mbedtls_mock_socket_close( &server );
2751}
2752/* END_CASE */
2753
Andrzej Kurek13719cd2020-01-22 06:36:39 -05002754/* BEGIN_CASE */
2755void ssl_message_queue_sanity( )
2756{
2757 mbedtls_test_message_queue queue;
2758
2759 /* Trying to push/pull to an empty queue */
2760 TEST_ASSERT( mbedtls_test_message_queue_push_info( NULL, 1 )
2761 == MBEDTLS_TEST_ERROR_ARG_NULL );
2762 TEST_ASSERT( mbedtls_test_message_queue_pop_info( NULL, 1 )
2763 == MBEDTLS_TEST_ERROR_ARG_NULL );
2764
Andrzej Kurek89bdc582020-03-09 06:29:43 -04002765 TEST_ASSERT( mbedtls_test_message_queue_setup( &queue, 3 ) == 0 );
Andrzej Kurek13719cd2020-01-22 06:36:39 -05002766 TEST_ASSERT( queue.capacity == 3 );
2767 TEST_ASSERT( queue.num == 0 );
2768
2769exit:
2770 mbedtls_test_message_queue_free( &queue );
2771}
2772/* END_CASE */
2773
2774/* BEGIN_CASE */
2775void ssl_message_queue_basic( )
2776{
2777 mbedtls_test_message_queue queue;
2778
Andrzej Kurek89bdc582020-03-09 06:29:43 -04002779 TEST_ASSERT( mbedtls_test_message_queue_setup( &queue, 3 ) == 0 );
Andrzej Kurek13719cd2020-01-22 06:36:39 -05002780
2781 /* Sanity test - 3 pushes and 3 pops with sufficient space */
2782 TEST_ASSERT( mbedtls_test_message_queue_push_info( &queue, 1 ) == 1 );
2783 TEST_ASSERT( queue.capacity == 3 );
2784 TEST_ASSERT( queue.num == 1 );
2785 TEST_ASSERT( mbedtls_test_message_queue_push_info( &queue, 1 ) == 1 );
2786 TEST_ASSERT( queue.capacity == 3 );
2787 TEST_ASSERT( queue.num == 2 );
2788 TEST_ASSERT( mbedtls_test_message_queue_push_info( &queue, 2 ) == 2 );
2789 TEST_ASSERT( queue.capacity == 3 );
2790 TEST_ASSERT( queue.num == 3 );
2791
2792 TEST_ASSERT( mbedtls_test_message_queue_pop_info( &queue, 1 ) == 1 );
2793 TEST_ASSERT( mbedtls_test_message_queue_pop_info( &queue, 1 ) == 1 );
2794 TEST_ASSERT( mbedtls_test_message_queue_pop_info( &queue, 2 ) == 2 );
2795
2796exit:
2797 mbedtls_test_message_queue_free( &queue );
2798}
2799/* END_CASE */
2800
2801/* BEGIN_CASE */
2802void ssl_message_queue_overflow_underflow( )
2803{
2804 mbedtls_test_message_queue queue;
2805
Andrzej Kurek89bdc582020-03-09 06:29:43 -04002806 TEST_ASSERT( mbedtls_test_message_queue_setup( &queue, 3 ) == 0 );
Andrzej Kurek13719cd2020-01-22 06:36:39 -05002807
2808 /* 4 pushes (last one with an error), 4 pops (last one with an error) */
2809 TEST_ASSERT( mbedtls_test_message_queue_push_info( &queue, 1 ) == 1 );
2810 TEST_ASSERT( mbedtls_test_message_queue_push_info( &queue, 1 ) == 1 );
2811 TEST_ASSERT( mbedtls_test_message_queue_push_info( &queue, 2 ) == 2 );
2812 TEST_ASSERT( mbedtls_test_message_queue_push_info( &queue, 3 )
Andrzej Kurekf46b9122020-02-07 08:19:00 -05002813 == MBEDTLS_ERR_SSL_WANT_WRITE );
Andrzej Kurek13719cd2020-01-22 06:36:39 -05002814
2815 TEST_ASSERT( mbedtls_test_message_queue_pop_info( &queue, 1 ) == 1 );
2816 TEST_ASSERT( mbedtls_test_message_queue_pop_info( &queue, 1 ) == 1 );
2817 TEST_ASSERT( mbedtls_test_message_queue_pop_info( &queue, 2 ) == 2 );
2818
2819 TEST_ASSERT( mbedtls_test_message_queue_pop_info( &queue, 1 )
Andrzej Kurekf46b9122020-02-07 08:19:00 -05002820 == MBEDTLS_ERR_SSL_WANT_READ );
Andrzej Kurek13719cd2020-01-22 06:36:39 -05002821
2822exit:
2823 mbedtls_test_message_queue_free( &queue );
2824}
2825/* END_CASE */
2826
2827/* BEGIN_CASE */
2828void ssl_message_queue_interleaved( )
2829{
2830 mbedtls_test_message_queue queue;
2831
Andrzej Kurek89bdc582020-03-09 06:29:43 -04002832 TEST_ASSERT( mbedtls_test_message_queue_setup( &queue, 3 ) == 0 );
Andrzej Kurek13719cd2020-01-22 06:36:39 -05002833
2834 /* Interleaved test - [2 pushes, 1 pop] twice, and then two pops
2835 * (to wrap around the buffer) */
2836 TEST_ASSERT( mbedtls_test_message_queue_push_info( &queue, 1 ) == 1 );
2837 TEST_ASSERT( mbedtls_test_message_queue_push_info( &queue, 1 ) == 1 );
2838
2839 TEST_ASSERT( mbedtls_test_message_queue_pop_info( &queue, 1 ) == 1 );
2840
2841 TEST_ASSERT( mbedtls_test_message_queue_push_info( &queue, 2 ) == 2 );
2842 TEST_ASSERT( mbedtls_test_message_queue_push_info( &queue, 3 ) == 3 );
2843
2844 TEST_ASSERT( mbedtls_test_message_queue_pop_info( &queue, 1 ) == 1 );
2845 TEST_ASSERT( mbedtls_test_message_queue_pop_info( &queue, 2 ) == 2 );
2846
2847 TEST_ASSERT( mbedtls_test_message_queue_push_info( &queue, 5 ) == 5 );
2848 TEST_ASSERT( mbedtls_test_message_queue_push_info( &queue, 8 ) == 8 );
2849
2850 TEST_ASSERT( mbedtls_test_message_queue_pop_info( &queue, 3 ) == 3 );
2851
2852 TEST_ASSERT( mbedtls_test_message_queue_pop_info( &queue, 5 ) == 5 );
2853
2854 TEST_ASSERT( mbedtls_test_message_queue_pop_info( &queue, 8 ) == 8 );
2855
2856exit:
2857 mbedtls_test_message_queue_free( &queue );
2858}
2859/* END_CASE */
2860
2861/* BEGIN_CASE */
2862void ssl_message_queue_insufficient_buffer( )
2863{
2864 mbedtls_test_message_queue queue;
2865 size_t message_len = 10;
2866 size_t buffer_len = 5;
2867
Andrzej Kurek89bdc582020-03-09 06:29:43 -04002868 TEST_ASSERT( mbedtls_test_message_queue_setup( &queue, 1 ) == 0 );
Andrzej Kurek13719cd2020-01-22 06:36:39 -05002869
2870 /* Popping without a sufficient buffer */
2871 TEST_ASSERT( mbedtls_test_message_queue_push_info( &queue, message_len )
2872 == (int) message_len );
2873 TEST_ASSERT( mbedtls_test_message_queue_pop_info( &queue, buffer_len )
2874 == (int) buffer_len );
2875exit:
2876 mbedtls_test_message_queue_free( &queue );
2877}
2878/* END_CASE */
2879
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002880/* BEGIN_CASE */
2881void ssl_message_mock_uninitialized( )
2882{
2883 enum { MSGLEN = 10 };
Shawn Carey03092f52021-05-13 10:38:32 -04002884 unsigned char message[MSGLEN] = {0}, received[MSGLEN];
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002885 mbedtls_mock_socket client, server;
2886 mbedtls_test_message_queue server_queue, client_queue;
2887 mbedtls_test_message_socket_context server_context, client_context;
Andrzej Kurek45916ba2020-03-05 14:46:22 -05002888 mbedtls_message_socket_init( &server_context );
2889 mbedtls_message_socket_init( &client_context );
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002890
2891 /* Send with a NULL context */
2892 TEST_ASSERT( mbedtls_mock_tcp_send_msg( NULL, message, MSGLEN )
2893 == MBEDTLS_TEST_ERROR_CONTEXT_ERROR );
2894
2895 TEST_ASSERT( mbedtls_mock_tcp_recv_msg( NULL, message, MSGLEN )
2896 == MBEDTLS_TEST_ERROR_CONTEXT_ERROR );
2897
2898 TEST_ASSERT( mbedtls_message_socket_setup( &server_queue, &client_queue, 1,
2899 &server,
2900 &server_context ) == 0 );
2901
2902 TEST_ASSERT( mbedtls_message_socket_setup( &client_queue, &server_queue, 1,
2903 &client,
2904 &client_context ) == 0 );
2905
2906 TEST_ASSERT( mbedtls_mock_tcp_send_msg( &client_context, message, MSGLEN )
2907 == MBEDTLS_TEST_ERROR_SEND_FAILED );
2908
2909 TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received, MSGLEN )
Andrzej Kurekf46b9122020-02-07 08:19:00 -05002910 == MBEDTLS_ERR_SSL_WANT_READ );
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002911
2912 /* Push directly to a queue to later simulate a disconnected behavior */
2913 TEST_ASSERT( mbedtls_test_message_queue_push_info( &server_queue, MSGLEN )
2914 == MSGLEN );
2915
2916 /* Test if there's an error when trying to read from a disconnected
2917 * socket */
2918 TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received, MSGLEN )
2919 == MBEDTLS_TEST_ERROR_RECV_FAILED );
2920 exit:
2921 mbedtls_message_socket_close( &server_context );
2922 mbedtls_message_socket_close( &client_context );
2923}
2924/* END_CASE */
2925
2926/* BEGIN_CASE */
2927void ssl_message_mock_basic( )
2928{
2929 enum { MSGLEN = 10 };
2930 unsigned char message[MSGLEN], received[MSGLEN];
2931 mbedtls_mock_socket client, server;
2932 unsigned i;
2933 mbedtls_test_message_queue server_queue, client_queue;
2934 mbedtls_test_message_socket_context server_context, client_context;
Andrzej Kurek45916ba2020-03-05 14:46:22 -05002935 mbedtls_message_socket_init( &server_context );
2936 mbedtls_message_socket_init( &client_context );
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002937
2938 TEST_ASSERT( mbedtls_message_socket_setup( &server_queue, &client_queue, 1,
2939 &server,
2940 &server_context ) == 0 );
2941
2942 TEST_ASSERT( mbedtls_message_socket_setup( &client_queue, &server_queue, 1,
2943 &client,
2944 &client_context ) == 0 );
2945
2946 /* Fill up the buffer with structured data so that unwanted changes
2947 * can be detected */
2948 for( i = 0; i < MSGLEN; i++ )
2949 {
2950 message[i] = i & 0xFF;
2951 }
2952 TEST_ASSERT( 0 == mbedtls_mock_socket_connect( &client, &server,
2953 MSGLEN ) );
2954
2955 /* Send the message to the server */
2956 TEST_ASSERT( mbedtls_mock_tcp_send_msg( &client_context, message,
2957 MSGLEN ) == MSGLEN );
2958
2959 /* Read from the server */
2960 TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received, MSGLEN )
2961 == MSGLEN );
2962
2963 TEST_ASSERT( memcmp( message, received, MSGLEN ) == 0 );
2964 memset( received, 0, MSGLEN );
2965
2966 /* Send the message to the client */
2967 TEST_ASSERT( mbedtls_mock_tcp_send_msg( &server_context, message,
2968 MSGLEN ) == MSGLEN );
2969
2970 /* Read from the client */
2971 TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &client_context, received, MSGLEN )
2972 == MSGLEN );
2973 TEST_ASSERT( memcmp( message, received, MSGLEN ) == 0 );
2974
2975 exit:
2976 mbedtls_message_socket_close( &server_context );
2977 mbedtls_message_socket_close( &client_context );
2978}
2979/* END_CASE */
2980
2981/* BEGIN_CASE */
2982void ssl_message_mock_queue_overflow_underflow( )
2983{
2984 enum { MSGLEN = 10 };
2985 unsigned char message[MSGLEN], received[MSGLEN];
2986 mbedtls_mock_socket client, server;
2987 unsigned i;
2988 mbedtls_test_message_queue server_queue, client_queue;
2989 mbedtls_test_message_socket_context server_context, client_context;
Andrzej Kurek45916ba2020-03-05 14:46:22 -05002990 mbedtls_message_socket_init( &server_context );
2991 mbedtls_message_socket_init( &client_context );
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002992
2993 TEST_ASSERT( mbedtls_message_socket_setup( &server_queue, &client_queue, 2,
2994 &server,
2995 &server_context ) == 0 );
2996
2997 TEST_ASSERT( mbedtls_message_socket_setup( &client_queue, &server_queue, 2,
2998 &client,
2999 &client_context ) == 0 );
3000
3001 /* Fill up the buffer with structured data so that unwanted changes
3002 * can be detected */
3003 for( i = 0; i < MSGLEN; i++ )
3004 {
3005 message[i] = i & 0xFF;
3006 }
3007 TEST_ASSERT( 0 == mbedtls_mock_socket_connect( &client, &server,
3008 MSGLEN*2 ) );
3009
3010 /* Send three message to the server, last one with an error */
3011 TEST_ASSERT( mbedtls_mock_tcp_send_msg( &client_context, message,
3012 MSGLEN - 1 ) == MSGLEN - 1 );
3013
3014 TEST_ASSERT( mbedtls_mock_tcp_send_msg( &client_context, message,
3015 MSGLEN ) == MSGLEN );
3016
3017 TEST_ASSERT( mbedtls_mock_tcp_send_msg( &client_context, message,
3018 MSGLEN )
Andrzej Kurekf46b9122020-02-07 08:19:00 -05003019 == MBEDTLS_ERR_SSL_WANT_WRITE );
Andrzej Kurekbc483de2020-01-22 03:40:00 -05003020
3021 /* Read three messages from the server, last one with an error */
3022 TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received,
3023 MSGLEN - 1 ) == MSGLEN - 1 );
3024
3025 TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received, MSGLEN )
3026 == MSGLEN );
3027
3028 TEST_ASSERT( memcmp( message, received, MSGLEN ) == 0 );
3029
3030 TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received, MSGLEN )
Andrzej Kurekf46b9122020-02-07 08:19:00 -05003031 == MBEDTLS_ERR_SSL_WANT_READ );
Andrzej Kurekbc483de2020-01-22 03:40:00 -05003032
3033 exit:
3034 mbedtls_message_socket_close( &server_context );
3035 mbedtls_message_socket_close( &client_context );
3036}
3037/* END_CASE */
3038
3039/* BEGIN_CASE */
3040void ssl_message_mock_socket_overflow( )
3041{
3042 enum { MSGLEN = 10 };
3043 unsigned char message[MSGLEN], received[MSGLEN];
3044 mbedtls_mock_socket client, server;
3045 unsigned i;
3046 mbedtls_test_message_queue server_queue, client_queue;
3047 mbedtls_test_message_socket_context server_context, client_context;
Andrzej Kurek45916ba2020-03-05 14:46:22 -05003048 mbedtls_message_socket_init( &server_context );
3049 mbedtls_message_socket_init( &client_context );
Andrzej Kurekbc483de2020-01-22 03:40:00 -05003050
3051 TEST_ASSERT( mbedtls_message_socket_setup( &server_queue, &client_queue, 2,
3052 &server,
3053 &server_context ) == 0 );
3054
3055 TEST_ASSERT( mbedtls_message_socket_setup( &client_queue, &server_queue, 2,
3056 &client,
3057 &client_context ) == 0 );
3058
3059 /* Fill up the buffer with structured data so that unwanted changes
3060 * can be detected */
3061 for( i = 0; i < MSGLEN; i++ )
3062 {
3063 message[i] = i & 0xFF;
3064 }
3065 TEST_ASSERT( 0 == mbedtls_mock_socket_connect( &client, &server,
3066 MSGLEN ) );
3067
3068 /* Send two message to the server, second one with an error */
3069 TEST_ASSERT( mbedtls_mock_tcp_send_msg( &client_context, message,
3070 MSGLEN ) == MSGLEN );
3071
3072 TEST_ASSERT( mbedtls_mock_tcp_send_msg( &client_context, message,
3073 MSGLEN )
3074 == MBEDTLS_TEST_ERROR_SEND_FAILED );
3075
3076 /* Read the only message from the server */
3077 TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received, MSGLEN )
3078 == MSGLEN );
3079
3080 TEST_ASSERT( memcmp( message, received, MSGLEN ) == 0 );
3081
3082 exit:
3083 mbedtls_message_socket_close( &server_context );
3084 mbedtls_message_socket_close( &client_context );
3085}
3086/* END_CASE */
3087
3088/* BEGIN_CASE */
3089void ssl_message_mock_truncated( )
3090{
3091 enum { MSGLEN = 10 };
3092 unsigned char message[MSGLEN], received[MSGLEN];
3093 mbedtls_mock_socket client, server;
3094 unsigned i;
3095 mbedtls_test_message_queue server_queue, client_queue;
3096 mbedtls_test_message_socket_context server_context, client_context;
Andrzej Kurek45916ba2020-03-05 14:46:22 -05003097 mbedtls_message_socket_init( &server_context );
3098 mbedtls_message_socket_init( &client_context );
Andrzej Kurekbc483de2020-01-22 03:40:00 -05003099
3100 TEST_ASSERT( mbedtls_message_socket_setup( &server_queue, &client_queue, 2,
3101 &server,
3102 &server_context ) == 0 );
3103
3104 TEST_ASSERT( mbedtls_message_socket_setup( &client_queue, &server_queue, 2,
3105 &client,
3106 &client_context ) == 0 );
3107
3108 memset( received, 0, MSGLEN );
3109 /* Fill up the buffer with structured data so that unwanted changes
3110 * can be detected */
3111 for( i = 0; i < MSGLEN; i++ )
3112 {
3113 message[i] = i & 0xFF;
3114 }
3115 TEST_ASSERT( 0 == mbedtls_mock_socket_connect( &client, &server,
3116 2 * MSGLEN ) );
3117
3118 /* Send two messages to the server, the second one small enough to fit in the
3119 * receiver's buffer. */
3120 TEST_ASSERT( mbedtls_mock_tcp_send_msg( &client_context, message,
3121 MSGLEN ) == MSGLEN );
3122 TEST_ASSERT( mbedtls_mock_tcp_send_msg( &client_context, message,
3123 MSGLEN / 2 ) == MSGLEN / 2 );
3124 /* Read a truncated message from the server */
3125 TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received, MSGLEN/2 )
3126 == MSGLEN/2 );
3127
3128 /* Test that the first half of the message is valid, and second one isn't */
3129 TEST_ASSERT( memcmp( message, received, MSGLEN/2 ) == 0 );
3130 TEST_ASSERT( memcmp( message + MSGLEN/2, received + MSGLEN/2, MSGLEN/2 )
3131 != 0 );
3132 memset( received, 0, MSGLEN );
3133
3134 /* Read a full message from the server */
3135 TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received, MSGLEN/2 )
3136 == MSGLEN / 2 );
3137
3138 /* Test that the first half of the message is valid */
3139 TEST_ASSERT( memcmp( message, received, MSGLEN/2 ) == 0 );
3140
3141 exit:
3142 mbedtls_message_socket_close( &server_context );
3143 mbedtls_message_socket_close( &client_context );
3144}
3145/* END_CASE */
3146
3147/* BEGIN_CASE */
3148void ssl_message_mock_socket_read_error( )
3149{
3150 enum { MSGLEN = 10 };
3151 unsigned char message[MSGLEN], received[MSGLEN];
3152 mbedtls_mock_socket client, server;
3153 unsigned i;
3154 mbedtls_test_message_queue server_queue, client_queue;
3155 mbedtls_test_message_socket_context server_context, client_context;
Andrzej Kurek45916ba2020-03-05 14:46:22 -05003156 mbedtls_message_socket_init( &server_context );
3157 mbedtls_message_socket_init( &client_context );
Andrzej Kurekbc483de2020-01-22 03:40:00 -05003158
3159 TEST_ASSERT( mbedtls_message_socket_setup( &server_queue, &client_queue, 1,
3160 &server,
3161 &server_context ) == 0 );
3162
3163 TEST_ASSERT( mbedtls_message_socket_setup( &client_queue, &server_queue, 1,
3164 &client,
3165 &client_context ) == 0 );
3166
3167 /* Fill up the buffer with structured data so that unwanted changes
3168 * can be detected */
3169 for( i = 0; i < MSGLEN; i++ )
3170 {
3171 message[i] = i & 0xFF;
3172 }
3173 TEST_ASSERT( 0 == mbedtls_mock_socket_connect( &client, &server,
3174 MSGLEN ) );
3175
3176 TEST_ASSERT( mbedtls_mock_tcp_send_msg( &client_context, message,
3177 MSGLEN ) == MSGLEN );
3178
3179 /* Force a read error by disconnecting the socket by hand */
3180 server.status = 0;
3181 TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received, MSGLEN )
3182 == MBEDTLS_TEST_ERROR_RECV_FAILED );
3183 /* Return to a valid state */
3184 server.status = MBEDTLS_MOCK_SOCKET_CONNECTED;
3185
3186 memset( received, 0, sizeof( received ) );
3187
3188 /* Test that even though the server tried to read once disconnected, the
3189 * continuity is preserved */
3190 TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received, MSGLEN )
3191 == MSGLEN );
3192
3193 TEST_ASSERT( memcmp( message, received, MSGLEN ) == 0 );
3194
3195 exit:
3196 mbedtls_message_socket_close( &server_context );
3197 mbedtls_message_socket_close( &client_context );
3198}
3199/* END_CASE */
3200
3201/* BEGIN_CASE */
3202void ssl_message_mock_interleaved_one_way( )
3203{
3204 enum { MSGLEN = 10 };
3205 unsigned char message[MSGLEN], received[MSGLEN];
3206 mbedtls_mock_socket client, server;
3207 unsigned i;
3208 mbedtls_test_message_queue server_queue, client_queue;
3209 mbedtls_test_message_socket_context server_context, client_context;
Andrzej Kurek45916ba2020-03-05 14:46:22 -05003210 mbedtls_message_socket_init( &server_context );
3211 mbedtls_message_socket_init( &client_context );
Andrzej Kurekbc483de2020-01-22 03:40:00 -05003212
3213 TEST_ASSERT( mbedtls_message_socket_setup( &server_queue, &client_queue, 3,
3214 &server,
3215 &server_context ) == 0 );
3216
3217 TEST_ASSERT( mbedtls_message_socket_setup( &client_queue, &server_queue, 3,
3218 &client,
3219 &client_context ) == 0 );
3220
3221 /* Fill up the buffer with structured data so that unwanted changes
3222 * can be detected */
3223 for( i = 0; i < MSGLEN; i++ )
3224 {
3225 message[i] = i & 0xFF;
3226 }
3227 TEST_ASSERT( 0 == mbedtls_mock_socket_connect( &client, &server,
3228 MSGLEN*3 ) );
3229
3230 /* Interleaved test - [2 sends, 1 read] twice, and then two reads
3231 * (to wrap around the buffer) */
3232 for( i = 0; i < 2; i++ )
3233 {
3234 TEST_ASSERT( mbedtls_mock_tcp_send_msg( &client_context, message,
3235 MSGLEN ) == MSGLEN );
3236
3237 TEST_ASSERT( mbedtls_mock_tcp_send_msg( &client_context, message,
3238 MSGLEN ) == MSGLEN );
3239
3240 TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received,
3241 MSGLEN ) == MSGLEN );
3242 TEST_ASSERT( memcmp( message, received, MSGLEN ) == 0 );
3243 memset( received, 0, sizeof( received ) );
3244 }
3245
3246 for( i = 0; i < 2; i++ )
3247 {
3248 TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received,
3249 MSGLEN ) == MSGLEN );
3250
3251 TEST_ASSERT( memcmp( message, received, MSGLEN ) == 0 );
3252 }
3253 TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received, MSGLEN )
Andrzej Kurekf46b9122020-02-07 08:19:00 -05003254 == MBEDTLS_ERR_SSL_WANT_READ );
Andrzej Kurekbc483de2020-01-22 03:40:00 -05003255 exit:
3256 mbedtls_message_socket_close( &server_context );
3257 mbedtls_message_socket_close( &client_context );
3258}
3259/* END_CASE */
3260
3261/* BEGIN_CASE */
3262void ssl_message_mock_interleaved_two_ways( )
3263{
3264 enum { MSGLEN = 10 };
3265 unsigned char message[MSGLEN], received[MSGLEN];
3266 mbedtls_mock_socket client, server;
3267 unsigned i;
3268 mbedtls_test_message_queue server_queue, client_queue;
3269 mbedtls_test_message_socket_context server_context, client_context;
Andrzej Kurek45916ba2020-03-05 14:46:22 -05003270 mbedtls_message_socket_init( &server_context );
3271 mbedtls_message_socket_init( &client_context );
Andrzej Kurekbc483de2020-01-22 03:40:00 -05003272
3273 TEST_ASSERT( mbedtls_message_socket_setup( &server_queue, &client_queue, 3,
3274 &server,
3275 &server_context ) == 0 );
3276
3277 TEST_ASSERT( mbedtls_message_socket_setup( &client_queue, &server_queue, 3,
3278 &client,
3279 &client_context ) == 0 );
3280
3281 /* Fill up the buffer with structured data so that unwanted changes
3282 * can be detected */
3283 for( i = 0; i < MSGLEN; i++ )
3284 {
3285 message[i] = i & 0xFF;
3286 }
3287 TEST_ASSERT( 0 == mbedtls_mock_socket_connect( &client, &server,
3288 MSGLEN*3 ) );
3289
3290 /* Interleaved test - [2 sends, 1 read] twice, both ways, and then two reads
3291 * (to wrap around the buffer) both ways. */
3292 for( i = 0; i < 2; i++ )
3293 {
3294 TEST_ASSERT( mbedtls_mock_tcp_send_msg( &client_context, message,
3295 MSGLEN ) == MSGLEN );
3296
3297 TEST_ASSERT( mbedtls_mock_tcp_send_msg( &client_context, message,
3298 MSGLEN ) == MSGLEN );
3299
3300 TEST_ASSERT( mbedtls_mock_tcp_send_msg( &server_context, message,
3301 MSGLEN ) == MSGLEN );
3302
3303 TEST_ASSERT( mbedtls_mock_tcp_send_msg( &server_context, message,
3304 MSGLEN ) == MSGLEN );
3305
3306 TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received,
3307 MSGLEN ) == MSGLEN );
3308
3309 TEST_ASSERT( memcmp( message, received, MSGLEN ) == 0 );
3310
3311 memset( received, 0, sizeof( received ) );
3312
3313 TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &client_context, received,
3314 MSGLEN ) == MSGLEN );
3315
3316 TEST_ASSERT( memcmp( message, received, MSGLEN ) == 0 );
3317
3318 memset( received, 0, sizeof( received ) );
3319 }
3320
3321 for( i = 0; i < 2; i++ )
3322 {
3323 TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received,
3324 MSGLEN ) == MSGLEN );
3325
3326 TEST_ASSERT( memcmp( message, received, MSGLEN ) == 0 );
3327 memset( received, 0, sizeof( received ) );
3328
3329 TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &client_context, received,
3330 MSGLEN ) == MSGLEN );
3331
3332 TEST_ASSERT( memcmp( message, received, MSGLEN ) == 0 );
3333 memset( received, 0, sizeof( received ) );
3334 }
3335
3336 TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received, MSGLEN )
Andrzej Kurekf46b9122020-02-07 08:19:00 -05003337 == MBEDTLS_ERR_SSL_WANT_READ );
Andrzej Kurekbc483de2020-01-22 03:40:00 -05003338
3339 TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &client_context, received, MSGLEN )
Andrzej Kurekf46b9122020-02-07 08:19:00 -05003340 == MBEDTLS_ERR_SSL_WANT_READ );
Andrzej Kurekbc483de2020-01-22 03:40:00 -05003341 exit:
3342 mbedtls_message_socket_close( &server_context );
3343 mbedtls_message_socket_close( &client_context );
3344}
3345/* END_CASE */
3346
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003347/* BEGIN_CASE depends_on:MBEDTLS_SSL_DTLS_ANTI_REPLAY */
Azim Khan5fcca462018-06-29 11:05:32 +01003348void ssl_dtls_replay( data_t * prevs, data_t * new, int ret )
Manuel Pégourié-Gonnard4956fd72014-09-24 11:13:44 +02003349{
Azim Khand30ca132017-06-09 04:32:58 +01003350 uint32_t len = 0;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003351 mbedtls_ssl_context ssl;
Manuel Pégourié-Gonnarddef0bbe2015-05-04 14:56:36 +02003352 mbedtls_ssl_config conf;
Manuel Pégourié-Gonnard4956fd72014-09-24 11:13:44 +02003353
Manuel Pégourié-Gonnard41d479e2015-04-29 00:48:22 +02003354 mbedtls_ssl_init( &ssl );
Manuel Pégourié-Gonnarddef0bbe2015-05-04 14:56:36 +02003355 mbedtls_ssl_config_init( &conf );
Manuel Pégourié-Gonnard41d479e2015-04-29 00:48:22 +02003356
Manuel Pégourié-Gonnard419d5ae2015-05-04 19:32:36 +02003357 TEST_ASSERT( mbedtls_ssl_config_defaults( &conf,
3358 MBEDTLS_SSL_IS_CLIENT,
Manuel Pégourié-Gonnardb31c5f62015-06-17 13:53:47 +02003359 MBEDTLS_SSL_TRANSPORT_DATAGRAM,
3360 MBEDTLS_SSL_PRESET_DEFAULT ) == 0 );
Manuel Pégourié-Gonnarddef0bbe2015-05-04 14:56:36 +02003361 TEST_ASSERT( mbedtls_ssl_setup( &ssl, &conf ) == 0 );
Manuel Pégourié-Gonnard4956fd72014-09-24 11:13:44 +02003362
3363 /* Read previous record numbers */
Azim Khand30ca132017-06-09 04:32:58 +01003364 for( len = 0; len < prevs->len; len += 6 )
Manuel Pégourié-Gonnard4956fd72014-09-24 11:13:44 +02003365 {
Azim Khand30ca132017-06-09 04:32:58 +01003366 memcpy( ssl.in_ctr + 2, prevs->x + len, 6 );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003367 mbedtls_ssl_dtls_replay_update( &ssl );
Manuel Pégourié-Gonnard4956fd72014-09-24 11:13:44 +02003368 }
3369
3370 /* Check new number */
Azim Khand30ca132017-06-09 04:32:58 +01003371 memcpy( ssl.in_ctr + 2, new->x, 6 );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003372 TEST_ASSERT( mbedtls_ssl_dtls_replay_check( &ssl ) == ret );
Manuel Pégourié-Gonnard4956fd72014-09-24 11:13:44 +02003373
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003374 mbedtls_ssl_free( &ssl );
Manuel Pégourié-Gonnarddef0bbe2015-05-04 14:56:36 +02003375 mbedtls_ssl_config_free( &conf );
Manuel Pégourié-Gonnard4956fd72014-09-24 11:13:44 +02003376}
3377/* END_CASE */
Hanno Beckerb25c0c72017-05-05 11:24:30 +01003378
3379/* BEGIN_CASE depends_on:MBEDTLS_X509_CRT_PARSE_C */
3380void ssl_set_hostname_twice( char *hostname0, char *hostname1 )
3381{
3382 mbedtls_ssl_context ssl;
3383 mbedtls_ssl_init( &ssl );
3384
3385 TEST_ASSERT( mbedtls_ssl_set_hostname( &ssl, hostname0 ) == 0 );
3386 TEST_ASSERT( mbedtls_ssl_set_hostname( &ssl, hostname1 ) == 0 );
3387
3388 mbedtls_ssl_free( &ssl );
3389}
Darryl Green11999bb2018-03-13 15:22:58 +00003390/* END_CASE */
Hanno Beckera18d1322018-01-03 14:27:32 +00003391
3392/* BEGIN_CASE */
3393void ssl_crypt_record( int cipher_type, int hash_id,
Hanno Beckerd856c822019-04-29 17:30:59 +01003394 int etm, int tag_mode, int ver,
3395 int cid0_len, int cid1_len )
Hanno Beckera18d1322018-01-03 14:27:32 +00003396{
3397 /*
3398 * Test several record encryptions and decryptions
3399 * with plenty of space before and after the data
3400 * within the record buffer.
3401 */
3402
3403 int ret;
3404 int num_records = 16;
3405 mbedtls_ssl_context ssl; /* ONLY for debugging */
3406
3407 mbedtls_ssl_transform t0, t1;
Hanno Becker81e16a32019-03-01 11:21:44 +00003408 unsigned char *buf = NULL;
Hanno Beckera18d1322018-01-03 14:27:32 +00003409 size_t const buflen = 512;
3410 mbedtls_record rec, rec_backup;
3411
Przemyslaw Stekiel93cf4ee2022-01-19 16:18:53 +01003412 USE_PSA_INIT( );
3413
Hanno Beckera18d1322018-01-03 14:27:32 +00003414 mbedtls_ssl_init( &ssl );
3415 mbedtls_ssl_transform_init( &t0 );
3416 mbedtls_ssl_transform_init( &t1 );
Przemyslaw Stekiel93cf4ee2022-01-19 16:18:53 +01003417 ret = build_transforms( &t0, &t1, cipher_type, hash_id,
3418 etm, tag_mode, ver,
3419 (size_t) cid0_len,
3420 (size_t) cid1_len );
3421
Przemyslaw Stekiel8c010eb2022-02-03 10:44:02 +01003422 TEST_ASSERT( ret == 0 );
Hanno Beckera18d1322018-01-03 14:27:32 +00003423
Hanno Becker3ee54212019-04-04 16:31:26 +01003424 TEST_ASSERT( ( buf = mbedtls_calloc( 1, buflen ) ) != NULL );
Hanno Beckera18d1322018-01-03 14:27:32 +00003425
3426 while( num_records-- > 0 )
3427 {
3428 mbedtls_ssl_transform *t_dec, *t_enc;
3429 /* Take turns in who's sending and who's receiving. */
3430 if( num_records % 3 == 0 )
3431 {
3432 t_dec = &t0;
3433 t_enc = &t1;
3434 }
3435 else
3436 {
3437 t_dec = &t1;
3438 t_enc = &t0;
3439 }
3440
3441 /*
3442 * The record header affects the transformation in two ways:
3443 * 1) It determines the AEAD additional data
3444 * 2) The record counter sometimes determines the IV.
3445 *
3446 * Apart from that, the fields don't have influence.
3447 * In particular, it is currently not the responsibility
3448 * of ssl_encrypt/decrypt_buf to check if the transform
3449 * version matches the record version, or that the
3450 * type is sensible.
3451 */
3452
3453 memset( rec.ctr, num_records, sizeof( rec.ctr ) );
3454 rec.type = 42;
3455 rec.ver[0] = num_records;
3456 rec.ver[1] = num_records;
Hanno Beckera0e20d02019-05-15 14:03:01 +01003457#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
Hanno Beckerd856c822019-04-29 17:30:59 +01003458 rec.cid_len = 0;
Hanno Beckera0e20d02019-05-15 14:03:01 +01003459#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
Hanno Beckera18d1322018-01-03 14:27:32 +00003460
3461 rec.buf = buf;
3462 rec.buf_len = buflen;
3463 rec.data_offset = 16;
3464 /* Make sure to vary the length to exercise different
3465 * paddings. */
3466 rec.data_len = 1 + num_records;
3467
3468 memset( rec.buf + rec.data_offset, 42, rec.data_len );
3469
3470 /* Make a copy for later comparison */
3471 rec_backup = rec;
3472
3473 /* Encrypt record */
3474 ret = mbedtls_ssl_encrypt_buf( &ssl, t_enc, &rec,
Ronald Cron351f0ee2020-06-10 12:12:18 +02003475 mbedtls_test_rnd_std_rand, NULL );
Hanno Beckera18d1322018-01-03 14:27:32 +00003476 TEST_ASSERT( ret == 0 || ret == MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL );
3477 if( ret != 0 )
3478 {
3479 continue;
3480 }
3481
Hanno Beckerb2713ab2020-05-07 14:54:22 +01003482#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
3483 if( rec.cid_len != 0 )
3484 {
3485 /* DTLS 1.2 + CID hides the real content type and
3486 * uses a special CID content type in the protected
3487 * record. Double-check this. */
3488 TEST_ASSERT( rec.type == MBEDTLS_SSL_MSG_CID );
3489 }
3490#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
3491
Ronald Cron6f135e12021-12-08 16:57:54 +01003492#if defined(MBEDTLS_SSL_PROTO_TLS1_3)
Hanno Beckerb2713ab2020-05-07 14:54:22 +01003493 if( t_enc->minor_ver == MBEDTLS_SSL_MINOR_VERSION_4 )
3494 {
3495 /* TLS 1.3 hides the real content type and
3496 * always uses Application Data as the content type
3497 * for protected records. Double-check this. */
3498 TEST_ASSERT( rec.type == MBEDTLS_SSL_MSG_APPLICATION_DATA );
3499 }
Ronald Cron6f135e12021-12-08 16:57:54 +01003500#endif /* MBEDTLS_SSL_PROTO_TLS1_3 */
Hanno Beckerb2713ab2020-05-07 14:54:22 +01003501
Hanno Beckera18d1322018-01-03 14:27:32 +00003502 /* Decrypt record with t_dec */
Hanno Beckerd856c822019-04-29 17:30:59 +01003503 ret = mbedtls_ssl_decrypt_buf( &ssl, t_dec, &rec );
3504 TEST_ASSERT( ret == 0 );
Hanno Beckera18d1322018-01-03 14:27:32 +00003505
3506 /* Compare results */
3507 TEST_ASSERT( rec.type == rec_backup.type );
3508 TEST_ASSERT( memcmp( rec.ctr, rec_backup.ctr, 8 ) == 0 );
3509 TEST_ASSERT( rec.ver[0] == rec_backup.ver[0] );
3510 TEST_ASSERT( rec.ver[1] == rec_backup.ver[1] );
3511 TEST_ASSERT( rec.data_len == rec_backup.data_len );
3512 TEST_ASSERT( rec.data_offset == rec_backup.data_offset );
3513 TEST_ASSERT( memcmp( rec.buf + rec.data_offset,
3514 rec_backup.buf + rec_backup.data_offset,
3515 rec.data_len ) == 0 );
3516 }
3517
Hanno Becker81e16a32019-03-01 11:21:44 +00003518exit:
3519
Hanno Beckera18d1322018-01-03 14:27:32 +00003520 /* Cleanup */
3521 mbedtls_ssl_free( &ssl );
3522 mbedtls_ssl_transform_free( &t0 );
3523 mbedtls_ssl_transform_free( &t1 );
3524
Hanno Becker3ee54212019-04-04 16:31:26 +01003525 mbedtls_free( buf );
Przemyslaw Stekiel93cf4ee2022-01-19 16:18:53 +01003526 USE_PSA_DONE( );
Hanno Beckera18d1322018-01-03 14:27:32 +00003527}
3528/* END_CASE */
Hanno Beckerb3268da2018-01-05 15:20:24 +00003529
3530/* BEGIN_CASE */
3531void ssl_crypt_record_small( int cipher_type, int hash_id,
Hanno Beckerd856c822019-04-29 17:30:59 +01003532 int etm, int tag_mode, int ver,
3533 int cid0_len, int cid1_len )
Hanno Beckerb3268da2018-01-05 15:20:24 +00003534{
3535 /*
3536 * Test pairs of encryption and decryption with an increasing
3537 * amount of space in the record buffer - in more detail:
3538 * 1) Try to encrypt with 0, 1, 2, ... bytes available
3539 * in front of the plaintext, and expect the encryption
3540 * to succeed starting from some offset. Always keep
3541 * enough space in the end of the buffer.
3542 * 2) Try to encrypt with 0, 1, 2, ... bytes available
3543 * at the end of the plaintext, and expect the encryption
3544 * to succeed starting from some offset. Always keep
3545 * enough space at the beginning of the buffer.
3546 * 3) Try to encrypt with 0, 1, 2, ... bytes available
3547 * both at the front and end of the plaintext,
3548 * and expect the encryption to succeed starting from
3549 * some offset.
3550 *
3551 * If encryption succeeds, check that decryption succeeds
3552 * and yields the original record.
3553 */
3554
3555 mbedtls_ssl_context ssl; /* ONLY for debugging */
3556
3557 mbedtls_ssl_transform t0, t1;
Hanno Becker81e16a32019-03-01 11:21:44 +00003558 unsigned char *buf = NULL;
Hanno Beckerd856c822019-04-29 17:30:59 +01003559 size_t const buflen = 256;
Hanno Beckerb3268da2018-01-05 15:20:24 +00003560 mbedtls_record rec, rec_backup;
3561
3562 int ret;
Hanno Beckerd856c822019-04-29 17:30:59 +01003563 int mode; /* Mode 1, 2 or 3 as explained above */
3564 size_t offset; /* Available space at beginning/end/both */
3565 size_t threshold = 96; /* Maximum offset to test against */
Hanno Beckerb3268da2018-01-05 15:20:24 +00003566
Hanno Beckerd856c822019-04-29 17:30:59 +01003567 size_t default_pre_padding = 64; /* Pre-padding to use in mode 2 */
3568 size_t default_post_padding = 128; /* Post-padding to use in mode 1 */
Hanno Beckerb3268da2018-01-05 15:20:24 +00003569
3570 int seen_success; /* Indicates if in the current mode we've
3571 * already seen a successful test. */
3572
Przemyslaw Stekiel93cf4ee2022-01-19 16:18:53 +01003573 USE_PSA_INIT( );
3574
Hanno Beckerb3268da2018-01-05 15:20:24 +00003575 mbedtls_ssl_init( &ssl );
3576 mbedtls_ssl_transform_init( &t0 );
3577 mbedtls_ssl_transform_init( &t1 );
Przemyslaw Stekiel93cf4ee2022-01-19 16:18:53 +01003578 ret = build_transforms( &t0, &t1, cipher_type, hash_id,
Hanno Beckerd856c822019-04-29 17:30:59 +01003579 etm, tag_mode, ver,
3580 (size_t) cid0_len,
Przemyslaw Stekiel93cf4ee2022-01-19 16:18:53 +01003581 (size_t) cid1_len );
3582
Przemyslaw Stekiel8c010eb2022-02-03 10:44:02 +01003583 TEST_ASSERT( ret == 0 );
Hanno Beckerb3268da2018-01-05 15:20:24 +00003584
Hanno Becker3ee54212019-04-04 16:31:26 +01003585 TEST_ASSERT( ( buf = mbedtls_calloc( 1, buflen ) ) != NULL );
Hanno Beckerb3268da2018-01-05 15:20:24 +00003586
3587 for( mode=1; mode <= 3; mode++ )
3588 {
3589 seen_success = 0;
3590 for( offset=0; offset <= threshold; offset++ )
3591 {
3592 mbedtls_ssl_transform *t_dec, *t_enc;
Hanno Becker6c87b3f2019-04-29 17:24:44 +01003593 t_dec = &t0;
3594 t_enc = &t1;
Hanno Beckerb3268da2018-01-05 15:20:24 +00003595
3596 memset( rec.ctr, offset, sizeof( rec.ctr ) );
3597 rec.type = 42;
3598 rec.ver[0] = offset;
3599 rec.ver[1] = offset;
3600 rec.buf = buf;
3601 rec.buf_len = buflen;
Hanno Beckera0e20d02019-05-15 14:03:01 +01003602#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
Hanno Beckerd856c822019-04-29 17:30:59 +01003603 rec.cid_len = 0;
Hanno Beckera0e20d02019-05-15 14:03:01 +01003604#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
Hanno Beckerb3268da2018-01-05 15:20:24 +00003605
3606 switch( mode )
3607 {
3608 case 1: /* Space in the beginning */
3609 rec.data_offset = offset;
3610 rec.data_len = buflen - offset - default_post_padding;
3611 break;
3612
3613 case 2: /* Space in the end */
3614 rec.data_offset = default_pre_padding;
3615 rec.data_len = buflen - default_pre_padding - offset;
3616 break;
3617
3618 case 3: /* Space in the beginning and end */
3619 rec.data_offset = offset;
3620 rec.data_len = buflen - 2 * offset;
3621 break;
3622
3623 default:
3624 TEST_ASSERT( 0 );
3625 break;
3626 }
3627
3628 memset( rec.buf + rec.data_offset, 42, rec.data_len );
3629
3630 /* Make a copy for later comparison */
3631 rec_backup = rec;
3632
3633 /* Encrypt record */
Ronald Cron6c5bd7f2020-06-10 14:08:26 +02003634 ret = mbedtls_ssl_encrypt_buf( &ssl, t_enc, &rec,
3635 mbedtls_test_rnd_std_rand, NULL );
Hanno Beckerb3268da2018-01-05 15:20:24 +00003636
3637 if( ( mode == 1 || mode == 2 ) && seen_success )
3638 {
3639 TEST_ASSERT( ret == 0 );
3640 }
3641 else
3642 {
3643 TEST_ASSERT( ret == 0 || ret == MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL );
3644 if( ret == 0 )
3645 seen_success = 1;
3646 }
3647
3648 if( ret != 0 )
3649 continue;
3650
Hanno Beckerb2713ab2020-05-07 14:54:22 +01003651#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
3652 if( rec.cid_len != 0 )
3653 {
3654 /* DTLS 1.2 + CID hides the real content type and
3655 * uses a special CID content type in the protected
3656 * record. Double-check this. */
3657 TEST_ASSERT( rec.type == MBEDTLS_SSL_MSG_CID );
3658 }
3659#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
3660
Ronald Cron6f135e12021-12-08 16:57:54 +01003661#if defined(MBEDTLS_SSL_PROTO_TLS1_3)
Hanno Beckerb2713ab2020-05-07 14:54:22 +01003662 if( t_enc->minor_ver == MBEDTLS_SSL_MINOR_VERSION_4 )
3663 {
3664 /* TLS 1.3 hides the real content type and
3665 * always uses Application Data as the content type
3666 * for protected records. Double-check this. */
3667 TEST_ASSERT( rec.type == MBEDTLS_SSL_MSG_APPLICATION_DATA );
3668 }
Ronald Cron6f135e12021-12-08 16:57:54 +01003669#endif /* MBEDTLS_SSL_PROTO_TLS1_3 */
Hanno Beckerb2713ab2020-05-07 14:54:22 +01003670
Hanno Beckerb3268da2018-01-05 15:20:24 +00003671 /* Decrypt record with t_dec */
3672 TEST_ASSERT( mbedtls_ssl_decrypt_buf( &ssl, t_dec, &rec ) == 0 );
3673
3674 /* Compare results */
3675 TEST_ASSERT( rec.type == rec_backup.type );
3676 TEST_ASSERT( memcmp( rec.ctr, rec_backup.ctr, 8 ) == 0 );
3677 TEST_ASSERT( rec.ver[0] == rec_backup.ver[0] );
3678 TEST_ASSERT( rec.ver[1] == rec_backup.ver[1] );
3679 TEST_ASSERT( rec.data_len == rec_backup.data_len );
3680 TEST_ASSERT( rec.data_offset == rec_backup.data_offset );
3681 TEST_ASSERT( memcmp( rec.buf + rec.data_offset,
3682 rec_backup.buf + rec_backup.data_offset,
3683 rec.data_len ) == 0 );
3684 }
3685
3686 TEST_ASSERT( seen_success == 1 );
3687 }
3688
Hanno Becker81e16a32019-03-01 11:21:44 +00003689exit:
3690
Hanno Beckerb3268da2018-01-05 15:20:24 +00003691 /* Cleanup */
3692 mbedtls_ssl_free( &ssl );
3693 mbedtls_ssl_transform_free( &t0 );
3694 mbedtls_ssl_transform_free( &t1 );
3695
Hanno Becker3ee54212019-04-04 16:31:26 +01003696 mbedtls_free( buf );
Przemyslaw Stekiel93cf4ee2022-01-19 16:18:53 +01003697 USE_PSA_DONE( );
Hanno Beckerb3268da2018-01-05 15:20:24 +00003698}
3699/* END_CASE */
Ron Eldor824ad7b2019-05-13 14:09:00 +03003700
Przemyslaw Stekielf4facef2022-02-02 21:31:04 +01003701/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CBC:MBEDTLS_AES_C:MBEDTLS_SSL_PROTO_TLS1_2 */
Manuel Pégourié-Gonnard0ac01a12020-07-03 12:49:10 +02003702void ssl_decrypt_non_etm_cbc( int cipher_type, int hash_id, int trunc_hmac,
Manuel Pégourié-Gonnard864abbf2020-07-21 10:37:14 +02003703 int length_selector )
Manuel Pégourié-Gonnard0ac01a12020-07-03 12:49:10 +02003704{
3705 /*
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003706 * Test record decryption for CBC without EtM, focused on the verification
3707 * of padding and MAC.
Manuel Pégourié-Gonnard0ac01a12020-07-03 12:49:10 +02003708 *
TRodziewicz299510e2021-07-09 16:55:11 +02003709 * Actually depends on TLS 1.2 and either AES, ARIA or Camellia, but since
3710 * the test framework doesn't support alternation in dependency statements,
3711 * just depend on AES.
Manuel Pégourié-Gonnard864abbf2020-07-21 10:37:14 +02003712 *
3713 * The length_selector argument is interpreted as follows:
3714 * - if it's -1, the plaintext length is 0 and minimal padding is applied
3715 * - if it's -2, the plaintext length is 0 and maximal padding is applied
3716 * - otherwise it must be in [0, 255] and is padding_length from RFC 5246:
3717 * it's the length of the rest of the padding, that is, excluding the
3718 * byte that encodes the length. The minimal non-zero plaintext length
3719 * that gives this padding_length is automatically selected.
Manuel Pégourié-Gonnard0ac01a12020-07-03 12:49:10 +02003720 */
3721 mbedtls_ssl_context ssl; /* ONLY for debugging */
3722 mbedtls_ssl_transform t0, t1;
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003723 mbedtls_record rec, rec_save;
3724 unsigned char *buf = NULL, *buf_save = NULL;
Manuel Pégourié-Gonnard0ac01a12020-07-03 12:49:10 +02003725 size_t buflen, olen = 0;
Manuel Pégourié-Gonnard864abbf2020-07-21 10:37:14 +02003726 size_t plaintext_len, block_size, i;
Manuel Pégourié-Gonnarde55653f2020-07-22 11:42:57 +02003727 unsigned char padlen; /* excluding the padding_length byte */
Manuel Pégourié-Gonnard0ac01a12020-07-03 12:49:10 +02003728 unsigned char add_data[13];
3729 unsigned char mac[MBEDTLS_MD_MAX_SIZE];
Neil Armstrongcf8841a2022-02-24 11:17:45 +01003730#if defined(MBEDTLS_USE_PSA_CRYPTO)
3731 psa_mac_operation_t operation = PSA_MAC_OPERATION_INIT;
3732 size_t sign_mac_length = 0;
3733#endif
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003734 int exp_ret;
Przemyslaw Stekiel93cf4ee2022-01-19 16:18:53 +01003735 int ret;
Manuel Pégourié-Gonnard4adc04a2020-07-16 10:00:48 +02003736 const unsigned char pad_max_len = 255; /* Per the standard */
Manuel Pégourié-Gonnard0ac01a12020-07-03 12:49:10 +02003737
Przemyslaw Stekiel93cf4ee2022-01-19 16:18:53 +01003738 USE_PSA_INIT( );
3739
Manuel Pégourié-Gonnard0ac01a12020-07-03 12:49:10 +02003740 mbedtls_ssl_init( &ssl );
3741 mbedtls_ssl_transform_init( &t0 );
3742 mbedtls_ssl_transform_init( &t1 );
3743
3744 /* Set up transforms with dummy keys */
Przemyslaw Stekiel93cf4ee2022-01-19 16:18:53 +01003745 ret = build_transforms( &t0, &t1, cipher_type, hash_id,
Manuel Pégourié-Gonnard0ac01a12020-07-03 12:49:10 +02003746 0, trunc_hmac,
3747 MBEDTLS_SSL_MINOR_VERSION_3,
Przemyslaw Stekiel93cf4ee2022-01-19 16:18:53 +01003748 0 , 0 );
Manuel Pégourié-Gonnard0ac01a12020-07-03 12:49:10 +02003749
Przemyslaw Stekiel4a36dd32022-01-25 00:43:58 +01003750 TEST_ASSERT( ret == 0 );
3751
Manuel Pégourié-Gonnard864abbf2020-07-21 10:37:14 +02003752 /* Determine padding/plaintext length */
3753 TEST_ASSERT( length_selector >= -2 && length_selector <= 255 );
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003754 block_size = t0.ivlen;
Manuel Pégourié-Gonnard864abbf2020-07-21 10:37:14 +02003755 if( length_selector < 0 )
3756 {
3757 plaintext_len = 0;
3758
Manuel Pégourié-Gonnarde55653f2020-07-22 11:42:57 +02003759 /* Minimal padding
3760 * The +1 is for the padding_length byte, not counted in padlen. */
Manuel Pégourié-Gonnard864abbf2020-07-21 10:37:14 +02003761 padlen = block_size - ( t0.maclen + 1 ) % block_size;
3762
3763 /* Maximal padding? */
3764 if( length_selector == -2 )
3765 padlen += block_size * ( ( pad_max_len - padlen ) / block_size );
3766 }
3767 else
3768 {
3769 padlen = length_selector;
3770
Manuel Pégourié-Gonnarde55653f2020-07-22 11:42:57 +02003771 /* Minimal non-zero plaintext_length giving desired padding.
3772 * The +1 is for the padding_length byte, not counted in padlen. */
Manuel Pégourié-Gonnard864abbf2020-07-21 10:37:14 +02003773 plaintext_len = block_size - ( padlen + t0.maclen + 1 ) % block_size;
3774 }
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003775
Manuel Pégourié-Gonnard0ac01a12020-07-03 12:49:10 +02003776 /* Prepare a buffer for record data */
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003777 buflen = block_size
Manuel Pégourié-Gonnard0ac01a12020-07-03 12:49:10 +02003778 + plaintext_len
3779 + t0.maclen
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003780 + padlen + 1;
Manuel Pégourié-Gonnard0ac01a12020-07-03 12:49:10 +02003781 ASSERT_ALLOC( buf, buflen );
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003782 ASSERT_ALLOC( buf_save, buflen );
Manuel Pégourié-Gonnard0ac01a12020-07-03 12:49:10 +02003783
3784 /* Prepare a dummy record header */
3785 memset( rec.ctr, 0, sizeof( rec.ctr ) );
3786 rec.type = MBEDTLS_SSL_MSG_APPLICATION_DATA;
3787 rec.ver[0] = MBEDTLS_SSL_MAJOR_VERSION_3;
3788 rec.ver[1] = MBEDTLS_SSL_MINOR_VERSION_3;
3789#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
3790 rec.cid_len = 0;
3791#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
3792
3793 /* Prepare dummy record content */
3794 rec.buf = buf;
3795 rec.buf_len = buflen;
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003796 rec.data_offset = block_size;
Manuel Pégourié-Gonnard0ac01a12020-07-03 12:49:10 +02003797 rec.data_len = plaintext_len;
3798 memset( rec.buf + rec.data_offset, 42, rec.data_len );
3799
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003800 /* Serialized version of record header for MAC purposes */
Manuel Pégourié-Gonnard0ac01a12020-07-03 12:49:10 +02003801 memcpy( add_data, rec.ctr, 8 );
3802 add_data[8] = rec.type;
3803 add_data[9] = rec.ver[0];
3804 add_data[10] = rec.ver[1];
3805 add_data[11] = ( rec.data_len >> 8 ) & 0xff;
3806 add_data[12] = ( rec.data_len >> 0 ) & 0xff;
3807
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003808 /* Set dummy IV */
3809 memset( t0.iv_enc, 0x55, t0.ivlen );
3810 memcpy( rec.buf, t0.iv_enc, t0.ivlen );
3811
3812 /*
3813 * Prepare a pre-encryption record (with MAC and padding), and save it.
3814 */
3815
3816 /* MAC with additional data */
Neil Armstrongcf8841a2022-02-24 11:17:45 +01003817#if defined(MBEDTLS_USE_PSA_CRYPTO)
3818 TEST_EQUAL( PSA_SUCCESS, psa_mac_sign_setup( &operation,
3819 t0.psa_mac_enc,
3820 t0.psa_mac_alg ) );
3821 TEST_EQUAL( PSA_SUCCESS, psa_mac_update( &operation, add_data, 13 ) );
3822 TEST_EQUAL( PSA_SUCCESS, psa_mac_update( &operation,
3823 rec.buf + rec.data_offset,
3824 rec.data_len ) );
3825 TEST_EQUAL( PSA_SUCCESS, psa_mac_sign_finish( &operation,
3826 mac, MBEDTLS_MD_MAX_SIZE,
3827 &sign_mac_length ) );
3828#else
Manuel Pégourié-Gonnard0ac01a12020-07-03 12:49:10 +02003829 TEST_EQUAL( 0, mbedtls_md_hmac_update( &t0.md_ctx_enc, add_data, 13 ) );
3830 TEST_EQUAL( 0, mbedtls_md_hmac_update( &t0.md_ctx_enc,
3831 rec.buf + rec.data_offset,
3832 rec.data_len ) );
3833 TEST_EQUAL( 0, mbedtls_md_hmac_finish( &t0.md_ctx_enc, mac ) );
Neil Armstrongcf8841a2022-02-24 11:17:45 +01003834#endif
Manuel Pégourié-Gonnard0ac01a12020-07-03 12:49:10 +02003835
3836 memcpy( rec.buf + rec.data_offset + rec.data_len, mac, t0.maclen );
3837 rec.data_len += t0.maclen;
3838
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003839 /* Pad */
3840 memset( rec.buf + rec.data_offset + rec.data_len, padlen, padlen + 1 );
3841 rec.data_len += padlen + 1;
Manuel Pégourié-Gonnard0ac01a12020-07-03 12:49:10 +02003842
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003843 /* Save correct pre-encryption record */
3844 rec_save = rec;
3845 rec_save.buf = buf_save;
3846 memcpy( buf_save, buf, buflen );
Manuel Pégourié-Gonnard0ac01a12020-07-03 12:49:10 +02003847
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003848 /*
3849 * Encrypt and decrypt the correct record, expecting success
3850 */
Przemyslaw Stekiel8c010eb2022-02-03 10:44:02 +01003851 TEST_EQUAL( 0, psa_cipher_encrypt_helper(&t0, t0.iv_enc, t0.ivlen,
Przemyslaw Stekielf4facef2022-02-02 21:31:04 +01003852 rec.buf + rec.data_offset, rec.data_len,
3853 rec.buf + rec.data_offset, &olen ) );
Manuel Pégourié-Gonnard0ac01a12020-07-03 12:49:10 +02003854 rec.data_offset -= t0.ivlen;
3855 rec.data_len += t0.ivlen;
3856
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003857 TEST_EQUAL( 0, mbedtls_ssl_decrypt_buf( &ssl, &t1, &rec ) );
3858
Manuel Pégourié-Gonnard0ac01a12020-07-03 12:49:10 +02003859 /*
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003860 * Modify each byte of the pre-encryption record before encrypting and
3861 * decrypting it, expecting failure every time.
Manuel Pégourié-Gonnard0ac01a12020-07-03 12:49:10 +02003862 */
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003863 for( i = block_size; i < buflen; i++ )
3864 {
Chris Jones9634bb12021-01-20 15:56:42 +00003865 mbedtls_test_set_step( i );
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003866
3867 /* Restore correct pre-encryption record */
3868 rec = rec_save;
3869 rec.buf = buf;
3870 memcpy( buf, buf_save, buflen );
3871
Manuel Pégourié-Gonnardb51f0442020-07-21 10:40:25 +02003872 /* Corrupt one byte of the data (could be plaintext, MAC or padding) */
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003873 rec.buf[i] ^= 0x01;
3874
3875 /* Encrypt */
Przemyslaw Stekiel8c010eb2022-02-03 10:44:02 +01003876 TEST_EQUAL( 0, psa_cipher_encrypt_helper(&t0, t0.iv_enc, t0.ivlen,
Przemyslaw Stekielf4facef2022-02-02 21:31:04 +01003877 rec.buf + rec.data_offset, rec.data_len,
3878 rec.buf + rec.data_offset, &olen ) );
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003879 rec.data_offset -= t0.ivlen;
3880 rec.data_len += t0.ivlen;
3881
3882 /* Decrypt and expect failure */
3883 TEST_EQUAL( MBEDTLS_ERR_SSL_INVALID_MAC,
3884 mbedtls_ssl_decrypt_buf( &ssl, &t1, &rec ) );
3885 }
3886
3887 /*
3888 * Use larger values of the padding bytes - with small buffers, this tests
3889 * the case where the announced padlen would be larger than the buffer
3890 * (and before that, than the buffer minus the size of the MAC), to make
3891 * sure our padding checking code does not perform any out-of-bounds reads
3892 * in this case. (With larger buffers, ie when the plaintext is long or
3893 * maximal length padding is used, this is less relevant but still doesn't
3894 * hurt to test.)
3895 *
3896 * (Start the loop with correct padding, just to double-check that record
3897 * saving did work, and that we're overwriting the correct bytes.)
3898 */
Manuel Pégourié-Gonnard4adc04a2020-07-16 10:00:48 +02003899 for( i = padlen; i <= pad_max_len; i++ )
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003900 {
Chris Jones9634bb12021-01-20 15:56:42 +00003901 mbedtls_test_set_step( i );
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003902
3903 /* Restore correct pre-encryption record */
3904 rec = rec_save;
3905 rec.buf = buf;
3906 memcpy( buf, buf_save, buflen );
3907
3908 /* Set padding bytes to new value */
3909 memset( buf + buflen - padlen - 1, i, padlen + 1 );
3910
3911 /* Encrypt */
Przemyslaw Stekiel8c010eb2022-02-03 10:44:02 +01003912 TEST_EQUAL( 0, psa_cipher_encrypt_helper(&t0, t0.iv_enc, t0.ivlen,
Przemyslaw Stekielf4facef2022-02-02 21:31:04 +01003913 rec.buf + rec.data_offset, rec.data_len,
3914 rec.buf + rec.data_offset, &olen ) );
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003915 rec.data_offset -= t0.ivlen;
3916 rec.data_len += t0.ivlen;
3917
3918 /* Decrypt and expect failure except the first time */
3919 exp_ret = ( i == padlen ) ? 0 : MBEDTLS_ERR_SSL_INVALID_MAC;
3920 TEST_EQUAL( exp_ret, mbedtls_ssl_decrypt_buf( &ssl, &t1, &rec ) );
3921 }
Manuel Pégourié-Gonnard0ac01a12020-07-03 12:49:10 +02003922
3923exit:
3924 mbedtls_ssl_free( &ssl );
3925 mbedtls_ssl_transform_free( &t0 );
3926 mbedtls_ssl_transform_free( &t1 );
3927 mbedtls_free( buf );
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003928 mbedtls_free( buf_save );
Przemyslaw Stekiel93cf4ee2022-01-19 16:18:53 +01003929 USE_PSA_DONE( );
Manuel Pégourié-Gonnard0ac01a12020-07-03 12:49:10 +02003930}
3931/* END_CASE */
3932
Gabor Mezeib35759d2022-02-09 16:59:11 +01003933/* BEGIN_CASE depends_on:MBEDTLS_TEST_HOOKS:MBEDTLS_SSL_PROTO_TLS1_3 */
3934void psa_hkdf_expand( int alg, char *hex_info_string,
3935 char *hex_prk_string, char *hex_okm_string )
3936{
3937 enum { OKM_LEN = 1024 };
3938 unsigned char *info = NULL;
3939 unsigned char *prk = NULL;
3940 unsigned char *okm = NULL;
3941 unsigned char *output_okm = NULL;
3942 size_t info_len, prk_len, okm_len;
3943
Gabor Mezei73812422022-02-15 16:24:58 +01003944 PSA_INIT( );
3945
Gabor Mezeib35759d2022-02-09 16:59:11 +01003946 ASSERT_ALLOC( output_okm, OKM_LEN );
3947
3948 prk = mbedtls_test_unhexify_alloc( hex_prk_string, &prk_len );
3949 info = mbedtls_test_unhexify_alloc( hex_info_string, &info_len );
3950 okm = mbedtls_test_unhexify_alloc( hex_okm_string, &okm_len );
3951 TEST_ASSERT( prk_len == PSA_HASH_LENGTH( alg ) );
3952 TEST_ASSERT( okm_len < OKM_LEN );
3953
Gabor Mezeib35759d2022-02-09 16:59:11 +01003954 PSA_ASSERT( mbedtls_psa_hkdf_expand( alg, prk, prk_len, info, info_len,
3955 output_okm, OKM_LEN ) );
3956
3957 ASSERT_COMPARE( output_okm, okm_len, okm, okm_len );
3958
3959exit:
Gabor Mezeid9170812022-02-15 16:25:27 +01003960 mbedtls_free( info );
3961 mbedtls_free( prk );
3962 mbedtls_free( okm );
3963 mbedtls_free( output_okm );
Gabor Mezeib35759d2022-02-09 16:59:11 +01003964
3965 PSA_DONE( );
3966}
3967/* END_CASE */
3968
3969/* BEGIN_CASE depends_on:MBEDTLS_TEST_HOOKS:MBEDTLS_SSL_PROTO_TLS1_3 */
3970void psa_hkdf_expand_ret( int alg, int prk_len, int okm_len, int ret )
3971{
3972 int output_ret;
3973 unsigned char *info = NULL;
3974 unsigned char *prk = NULL;
3975 unsigned char *okm = NULL;
3976 size_t info_len;
Gabor Mezeicbe5ba52022-02-17 11:52:12 +01003977 size_t i;
3978 mbedtls_svc_key_id_t *keys = NULL;
Gabor Mezeib35759d2022-02-09 16:59:11 +01003979
Gabor Mezei73812422022-02-15 16:24:58 +01003980 PSA_INIT( );
3981
Gabor Mezeib35759d2022-02-09 16:59:11 +01003982 info_len = 0;
3983
Gabor Mezei8e360252022-02-17 11:50:02 +01003984 if( prk_len > 0 )
Gabor Mezeib35759d2022-02-09 16:59:11 +01003985 ASSERT_ALLOC( prk, prk_len );
3986
Gabor Mezei8e360252022-02-17 11:50:02 +01003987 if( okm_len > 0 )
Gabor Mezeib35759d2022-02-09 16:59:11 +01003988 ASSERT_ALLOC( okm, okm_len );
3989
Gabor Mezeicbe5ba52022-02-17 11:52:12 +01003990 if( ret == PSA_ERROR_INSUFFICIENT_MEMORY )
3991 {
3992 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
3993
3994 /* Reserve all key slot to make the key import fail. */
3995 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_SIGN_MESSAGE );
3996 psa_set_key_algorithm( &attributes, alg );
3997 psa_set_key_type( &attributes, PSA_KEY_TYPE_HMAC );
3998
3999 ASSERT_ALLOC( keys, MBEDTLS_PSA_KEY_SLOT_COUNT );
4000
4001 for( i = 0; i < MBEDTLS_PSA_KEY_SLOT_COUNT; i++ )
4002 {
4003 /* Do not use the 0 value because it will be passed to
4004 mbedtls_psa_hkdf_expand */
4005 prk[0] = i + 1;
4006 keys[i] = MBEDTLS_SVC_KEY_ID_INIT;
4007 psa_import_key( &attributes, prk, prk_len, &keys[i] );
4008 }
4009
4010 /* reset prk buffer */
4011 prk[0] = 0;
4012 }
4013
Gabor Mezeib35759d2022-02-09 16:59:11 +01004014 output_ret = mbedtls_psa_hkdf_expand( alg, prk, prk_len,
4015 info, info_len,
4016 okm, okm_len );
4017 TEST_ASSERT( output_ret == ret );
4018
4019exit:
Gabor Mezeid9170812022-02-15 16:25:27 +01004020 mbedtls_free( prk );
4021 mbedtls_free( okm );
Gabor Mezeib35759d2022-02-09 16:59:11 +01004022
Gabor Mezeicbe5ba52022-02-17 11:52:12 +01004023 if( ret == PSA_ERROR_INSUFFICIENT_MEMORY )
4024 {
4025 for( i = 0; i < MBEDTLS_PSA_KEY_SLOT_COUNT; i++ )
4026 psa_destroy_key( keys[i] );
4027
4028 mbedtls_free( keys );
4029 }
4030
Gabor Mezeib35759d2022-02-09 16:59:11 +01004031 PSA_DONE( );
4032}
4033/* END_CASE */
4034
Ronald Cron6f135e12021-12-08 16:57:54 +01004035/* BEGIN_CASE depends_on:MBEDTLS_SSL_PROTO_TLS1_3 */
Xiaofei Bai746f9482021-11-12 08:53:56 +00004036void ssl_tls13_hkdf_expand_label( int hash_alg,
4037 data_t *secret,
4038 int label_idx,
4039 data_t *ctx,
4040 int desired_length,
4041 data_t *expected )
Hanno Becker39ff4922020-08-21 13:36:56 +01004042{
4043 unsigned char dst[ 100 ];
4044
Hanno Becker70d7fb02020-09-09 10:11:21 +01004045 unsigned char const *lbl = NULL;
4046 size_t lbl_len;
Xiaofei Baid25fab62021-12-02 06:36:27 +00004047#define MBEDTLS_SSL_TLS1_3_LABEL( name, string ) \
4048 if( label_idx == (int) tls13_label_ ## name ) \
4049 { \
Xiaofei Bai746f9482021-11-12 08:53:56 +00004050 lbl = mbedtls_ssl_tls13_labels.name; \
4051 lbl_len = sizeof( mbedtls_ssl_tls13_labels.name ); \
Hanno Becker70d7fb02020-09-09 10:11:21 +01004052 }
4053MBEDTLS_SSL_TLS1_3_LABEL_LIST
4054#undef MBEDTLS_SSL_TLS1_3_LABEL
4055 TEST_ASSERT( lbl != NULL );
Hanno Becker39ff4922020-08-21 13:36:56 +01004056
4057 /* Check sanity of test parameters. */
4058 TEST_ASSERT( (size_t) desired_length <= sizeof(dst) );
4059 TEST_ASSERT( (size_t) desired_length == expected->len );
4060
Xiaofei Bai746f9482021-11-12 08:53:56 +00004061 TEST_ASSERT( mbedtls_ssl_tls13_hkdf_expand_label(
Hanno Becker39ff4922020-08-21 13:36:56 +01004062 (mbedtls_md_type_t) hash_alg,
4063 secret->x, secret->len,
Hanno Becker70d7fb02020-09-09 10:11:21 +01004064 lbl, lbl_len,
Hanno Becker39ff4922020-08-21 13:36:56 +01004065 ctx->x, ctx->len,
4066 dst, desired_length ) == 0 );
4067
Hanno Beckerfb080962020-09-08 10:58:42 +01004068 ASSERT_COMPARE( dst, (size_t) desired_length,
4069 expected->x, (size_t) expected->len );
Hanno Becker39ff4922020-08-21 13:36:56 +01004070}
4071/* END_CASE */
4072
Ronald Cron6f135e12021-12-08 16:57:54 +01004073/* BEGIN_CASE depends_on:MBEDTLS_SSL_PROTO_TLS1_3 */
Xiaofei Bai746f9482021-11-12 08:53:56 +00004074void ssl_tls13_traffic_key_generation( int hash_alg,
4075 data_t *server_secret,
4076 data_t *client_secret,
4077 int desired_iv_len,
4078 int desired_key_len,
4079 data_t *expected_server_write_key,
4080 data_t *expected_server_write_iv,
4081 data_t *expected_client_write_key,
4082 data_t *expected_client_write_iv )
Hanno Becker19498f82020-08-21 13:37:08 +01004083{
4084 mbedtls_ssl_key_set keys;
4085
4086 /* Check sanity of test parameters. */
4087 TEST_ASSERT( client_secret->len == server_secret->len );
4088 TEST_ASSERT( expected_client_write_iv->len == expected_server_write_iv->len &&
4089 expected_client_write_iv->len == (size_t) desired_iv_len );
4090 TEST_ASSERT( expected_client_write_key->len == expected_server_write_key->len &&
4091 expected_client_write_key->len == (size_t) desired_key_len );
4092
Xiaofei Bai746f9482021-11-12 08:53:56 +00004093 TEST_ASSERT( mbedtls_ssl_tls13_make_traffic_keys(
Hanno Becker19498f82020-08-21 13:37:08 +01004094 (mbedtls_md_type_t) hash_alg,
4095 client_secret->x,
4096 server_secret->x,
4097 client_secret->len /* == server_secret->len */,
4098 desired_key_len, desired_iv_len,
4099 &keys ) == 0 );
4100
Hanno Beckerfb080962020-09-08 10:58:42 +01004101 ASSERT_COMPARE( keys.client_write_key,
Hanno Becker493ea7f2020-09-08 11:01:00 +01004102 keys.key_len,
Hanno Beckerfb080962020-09-08 10:58:42 +01004103 expected_client_write_key->x,
4104 (size_t) desired_key_len );
4105 ASSERT_COMPARE( keys.server_write_key,
Hanno Becker493ea7f2020-09-08 11:01:00 +01004106 keys.key_len,
Hanno Beckerfb080962020-09-08 10:58:42 +01004107 expected_server_write_key->x,
4108 (size_t) desired_key_len );
4109 ASSERT_COMPARE( keys.client_write_iv,
Hanno Becker493ea7f2020-09-08 11:01:00 +01004110 keys.iv_len,
Hanno Beckerfb080962020-09-08 10:58:42 +01004111 expected_client_write_iv->x,
4112 (size_t) desired_iv_len );
4113 ASSERT_COMPARE( keys.server_write_iv,
Hanno Becker493ea7f2020-09-08 11:01:00 +01004114 keys.iv_len,
Hanno Beckerfb080962020-09-08 10:58:42 +01004115 expected_server_write_iv->x,
4116 (size_t) desired_iv_len );
Hanno Becker19498f82020-08-21 13:37:08 +01004117}
4118/* END_CASE */
4119
Ronald Cron6f135e12021-12-08 16:57:54 +01004120/* BEGIN_CASE depends_on:MBEDTLS_SSL_PROTO_TLS1_3 */
Xiaofei Bai746f9482021-11-12 08:53:56 +00004121void ssl_tls13_derive_secret( int hash_alg,
4122 data_t *secret,
4123 int label_idx,
4124 data_t *ctx,
4125 int desired_length,
4126 int already_hashed,
4127 data_t *expected )
Hanno Beckere4849d12020-08-21 14:14:14 +01004128{
4129 unsigned char dst[ 100 ];
4130
Hanno Becker70d7fb02020-09-09 10:11:21 +01004131 unsigned char const *lbl = NULL;
4132 size_t lbl_len;
Xiaofei Baid25fab62021-12-02 06:36:27 +00004133#define MBEDTLS_SSL_TLS1_3_LABEL( name, string ) \
4134 if( label_idx == (int) tls13_label_ ## name ) \
4135 { \
Xiaofei Bai746f9482021-11-12 08:53:56 +00004136 lbl = mbedtls_ssl_tls13_labels.name; \
4137 lbl_len = sizeof( mbedtls_ssl_tls13_labels.name ); \
Hanno Becker70d7fb02020-09-09 10:11:21 +01004138 }
4139MBEDTLS_SSL_TLS1_3_LABEL_LIST
4140#undef MBEDTLS_SSL_TLS1_3_LABEL
4141 TEST_ASSERT( lbl != NULL );
4142
Hanno Beckere4849d12020-08-21 14:14:14 +01004143 /* Check sanity of test parameters. */
4144 TEST_ASSERT( (size_t) desired_length <= sizeof(dst) );
4145 TEST_ASSERT( (size_t) desired_length == expected->len );
4146
Xiaofei Bai746f9482021-11-12 08:53:56 +00004147 TEST_ASSERT( mbedtls_ssl_tls13_derive_secret(
Hanno Beckere4849d12020-08-21 14:14:14 +01004148 (mbedtls_md_type_t) hash_alg,
4149 secret->x, secret->len,
Hanno Becker70d7fb02020-09-09 10:11:21 +01004150 lbl, lbl_len,
Hanno Beckere4849d12020-08-21 14:14:14 +01004151 ctx->x, ctx->len,
4152 already_hashed,
4153 dst, desired_length ) == 0 );
4154
Hanno Beckerfb080962020-09-08 10:58:42 +01004155 ASSERT_COMPARE( dst, desired_length,
4156 expected->x, desired_length );
Hanno Beckere4849d12020-08-21 14:14:14 +01004157}
4158/* END_CASE */
4159
Ronald Cron6f135e12021-12-08 16:57:54 +01004160/* BEGIN_CASE depends_on:MBEDTLS_SSL_PROTO_TLS1_3 */
Xiaofei Bai746f9482021-11-12 08:53:56 +00004161void ssl_tls13_derive_early_secrets( int hash_alg,
4162 data_t *secret,
4163 data_t *transcript,
4164 data_t *traffic_expected,
4165 data_t *exporter_expected )
Hanno Beckera4f40a02021-05-24 06:42:11 +01004166{
Xiaofei Bai746f9482021-11-12 08:53:56 +00004167 mbedtls_ssl_tls13_early_secrets secrets;
Hanno Beckera4f40a02021-05-24 06:42:11 +01004168
4169 /* Double-check that we've passed sane parameters. */
4170 mbedtls_md_type_t md_type = (mbedtls_md_type_t) hash_alg;
4171 mbedtls_md_info_t const * const md_info = mbedtls_md_info_from_type( md_type );
4172 size_t const md_size = mbedtls_md_get_size( md_info );
4173 TEST_ASSERT( md_info != 0 &&
4174 secret->len == md_size &&
4175 transcript->len == md_size &&
4176 traffic_expected->len == md_size &&
4177 exporter_expected->len == md_size );
4178
Xiaofei Bai746f9482021-11-12 08:53:56 +00004179 TEST_ASSERT( mbedtls_ssl_tls13_derive_early_secrets(
Hanno Beckera4f40a02021-05-24 06:42:11 +01004180 md_type, secret->x, transcript->x, transcript->len,
4181 &secrets ) == 0 );
4182
4183 ASSERT_COMPARE( secrets.client_early_traffic_secret, md_size,
4184 traffic_expected->x, traffic_expected->len );
4185 ASSERT_COMPARE( secrets.early_exporter_master_secret, md_size,
4186 exporter_expected->x, exporter_expected->len );
4187}
4188/* END_CASE */
4189
Ronald Cron6f135e12021-12-08 16:57:54 +01004190/* BEGIN_CASE depends_on:MBEDTLS_SSL_PROTO_TLS1_3 */
Xiaofei Bai746f9482021-11-12 08:53:56 +00004191void ssl_tls13_derive_handshake_secrets( int hash_alg,
4192 data_t *secret,
4193 data_t *transcript,
4194 data_t *client_expected,
4195 data_t *server_expected )
Hanno Beckera4f40a02021-05-24 06:42:11 +01004196{
Xiaofei Bai746f9482021-11-12 08:53:56 +00004197 mbedtls_ssl_tls13_handshake_secrets secrets;
Hanno Beckera4f40a02021-05-24 06:42:11 +01004198
4199 /* Double-check that we've passed sane parameters. */
4200 mbedtls_md_type_t md_type = (mbedtls_md_type_t) hash_alg;
4201 mbedtls_md_info_t const * const md_info = mbedtls_md_info_from_type( md_type );
4202 size_t const md_size = mbedtls_md_get_size( md_info );
4203 TEST_ASSERT( md_info != 0 &&
4204 secret->len == md_size &&
4205 transcript->len == md_size &&
4206 client_expected->len == md_size &&
4207 server_expected->len == md_size );
4208
Xiaofei Bai746f9482021-11-12 08:53:56 +00004209 TEST_ASSERT( mbedtls_ssl_tls13_derive_handshake_secrets(
Hanno Beckera4f40a02021-05-24 06:42:11 +01004210 md_type, secret->x, transcript->x, transcript->len,
4211 &secrets ) == 0 );
4212
4213 ASSERT_COMPARE( secrets.client_handshake_traffic_secret, md_size,
4214 client_expected->x, client_expected->len );
4215 ASSERT_COMPARE( secrets.server_handshake_traffic_secret, md_size,
4216 server_expected->x, server_expected->len );
4217}
4218/* END_CASE */
4219
Ronald Cron6f135e12021-12-08 16:57:54 +01004220/* BEGIN_CASE depends_on:MBEDTLS_SSL_PROTO_TLS1_3 */
Xiaofei Bai746f9482021-11-12 08:53:56 +00004221void ssl_tls13_derive_application_secrets( int hash_alg,
4222 data_t *secret,
4223 data_t *transcript,
4224 data_t *client_expected,
4225 data_t *server_expected,
4226 data_t *exporter_expected )
Hanno Beckera4f40a02021-05-24 06:42:11 +01004227{
Xiaofei Bai746f9482021-11-12 08:53:56 +00004228 mbedtls_ssl_tls13_application_secrets secrets;
Hanno Beckera4f40a02021-05-24 06:42:11 +01004229
4230 /* Double-check that we've passed sane parameters. */
4231 mbedtls_md_type_t md_type = (mbedtls_md_type_t) hash_alg;
4232 mbedtls_md_info_t const * const md_info = mbedtls_md_info_from_type( md_type );
4233 size_t const md_size = mbedtls_md_get_size( md_info );
4234 TEST_ASSERT( md_info != 0 &&
4235 secret->len == md_size &&
4236 transcript->len == md_size &&
4237 client_expected->len == md_size &&
4238 server_expected->len == md_size &&
4239 exporter_expected->len == md_size );
4240
Xiaofei Bai746f9482021-11-12 08:53:56 +00004241 TEST_ASSERT( mbedtls_ssl_tls13_derive_application_secrets(
Hanno Beckera4f40a02021-05-24 06:42:11 +01004242 md_type, secret->x, transcript->x, transcript->len,
4243 &secrets ) == 0 );
4244
4245 ASSERT_COMPARE( secrets.client_application_traffic_secret_N, md_size,
4246 client_expected->x, client_expected->len );
4247 ASSERT_COMPARE( secrets.server_application_traffic_secret_N, md_size,
4248 server_expected->x, server_expected->len );
4249 ASSERT_COMPARE( secrets.exporter_master_secret, md_size,
4250 exporter_expected->x, exporter_expected->len );
4251}
4252/* END_CASE */
4253
Ronald Cron6f135e12021-12-08 16:57:54 +01004254/* BEGIN_CASE depends_on:MBEDTLS_SSL_PROTO_TLS1_3 */
Xiaofei Bai746f9482021-11-12 08:53:56 +00004255void ssl_tls13_derive_resumption_secrets( int hash_alg,
4256 data_t *secret,
4257 data_t *transcript,
4258 data_t *resumption_expected )
Hanno Beckera4f40a02021-05-24 06:42:11 +01004259{
Xiaofei Bai746f9482021-11-12 08:53:56 +00004260 mbedtls_ssl_tls13_application_secrets secrets;
Hanno Beckera4f40a02021-05-24 06:42:11 +01004261
4262 /* Double-check that we've passed sane parameters. */
4263 mbedtls_md_type_t md_type = (mbedtls_md_type_t) hash_alg;
4264 mbedtls_md_info_t const * const md_info = mbedtls_md_info_from_type( md_type );
4265 size_t const md_size = mbedtls_md_get_size( md_info );
4266 TEST_ASSERT( md_info != 0 &&
4267 secret->len == md_size &&
4268 transcript->len == md_size &&
4269 resumption_expected->len == md_size );
4270
Xiaofei Bai746f9482021-11-12 08:53:56 +00004271 TEST_ASSERT( mbedtls_ssl_tls13_derive_resumption_master_secret(
Hanno Beckera4f40a02021-05-24 06:42:11 +01004272 md_type, secret->x, transcript->x, transcript->len,
4273 &secrets ) == 0 );
4274
4275 ASSERT_COMPARE( secrets.resumption_master_secret, md_size,
4276 resumption_expected->x, resumption_expected->len );
4277}
4278/* END_CASE */
4279
Ronald Cron6f135e12021-12-08 16:57:54 +01004280/* BEGIN_CASE depends_on:MBEDTLS_SSL_PROTO_TLS1_3 */
Xiaofei Bai746f9482021-11-12 08:53:56 +00004281void ssl_tls13_create_psk_binder( int hash_alg,
4282 data_t *psk,
4283 int psk_type,
4284 data_t *transcript,
4285 data_t *binder_expected )
Hanno Becker55bc2c52021-05-24 06:53:52 +01004286{
4287 unsigned char binder[ MBEDTLS_MD_MAX_SIZE ];
4288
4289 /* Double-check that we've passed sane parameters. */
4290 mbedtls_md_type_t md_type = (mbedtls_md_type_t) hash_alg;
4291 mbedtls_md_info_t const * const md_info = mbedtls_md_info_from_type( md_type );
4292 size_t const md_size = mbedtls_md_get_size( md_info );
4293 TEST_ASSERT( md_info != 0 &&
4294 transcript->len == md_size &&
4295 binder_expected->len == md_size );
4296
Xiaofei Bai746f9482021-11-12 08:53:56 +00004297 TEST_ASSERT( mbedtls_ssl_tls13_create_psk_binder(
Hanno Becker55bc2c52021-05-24 06:53:52 +01004298 NULL, /* SSL context for debugging only */
4299 md_type,
4300 psk->x, psk->len,
4301 psk_type,
4302 transcript->x,
4303 binder ) == 0 );
4304
4305 ASSERT_COMPARE( binder, md_size,
4306 binder_expected->x, binder_expected->len );
4307}
4308/* END_CASE */
4309
Ronald Cron6f135e12021-12-08 16:57:54 +01004310/* BEGIN_CASE depends_on:MBEDTLS_SSL_PROTO_TLS1_3 */
Xiaofei Bai746f9482021-11-12 08:53:56 +00004311void ssl_tls13_record_protection( int ciphersuite,
4312 int endpoint,
4313 int ctr,
4314 int padding_used,
4315 data_t *server_write_key,
4316 data_t *server_write_iv,
4317 data_t *client_write_key,
4318 data_t *client_write_iv,
4319 data_t *plaintext,
4320 data_t *ciphertext )
Hanno Beckera77d0052021-03-22 15:16:33 +00004321{
4322 mbedtls_ssl_key_set keys;
4323 mbedtls_ssl_transform transform_send;
4324 mbedtls_ssl_transform transform_recv;
4325 mbedtls_record rec;
4326 unsigned char *buf = NULL;
Hanno Becker1f918782021-08-01 19:18:28 +01004327 size_t buf_len;
Hanno Beckera77d0052021-03-22 15:16:33 +00004328 int other_endpoint;
4329
Przemyslaw Stekiel93cf4ee2022-01-19 16:18:53 +01004330 USE_PSA_INIT( );
4331
Hanno Beckera77d0052021-03-22 15:16:33 +00004332 TEST_ASSERT( endpoint == MBEDTLS_SSL_IS_CLIENT ||
4333 endpoint == MBEDTLS_SSL_IS_SERVER );
4334
4335 if( endpoint == MBEDTLS_SSL_IS_SERVER )
4336 other_endpoint = MBEDTLS_SSL_IS_CLIENT;
4337 if( endpoint == MBEDTLS_SSL_IS_CLIENT )
4338 other_endpoint = MBEDTLS_SSL_IS_SERVER;
4339
4340 TEST_ASSERT( server_write_key->len == client_write_key->len );
4341 TEST_ASSERT( server_write_iv->len == client_write_iv->len );
4342
4343 memcpy( keys.client_write_key,
4344 client_write_key->x, client_write_key->len );
4345 memcpy( keys.client_write_iv,
4346 client_write_iv->x, client_write_iv->len );
4347 memcpy( keys.server_write_key,
4348 server_write_key->x, server_write_key->len );
4349 memcpy( keys.server_write_iv,
4350 server_write_iv->x, server_write_iv->len );
4351
4352 keys.key_len = server_write_key->len;
4353 keys.iv_len = server_write_iv->len;
4354
4355 mbedtls_ssl_transform_init( &transform_recv );
4356 mbedtls_ssl_transform_init( &transform_send );
4357
4358 TEST_ASSERT( mbedtls_ssl_tls13_populate_transform(
4359 &transform_send, endpoint,
4360 ciphersuite, &keys, NULL ) == 0 );
4361 TEST_ASSERT( mbedtls_ssl_tls13_populate_transform(
4362 &transform_recv, other_endpoint,
4363 ciphersuite, &keys, NULL ) == 0 );
4364
Hanno Becker1f918782021-08-01 19:18:28 +01004365 /* Make sure we have enough space in the buffer even if
4366 * we use more padding than the KAT. */
4367 buf_len = ciphertext->len + MBEDTLS_SSL_CID_TLS1_3_PADDING_GRANULARITY;
4368 ASSERT_ALLOC( buf, buf_len );
Hanno Beckera77d0052021-03-22 15:16:33 +00004369 rec.type = MBEDTLS_SSL_MSG_APPLICATION_DATA;
Hanno Becker41537452021-04-20 05:35:28 +01004370
4371 /* TLS 1.3 uses the version identifier from TLS 1.2 on the wire. */
Hanno Beckera77d0052021-03-22 15:16:33 +00004372 mbedtls_ssl_write_version( MBEDTLS_SSL_MAJOR_VERSION_3,
4373 MBEDTLS_SSL_MINOR_VERSION_3,
4374 MBEDTLS_SSL_TRANSPORT_STREAM,
4375 rec.ver );
4376
4377 /* Copy plaintext into record structure */
4378 rec.buf = buf;
Hanno Becker1f918782021-08-01 19:18:28 +01004379 rec.buf_len = buf_len;
Hanno Beckera77d0052021-03-22 15:16:33 +00004380 rec.data_offset = 0;
4381 TEST_ASSERT( plaintext->len <= ciphertext->len );
4382 memcpy( rec.buf + rec.data_offset, plaintext->x, plaintext->len );
4383 rec.data_len = plaintext->len;
4384#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
4385 rec.cid_len = 0;
4386#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
4387
4388 memset( &rec.ctr[0], 0, 8 );
4389 rec.ctr[7] = ctr;
4390
4391 TEST_ASSERT( mbedtls_ssl_encrypt_buf( NULL, &transform_send, &rec,
4392 NULL, NULL ) == 0 );
Hanno Becker1f918782021-08-01 19:18:28 +01004393
4394 if( padding_used == MBEDTLS_SSL_CID_TLS1_3_PADDING_GRANULARITY )
4395 {
4396 ASSERT_COMPARE( rec.buf + rec.data_offset, rec.data_len,
4397 ciphertext->x, ciphertext->len );
4398 }
Hanno Beckera77d0052021-03-22 15:16:33 +00004399
4400 TEST_ASSERT( mbedtls_ssl_decrypt_buf( NULL, &transform_recv, &rec ) == 0 );
4401 ASSERT_COMPARE( rec.buf + rec.data_offset, rec.data_len,
4402 plaintext->x, plaintext->len );
4403
Hanno Becker80e760e2021-03-23 06:00:21 +00004404 mbedtls_free( buf );
Hanno Beckera77d0052021-03-22 15:16:33 +00004405 mbedtls_ssl_transform_free( &transform_send );
4406 mbedtls_ssl_transform_free( &transform_recv );
Przemyslaw Stekiel93cf4ee2022-01-19 16:18:53 +01004407 USE_PSA_DONE( );
Hanno Beckera77d0052021-03-22 15:16:33 +00004408}
4409/* END_CASE */
4410
Ronald Cron6f135e12021-12-08 16:57:54 +01004411/* BEGIN_CASE depends_on:MBEDTLS_SSL_PROTO_TLS1_3 */
Xiaofei Bai746f9482021-11-12 08:53:56 +00004412void ssl_tls13_key_evolution( int hash_alg,
4413 data_t *secret,
4414 data_t *input,
4415 data_t *expected )
Hanno Becker2d2c3eb2020-08-20 14:54:24 +01004416{
4417 unsigned char secret_new[ MBEDTLS_MD_MAX_SIZE ];
4418
Xiaofei Bai746f9482021-11-12 08:53:56 +00004419 TEST_ASSERT( mbedtls_ssl_tls13_evolve_secret(
Hanno Becker2d2c3eb2020-08-20 14:54:24 +01004420 (mbedtls_md_type_t) hash_alg,
4421 secret->len ? secret->x : NULL,
4422 input->len ? input->x : NULL, input->len,
4423 secret_new ) == 0 );
4424
Hanno Beckerfb080962020-09-08 10:58:42 +01004425 ASSERT_COMPARE( secret_new, (size_t) expected->len,
4426 expected->x, (size_t) expected->len );
Hanno Becker2d2c3eb2020-08-20 14:54:24 +01004427}
4428/* END_CASE */
4429
Jerry Yu53d23e22022-02-09 16:25:09 +08004430/* BEGIN_CASE depends_on:MBEDTLS_SSL_PROTO_TLS1_2 */
Ron Eldor824ad7b2019-05-13 14:09:00 +03004431void ssl_tls_prf( int type, data_t * secret, data_t * random,
Ronald Cronac6ae352020-06-26 14:33:03 +02004432 char *label, data_t *result_str, int exp_ret )
Ron Eldor824ad7b2019-05-13 14:09:00 +03004433{
4434 unsigned char *output;
4435
Ronald Cronac6ae352020-06-26 14:33:03 +02004436 output = mbedtls_calloc( 1, result_str->len );
Ron Eldor824ad7b2019-05-13 14:09:00 +03004437 if( output == NULL )
4438 goto exit;
4439
Gilles Peskine9de97e22021-02-02 21:00:11 +01004440 USE_PSA_INIT( );
Ron Eldor6b9b1b82019-05-15 17:04:33 +03004441
Ron Eldor824ad7b2019-05-13 14:09:00 +03004442 TEST_ASSERT( mbedtls_ssl_tls_prf( type, secret->x, secret->len,
4443 label, random->x, random->len,
Ronald Cronac6ae352020-06-26 14:33:03 +02004444 output, result_str->len ) == exp_ret );
Ron Eldor824ad7b2019-05-13 14:09:00 +03004445
4446 if( exp_ret == 0 )
4447 {
Ronald Cronac6ae352020-06-26 14:33:03 +02004448 TEST_ASSERT( mbedtls_test_hexcmp( output, result_str->x,
4449 result_str->len, result_str->len ) == 0 );
Ron Eldor824ad7b2019-05-13 14:09:00 +03004450 }
4451exit:
4452
4453 mbedtls_free( output );
Gilles Peskine1f186ff2021-02-02 21:04:06 +01004454 USE_PSA_DONE( );
Ron Eldor824ad7b2019-05-13 14:09:00 +03004455}
4456/* END_CASE */
Manuel Pégourié-Gonnard6eac11b2019-05-23 09:30:55 +02004457
Manuel Pégourié-Gonnardf9deaec2019-05-24 09:41:39 +02004458/* BEGIN_CASE */
Manuel Pégourié-Gonnard686adb42019-06-03 09:55:16 +02004459void ssl_serialize_session_save_load( int ticket_len, char *crt_file )
Manuel Pégourié-Gonnardf9deaec2019-05-24 09:41:39 +02004460{
4461 mbedtls_ssl_session original, restored;
4462 unsigned char *buf = NULL;
4463 size_t len;
4464
4465 /*
4466 * Test that a save-load pair is the identity
4467 */
4468
4469 mbedtls_ssl_session_init( &original );
4470 mbedtls_ssl_session_init( &restored );
4471
4472 /* Prepare a dummy session to work on */
Hanno Beckerfadbdbb2021-07-23 06:25:48 +01004473 TEST_ASSERT( ssl_populate_session_tls12( &original, ticket_len, crt_file ) == 0 );
Manuel Pégourié-Gonnardf9deaec2019-05-24 09:41:39 +02004474
Manuel Pégourié-Gonnard686adb42019-06-03 09:55:16 +02004475 /* Serialize it */
Manuel Pégourié-Gonnardf9deaec2019-05-24 09:41:39 +02004476 TEST_ASSERT( mbedtls_ssl_session_save( &original, NULL, 0, &len )
4477 == MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL );
4478 TEST_ASSERT( ( buf = mbedtls_calloc( 1, len ) ) != NULL );
4479 TEST_ASSERT( mbedtls_ssl_session_save( &original, buf, len, &len )
4480 == 0 );
4481
Manuel Pégourié-Gonnard686adb42019-06-03 09:55:16 +02004482 /* Restore session from serialized data */
Manuel Pégourié-Gonnardf9deaec2019-05-24 09:41:39 +02004483 TEST_ASSERT( mbedtls_ssl_session_load( &restored, buf, len) == 0 );
4484
4485 /*
4486 * Make sure both session structures are identical
4487 */
4488#if defined(MBEDTLS_HAVE_TIME)
4489 TEST_ASSERT( original.start == restored.start );
4490#endif
Hanno Beckerfadbdbb2021-07-23 06:25:48 +01004491 TEST_ASSERT( original.minor_ver == restored.minor_ver );
Manuel Pégourié-Gonnardf9deaec2019-05-24 09:41:39 +02004492 TEST_ASSERT( original.ciphersuite == restored.ciphersuite );
4493 TEST_ASSERT( original.compression == restored.compression );
4494 TEST_ASSERT( original.id_len == restored.id_len );
4495 TEST_ASSERT( memcmp( original.id,
4496 restored.id, sizeof( original.id ) ) == 0 );
4497 TEST_ASSERT( memcmp( original.master,
4498 restored.master, sizeof( original.master ) ) == 0 );
4499
4500#if defined(MBEDTLS_X509_CRT_PARSE_C)
Manuel Pégourié-Gonnardee13a732019-07-29 13:00:39 +02004501#if defined(MBEDTLS_SSL_KEEP_PEER_CERTIFICATE)
Manuel Pégourié-Gonnardf9deaec2019-05-24 09:41:39 +02004502 TEST_ASSERT( ( original.peer_cert == NULL ) ==
4503 ( restored.peer_cert == NULL ) );
4504 if( original.peer_cert != NULL )
4505 {
4506 TEST_ASSERT( original.peer_cert->raw.len ==
4507 restored.peer_cert->raw.len );
4508 TEST_ASSERT( memcmp( original.peer_cert->raw.p,
4509 restored.peer_cert->raw.p,
4510 original.peer_cert->raw.len ) == 0 );
4511 }
Manuel Pégourié-Gonnardee13a732019-07-29 13:00:39 +02004512#else /* MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
4513 TEST_ASSERT( original.peer_cert_digest_type ==
4514 restored.peer_cert_digest_type );
4515 TEST_ASSERT( original.peer_cert_digest_len ==
4516 restored.peer_cert_digest_len );
4517 TEST_ASSERT( ( original.peer_cert_digest == NULL ) ==
4518 ( restored.peer_cert_digest == NULL ) );
4519 if( original.peer_cert_digest != NULL )
4520 {
4521 TEST_ASSERT( memcmp( original.peer_cert_digest,
4522 restored.peer_cert_digest,
4523 original.peer_cert_digest_len ) == 0 );
4524 }
4525#endif /* MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
4526#endif /* MBEDTLS_X509_CRT_PARSE_C */
Manuel Pégourié-Gonnardf9deaec2019-05-24 09:41:39 +02004527 TEST_ASSERT( original.verify_result == restored.verify_result );
4528
4529#if defined(MBEDTLS_SSL_SESSION_TICKETS) && defined(MBEDTLS_SSL_CLI_C)
4530 TEST_ASSERT( original.ticket_len == restored.ticket_len );
4531 if( original.ticket_len != 0 )
4532 {
4533 TEST_ASSERT( original.ticket != NULL );
4534 TEST_ASSERT( restored.ticket != NULL );
4535 TEST_ASSERT( memcmp( original.ticket,
4536 restored.ticket, original.ticket_len ) == 0 );
4537 }
4538 TEST_ASSERT( original.ticket_lifetime == restored.ticket_lifetime );
4539#endif
4540
4541#if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
4542 TEST_ASSERT( original.mfl_code == restored.mfl_code );
4543#endif
4544
Manuel Pégourié-Gonnardf9deaec2019-05-24 09:41:39 +02004545#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
4546 TEST_ASSERT( original.encrypt_then_mac == restored.encrypt_then_mac );
4547#endif
4548
4549exit:
4550 mbedtls_ssl_session_free( &original );
4551 mbedtls_ssl_session_free( &restored );
4552 mbedtls_free( buf );
4553}
4554/* END_CASE */
4555
Manuel Pégourié-Gonnardaa755832019-06-03 10:53:47 +02004556/* BEGIN_CASE */
Manuel Pégourié-Gonnard686adb42019-06-03 09:55:16 +02004557void ssl_serialize_session_load_save( int ticket_len, char *crt_file )
Manuel Pégourié-Gonnard6eac11b2019-05-23 09:30:55 +02004558{
4559 mbedtls_ssl_session session;
4560 unsigned char *buf1 = NULL, *buf2 = NULL;
4561 size_t len0, len1, len2;
4562
4563 /*
4564 * Test that a load-save pair is the identity
4565 */
4566
4567 mbedtls_ssl_session_init( &session );
4568
Manuel Pégourié-Gonnard3caa6ca2019-05-23 10:06:14 +02004569 /* Prepare a dummy session to work on */
Hanno Beckerfadbdbb2021-07-23 06:25:48 +01004570 TEST_ASSERT( ssl_populate_session_tls12( &session, ticket_len, crt_file ) == 0 );
Manuel Pégourié-Gonnard3caa6ca2019-05-23 10:06:14 +02004571
Manuel Pégourié-Gonnard686adb42019-06-03 09:55:16 +02004572 /* Get desired buffer size for serializing */
Manuel Pégourié-Gonnard6eac11b2019-05-23 09:30:55 +02004573 TEST_ASSERT( mbedtls_ssl_session_save( &session, NULL, 0, &len0 )
4574 == MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL );
4575
4576 /* Allocate first buffer */
4577 buf1 = mbedtls_calloc( 1, len0 );
4578 TEST_ASSERT( buf1 != NULL );
4579
Manuel Pégourié-Gonnard686adb42019-06-03 09:55:16 +02004580 /* Serialize to buffer and free live session */
Manuel Pégourié-Gonnard6eac11b2019-05-23 09:30:55 +02004581 TEST_ASSERT( mbedtls_ssl_session_save( &session, buf1, len0, &len1 )
4582 == 0 );
4583 TEST_ASSERT( len0 == len1 );
4584 mbedtls_ssl_session_free( &session );
4585
Manuel Pégourié-Gonnard686adb42019-06-03 09:55:16 +02004586 /* Restore session from serialized data */
Manuel Pégourié-Gonnard220403b2019-05-24 09:54:21 +02004587 TEST_ASSERT( mbedtls_ssl_session_load( &session, buf1, len1 ) == 0 );
Manuel Pégourié-Gonnard6eac11b2019-05-23 09:30:55 +02004588
Manuel Pégourié-Gonnard686adb42019-06-03 09:55:16 +02004589 /* Allocate second buffer and serialize to it */
Manuel Pégourié-Gonnard6eac11b2019-05-23 09:30:55 +02004590 buf2 = mbedtls_calloc( 1, len0 );
Manuel Pégourié-Gonnardb4079902019-05-24 09:52:10 +02004591 TEST_ASSERT( buf2 != NULL );
Manuel Pégourié-Gonnard6eac11b2019-05-23 09:30:55 +02004592 TEST_ASSERT( mbedtls_ssl_session_save( &session, buf2, len0, &len2 )
4593 == 0 );
4594
Manuel Pégourié-Gonnard686adb42019-06-03 09:55:16 +02004595 /* Make sure both serialized versions are identical */
Manuel Pégourié-Gonnard6eac11b2019-05-23 09:30:55 +02004596 TEST_ASSERT( len1 == len2 );
4597 TEST_ASSERT( memcmp( buf1, buf2, len1 ) == 0 );
4598
4599exit:
4600 mbedtls_ssl_session_free( &session );
4601 mbedtls_free( buf1 );
4602 mbedtls_free( buf2 );
4603}
4604/* END_CASE */
Manuel Pégourié-Gonnardf5fa0aa2019-05-23 10:38:11 +02004605
4606/* BEGIN_CASE */
Manuel Pégourié-Gonnard686adb42019-06-03 09:55:16 +02004607void ssl_serialize_session_save_buf_size( int ticket_len, char *crt_file )
Manuel Pégourié-Gonnardf5fa0aa2019-05-23 10:38:11 +02004608{
4609 mbedtls_ssl_session session;
4610 unsigned char *buf = NULL;
4611 size_t good_len, bad_len, test_len;
4612
4613 /*
4614 * Test that session_save() fails cleanly on small buffers
4615 */
4616
4617 mbedtls_ssl_session_init( &session );
4618
Manuel Pégourié-Gonnard686adb42019-06-03 09:55:16 +02004619 /* Prepare dummy session and get serialized size */
Hanno Beckerfadbdbb2021-07-23 06:25:48 +01004620 TEST_ASSERT( ssl_populate_session_tls12( &session, ticket_len, crt_file ) == 0 );
Manuel Pégourié-Gonnardf5fa0aa2019-05-23 10:38:11 +02004621 TEST_ASSERT( mbedtls_ssl_session_save( &session, NULL, 0, &good_len )
4622 == MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL );
4623
4624 /* Try all possible bad lengths */
4625 for( bad_len = 1; bad_len < good_len; bad_len++ )
4626 {
4627 /* Allocate exact size so that asan/valgrind can detect any overwrite */
4628 mbedtls_free( buf );
4629 TEST_ASSERT( ( buf = mbedtls_calloc( 1, bad_len ) ) != NULL );
4630 TEST_ASSERT( mbedtls_ssl_session_save( &session, buf, bad_len,
4631 &test_len )
4632 == MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL );
4633 TEST_ASSERT( test_len == good_len );
4634 }
4635
4636exit:
4637 mbedtls_ssl_session_free( &session );
4638 mbedtls_free( buf );
4639}
4640/* END_CASE */
Manuel Pégourié-Gonnarda3d831b2019-05-23 12:28:45 +02004641
4642/* BEGIN_CASE */
Manuel Pégourié-Gonnard686adb42019-06-03 09:55:16 +02004643void ssl_serialize_session_load_buf_size( int ticket_len, char *crt_file )
Manuel Pégourié-Gonnarda3d831b2019-05-23 12:28:45 +02004644{
4645 mbedtls_ssl_session session;
4646 unsigned char *good_buf = NULL, *bad_buf = NULL;
4647 size_t good_len, bad_len;
4648
4649 /*
4650 * Test that session_load() fails cleanly on small buffers
4651 */
4652
4653 mbedtls_ssl_session_init( &session );
4654
Manuel Pégourié-Gonnard686adb42019-06-03 09:55:16 +02004655 /* Prepare serialized session data */
Hanno Beckerfadbdbb2021-07-23 06:25:48 +01004656 TEST_ASSERT( ssl_populate_session_tls12( &session, ticket_len, crt_file ) == 0 );
Manuel Pégourié-Gonnarda3d831b2019-05-23 12:28:45 +02004657 TEST_ASSERT( mbedtls_ssl_session_save( &session, NULL, 0, &good_len )
4658 == MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL );
4659 TEST_ASSERT( ( good_buf = mbedtls_calloc( 1, good_len ) ) != NULL );
4660 TEST_ASSERT( mbedtls_ssl_session_save( &session, good_buf, good_len,
4661 &good_len ) == 0 );
4662 mbedtls_ssl_session_free( &session );
4663
4664 /* Try all possible bad lengths */
4665 for( bad_len = 0; bad_len < good_len; bad_len++ )
4666 {
4667 /* Allocate exact size so that asan/valgrind can detect any overread */
4668 mbedtls_free( bad_buf );
4669 bad_buf = mbedtls_calloc( 1, bad_len ? bad_len : 1 );
4670 TEST_ASSERT( bad_buf != NULL );
4671 memcpy( bad_buf, good_buf, bad_len );
4672
4673 TEST_ASSERT( mbedtls_ssl_session_load( &session, bad_buf, bad_len )
4674 == MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
4675 }
4676
4677exit:
4678 mbedtls_ssl_session_free( &session );
4679 mbedtls_free( good_buf );
4680 mbedtls_free( bad_buf );
4681}
4682/* END_CASE */
Hanno Becker861d0bb2019-05-21 16:39:30 +01004683
Hanno Becker363b6462019-05-29 12:44:28 +01004684/* BEGIN_CASE */
4685void ssl_session_serialize_version_check( int corrupt_major,
Hanno Becker861d0bb2019-05-21 16:39:30 +01004686 int corrupt_minor,
4687 int corrupt_patch,
4688 int corrupt_config )
4689{
Hanno Becker363b6462019-05-29 12:44:28 +01004690 unsigned char serialized_session[ 2048 ];
4691 size_t serialized_session_len;
Hanno Beckerfe1275e2019-05-29 12:45:21 +01004692 unsigned cur_byte;
Hanno Becker861d0bb2019-05-21 16:39:30 +01004693 mbedtls_ssl_session session;
Hanno Beckerfe1275e2019-05-29 12:45:21 +01004694 uint8_t should_corrupt_byte[] = { corrupt_major == 1,
4695 corrupt_minor == 1,
4696 corrupt_patch == 1,
4697 corrupt_config == 1,
4698 corrupt_config == 1 };
4699
Hanno Becker861d0bb2019-05-21 16:39:30 +01004700 mbedtls_ssl_session_init( &session );
Paul Elliott46a6c202021-12-09 18:16:13 +00004701 TEST_ASSERT( ssl_populate_session_tls12( &session, 0, NULL ) == 0 );
Hanno Becker861d0bb2019-05-21 16:39:30 +01004702
Hanno Beckerfe1275e2019-05-29 12:45:21 +01004703 /* Infer length of serialized session. */
Hanno Becker861d0bb2019-05-21 16:39:30 +01004704 TEST_ASSERT( mbedtls_ssl_session_save( &session,
Hanno Becker363b6462019-05-29 12:44:28 +01004705 serialized_session,
4706 sizeof( serialized_session ),
4707 &serialized_session_len ) == 0 );
Hanno Becker861d0bb2019-05-21 16:39:30 +01004708
Hanno Beckerfe1275e2019-05-29 12:45:21 +01004709 mbedtls_ssl_session_free( &session );
Hanno Becker861d0bb2019-05-21 16:39:30 +01004710
Hanno Beckerfe1275e2019-05-29 12:45:21 +01004711 /* Without any modification, we should be able to successfully
Hanno Becker363b6462019-05-29 12:44:28 +01004712 * de-serialize the session - double-check that. */
Hanno Becker861d0bb2019-05-21 16:39:30 +01004713 TEST_ASSERT( mbedtls_ssl_session_load( &session,
Hanno Becker363b6462019-05-29 12:44:28 +01004714 serialized_session,
4715 serialized_session_len ) == 0 );
Hanno Becker861d0bb2019-05-21 16:39:30 +01004716 mbedtls_ssl_session_free( &session );
4717
Hanno Beckerfe1275e2019-05-29 12:45:21 +01004718 /* Go through the bytes in the serialized session header and
4719 * corrupt them bit-by-bit. */
4720 for( cur_byte = 0; cur_byte < sizeof( should_corrupt_byte ); cur_byte++ )
Hanno Becker861d0bb2019-05-21 16:39:30 +01004721 {
Hanno Beckerfe1275e2019-05-29 12:45:21 +01004722 int cur_bit;
4723 unsigned char * const byte = &serialized_session[ cur_byte ];
4724
4725 if( should_corrupt_byte[ cur_byte ] == 0 )
4726 continue;
4727
4728 for( cur_bit = 0; cur_bit < CHAR_BIT; cur_bit++ )
4729 {
4730 unsigned char const corrupted_bit = 0x1u << cur_bit;
4731 /* Modify a single bit in the serialized session. */
4732 *byte ^= corrupted_bit;
4733
4734 /* Attempt to deserialize */
4735 TEST_ASSERT( mbedtls_ssl_session_load( &session,
4736 serialized_session,
4737 serialized_session_len ) ==
Hanno Beckerf9b33032019-06-03 12:58:39 +01004738 MBEDTLS_ERR_SSL_VERSION_MISMATCH );
Hanno Beckerfe1275e2019-05-29 12:45:21 +01004739
4740 /* Undo the change */
4741 *byte ^= corrupted_bit;
4742 }
Hanno Becker861d0bb2019-05-21 16:39:30 +01004743 }
4744
Hanno Becker861d0bb2019-05-21 16:39:30 +01004745}
4746/* END_CASE */
Piotr Nowicki2a1f1782020-01-13 09:42:10 +01004747
Manuel Pégourié-Gonnardd12402f2020-05-20 10:34:25 +02004748/* BEGIN_CASE depends_on:MBEDTLS_X509_CRT_PARSE_C:MBEDTLS_RSA_C:MBEDTLS_ECP_DP_SECP384R1_ENABLED:!MBEDTLS_USE_PSA_CRYPTO:MBEDTLS_PKCS1_V15:MBEDTLS_ENTROPY_C:MBEDTLS_ENTROPY_C:MBEDTLS_CTR_DRBG_C */
Piotr Nowicki2a1f1782020-01-13 09:42:10 +01004749void mbedtls_endpoint_sanity( int endpoint_type )
4750{
4751 enum { BUFFSIZE = 1024 };
4752 mbedtls_endpoint ep;
4753 int ret = -1;
4754
Andrzej Kurek15daf502020-02-12 09:17:52 -05004755 ret = mbedtls_endpoint_init( NULL, endpoint_type, MBEDTLS_PK_RSA,
4756 NULL, NULL, NULL );
Piotr Nowicki2a1f1782020-01-13 09:42:10 +01004757 TEST_ASSERT( MBEDTLS_ERR_SSL_BAD_INPUT_DATA == ret );
4758
Andrzej Kurekb2980742020-02-02 19:25:26 -05004759 ret = mbedtls_endpoint_certificate_init( NULL, MBEDTLS_PK_RSA );
Piotr Nowicki2a1f1782020-01-13 09:42:10 +01004760 TEST_ASSERT( MBEDTLS_ERR_SSL_BAD_INPUT_DATA == ret );
4761
Andrzej Kurek15daf502020-02-12 09:17:52 -05004762 ret = mbedtls_endpoint_init( &ep, endpoint_type, MBEDTLS_PK_RSA,
4763 NULL, NULL, NULL );
Piotr Nowicki2a1f1782020-01-13 09:42:10 +01004764 TEST_ASSERT( ret == 0 );
4765
4766exit:
Andrzej Kurek15daf502020-02-12 09:17:52 -05004767 mbedtls_endpoint_free( &ep, NULL );
Piotr Nowicki2a1f1782020-01-13 09:42:10 +01004768}
4769/* END_CASE */
4770
Manuel Pégourié-Gonnardd12402f2020-05-20 10:34:25 +02004771/* BEGIN_CASE depends_on:MBEDTLS_X509_CRT_PARSE_C:MBEDTLS_RSA_C:MBEDTLS_ECP_DP_SECP384R1_ENABLED:!MBEDTLS_USE_PSA_CRYPTO:MBEDTLS_PKCS1_V15:MBEDTLS_ENTROPY_C:MBEDTLS_ENTROPY_C:MBEDTLS_CTR_DRBG_C */
Piotr Nowicki2a1f1782020-01-13 09:42:10 +01004772void move_handshake_to_state(int endpoint_type, int state, int need_pass)
4773{
4774 enum { BUFFSIZE = 1024 };
4775 mbedtls_endpoint base_ep, second_ep;
4776 int ret = -1;
4777
Andrzej Kurek15daf502020-02-12 09:17:52 -05004778 ret = mbedtls_endpoint_init( &base_ep, endpoint_type, MBEDTLS_PK_RSA,
4779 NULL, NULL, NULL );
Piotr Nowicki2a1f1782020-01-13 09:42:10 +01004780 TEST_ASSERT( ret == 0 );
4781
4782 ret = mbedtls_endpoint_init( &second_ep,
4783 ( endpoint_type == MBEDTLS_SSL_IS_SERVER ) ?
Andrzej Kurekb2980742020-02-02 19:25:26 -05004784 MBEDTLS_SSL_IS_CLIENT : MBEDTLS_SSL_IS_SERVER,
Andrzej Kurek15daf502020-02-12 09:17:52 -05004785 MBEDTLS_PK_RSA, NULL, NULL, NULL );
Piotr Nowicki2a1f1782020-01-13 09:42:10 +01004786 TEST_ASSERT( ret == 0 );
4787
4788 ret = mbedtls_mock_socket_connect( &(base_ep.socket),
4789 &(second_ep.socket),
4790 BUFFSIZE );
4791 TEST_ASSERT( ret == 0 );
4792
4793 ret = mbedtls_move_handshake_to_state( &(base_ep.ssl),
4794 &(second_ep.ssl),
4795 state );
4796 if( need_pass )
4797 {
4798 TEST_ASSERT( ret == 0 );
4799 TEST_ASSERT( base_ep.ssl.state == state );
4800 }
4801 else
4802 {
4803 TEST_ASSERT( ret != 0 );
4804 TEST_ASSERT( base_ep.ssl.state != state );
4805 }
4806
4807exit:
Andrzej Kurek15daf502020-02-12 09:17:52 -05004808 mbedtls_endpoint_free( &base_ep, NULL );
4809 mbedtls_endpoint_free( &second_ep, NULL );
Piotr Nowicki2a1f1782020-01-13 09:42:10 +01004810}
4811/* END_CASE */
Andrzej Kurekf40daa32020-02-04 09:00:01 -05004812
Neil Armstrong46a17602022-02-23 15:11:16 +01004813/* BEGIN_CASE depends_on:MBEDTLS_X509_CRT_PARSE_C:MBEDTLS_PKCS1_V15:MBEDTLS_RSA_C:MBEDTLS_ECP_DP_SECP384R1_ENABLED:MBEDTLS_ENTROPY_C:MBEDTLS_CTR_DRBG_C */
Paul Elliottc8570442020-04-15 17:00:50 +01004814void handshake_version( int dtls, int client_min_version, int client_max_version,
4815 int server_min_version, int server_max_version,
4816 int expected_negotiated_version )
Andrzej Kurekf40daa32020-02-04 09:00:01 -05004817{
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05004818 handshake_test_options options;
4819 init_handshake_options( &options );
Andrzej Kurekda2b6782020-02-12 07:56:36 -05004820
Paul Elliottc8570442020-04-15 17:00:50 +01004821 options.client_min_version = client_min_version;
4822 options.client_max_version = client_max_version;
4823 options.server_min_version = server_min_version;
4824 options.server_max_version = server_max_version;
4825
4826 options.expected_negotiated_version = expected_negotiated_version;
4827
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05004828 options.dtls = dtls;
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05004829 perform_handshake( &options );
Andrzej Kurekf40daa32020-02-04 09:00:01 -05004830
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05004831 /* The goto below is used to avoid an "unused label" warning.*/
4832 goto exit;
4833}
4834/* END_CASE */
Andrzej Kurek9e9efdc2020-02-26 05:25:23 -05004835
Neil Armstrong46a17602022-02-23 15:11:16 +01004836/* BEGIN_CASE depends_on:MBEDTLS_X509_CRT_PARSE_C:MBEDTLS_PKCS1_V15:MBEDTLS_SSL_PROTO_TLS1_2:MBEDTLS_ENTROPY_C:MBEDTLS_CTR_DRBG_C */
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05004837void handshake_psk_cipher( char* cipher, int pk_alg, data_t *psk_str, int dtls )
4838{
4839 handshake_test_options options;
4840 init_handshake_options( &options );
Andrzej Kurekf40daa32020-02-04 09:00:01 -05004841
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05004842 options.cipher = cipher;
4843 options.dtls = dtls;
4844 options.psk_str = psk_str;
4845 options.pk_alg = pk_alg;
Andrzej Kurekcc5169c2020-02-04 09:04:56 -05004846
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05004847 perform_handshake( &options );
Andrzej Kurek316da1f2020-02-26 09:03:47 -05004848
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05004849 /* The goto below is used to avoid an "unused label" warning.*/
4850 goto exit;
4851}
4852/* END_CASE */
Andrzej Kurek316da1f2020-02-26 09:03:47 -05004853
Neil Armstrong46a17602022-02-23 15:11:16 +01004854/* BEGIN_CASE depends_on:MBEDTLS_X509_CRT_PARSE_C:MBEDTLS_PKCS1_V15:MBEDTLS_SSL_PROTO_TLS1_2:MBEDTLS_ENTROPY_C:MBEDTLS_CTR_DRBG_C */
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05004855void handshake_cipher( char* cipher, int pk_alg, int dtls )
4856{
4857 test_handshake_psk_cipher( cipher, pk_alg, NULL, dtls );
Andrzej Kurekf40daa32020-02-04 09:00:01 -05004858
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05004859 /* The goto below is used to avoid an "unused label" warning.*/
4860 goto exit;
4861}
4862/* END_CASE */
Andrzej Kurekf40daa32020-02-04 09:00:01 -05004863
Neil Armstrong46a17602022-02-23 15:11:16 +01004864/* BEGIN_CASE depends_on:MBEDTLS_X509_CRT_PARSE_C:MBEDTLS_PKCS1_V15:MBEDTLS_SSL_PROTO_TLS1_2:MBEDTLS_RSA_C:MBEDTLS_ECP_DP_SECP384R1_ENABLED:MBEDTLS_ENTROPY_C:MBEDTLS_CTR_DRBG_C */
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05004865void app_data( int mfl, int cli_msg_len, int srv_msg_len,
4866 int expected_cli_fragments,
4867 int expected_srv_fragments, int dtls )
4868{
4869 handshake_test_options options;
4870 init_handshake_options( &options );
Andrzej Kurekda2b6782020-02-12 07:56:36 -05004871
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05004872 options.mfl = mfl;
4873 options.cli_msg_len = cli_msg_len;
4874 options.srv_msg_len = srv_msg_len;
4875 options.expected_cli_fragments = expected_cli_fragments;
4876 options.expected_srv_fragments = expected_srv_fragments;
4877 options.dtls = dtls;
Andrzej Kurekda2b6782020-02-12 07:56:36 -05004878
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05004879 perform_handshake( &options );
4880 /* The goto below is used to avoid an "unused label" warning.*/
4881 goto exit;
4882}
4883/* END_CASE */
Andrzej Kurekda2b6782020-02-12 07:56:36 -05004884
Manuel Pégourié-Gonnardd12402f2020-05-20 10:34:25 +02004885/* BEGIN_CASE depends_on:MBEDTLS_X509_CRT_PARSE_C:!MBEDTLS_USE_PSA_CRYPTO:MBEDTLS_PKCS1_V15:MBEDTLS_SSL_PROTO_TLS1_2:MBEDTLS_RSA_C:MBEDTLS_ECP_DP_SECP384R1_ENABLED:MBEDTLS_ENTROPY_C:MBEDTLS_CTR_DRBG_C */
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05004886void app_data_tls( int mfl, int cli_msg_len, int srv_msg_len,
4887 int expected_cli_fragments,
4888 int expected_srv_fragments )
4889{
4890 test_app_data( mfl, cli_msg_len, srv_msg_len, expected_cli_fragments,
4891 expected_srv_fragments, 0 );
4892 /* The goto below is used to avoid an "unused label" warning.*/
4893 goto exit;
4894}
4895/* END_CASE */
Andrzej Kurekda2b6782020-02-12 07:56:36 -05004896
Manuel Pégourié-Gonnardd12402f2020-05-20 10:34:25 +02004897/* BEGIN_CASE depends_on:MBEDTLS_X509_CRT_PARSE_C:!MBEDTLS_USE_PSA_CRYPTO:MBEDTLS_PKCS1_V15:MBEDTLS_SSL_PROTO_TLS1_2:MBEDTLS_RSA_C:MBEDTLS_ECP_DP_SECP384R1_ENABLED:MBEDTLS_SSL_PROTO_DTLS:MBEDTLS_ENTROPY_C:MBEDTLS_CTR_DRBG_C */
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05004898void app_data_dtls( int mfl, int cli_msg_len, int srv_msg_len,
4899 int expected_cli_fragments,
4900 int expected_srv_fragments )
4901{
4902 test_app_data( mfl, cli_msg_len, srv_msg_len, expected_cli_fragments,
4903 expected_srv_fragments, 1 );
4904 /* The goto below is used to avoid an "unused label" warning.*/
4905 goto exit;
4906}
4907/* END_CASE */
Andrzej Kurekda2b6782020-02-12 07:56:36 -05004908
Manuel Pégourié-Gonnardd12402f2020-05-20 10:34:25 +02004909/* BEGIN_CASE depends_on:MBEDTLS_X509_CRT_PARSE_C:!MBEDTLS_USE_PSA_CRYPTO:MBEDTLS_PKCS1_V15:MBEDTLS_SSL_PROTO_TLS1_2:MBEDTLS_RSA_C:MBEDTLS_ECP_DP_SECP384R1_ENABLED:MBEDTLS_SSL_PROTO_DTLS:MBEDTLS_SSL_RENEGOTIATION:MBEDTLS_SSL_CONTEXT_SERIALIZATION:MBEDTLS_ENTROPY_C:MBEDTLS_CTR_DRBG_C */
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05004910void handshake_serialization( )
4911{
4912 handshake_test_options options;
4913 init_handshake_options( &options );
Andrzej Kurekda2b6782020-02-12 07:56:36 -05004914
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05004915 options.serialize = 1;
4916 options.dtls = 1;
4917 perform_handshake( &options );
4918 /* The goto below is used to avoid an "unused label" warning.*/
4919 goto exit;
4920}
4921/* END_CASE */
Andrzej Kurekda2b6782020-02-12 07:56:36 -05004922
Manuel Pégourié-Gonnardd12402f2020-05-20 10:34:25 +02004923/* BEGIN_CASE depends_on:MBEDTLS_X509_CRT_PARSE_C:!MBEDTLS_USE_PSA_CRYPTO:MBEDTLS_PKCS1_V15:MBEDTLS_RSA_C:MBEDTLS_ECP_DP_SECP384R1_ENABLED:MBEDTLS_DEBUG_C:MBEDTLS_SSL_MAX_FRAGMENT_LENGTH:MBEDTLS_CIPHER_MODE_CBC:MBEDTLS_ENTROPY_C:MBEDTLS_CTR_DRBG_C */
Piotr Nowickibde7ee82020-02-21 10:59:50 +01004924void handshake_fragmentation( int mfl, int expected_srv_hs_fragmentation, int expected_cli_hs_fragmentation)
4925{
4926 handshake_test_options options;
4927 log_pattern srv_pattern, cli_pattern;
4928
4929 srv_pattern.pattern = cli_pattern.pattern = "found fragmented DTLS handshake";
4930 srv_pattern.counter = 0;
4931 cli_pattern.counter = 0;
4932
4933 init_handshake_options( &options );
4934 options.dtls = 1;
4935 options.mfl = mfl;
Darryl Greenaad82f92019-12-02 10:53:11 +00004936 /* Set cipher to one using CBC so that record splitting can be tested */
4937 options.cipher = "TLS-DHE-RSA-WITH-AES-256-CBC-SHA256";
Piotr Nowickibde7ee82020-02-21 10:59:50 +01004938 options.srv_auth_mode = MBEDTLS_SSL_VERIFY_REQUIRED;
4939 options.srv_log_obj = &srv_pattern;
4940 options.cli_log_obj = &cli_pattern;
4941 options.srv_log_fun = log_analyzer;
4942 options.cli_log_fun = log_analyzer;
4943
4944 perform_handshake( &options );
4945
4946 /* Test if the server received a fragmented handshake */
4947 if( expected_srv_hs_fragmentation )
4948 {
4949 TEST_ASSERT( srv_pattern.counter >= 1 );
4950 }
4951 /* Test if the client received a fragmented handshake */
4952 if( expected_cli_hs_fragmentation )
4953 {
4954 TEST_ASSERT( cli_pattern.counter >= 1 );
4955 }
4956}
4957/* END_CASE */
4958
Manuel Pégourié-Gonnardd12402f2020-05-20 10:34:25 +02004959/* BEGIN_CASE depends_on:MBEDTLS_X509_CRT_PARSE_C:!MBEDTLS_USE_PSA_CRYPTO:MBEDTLS_PKCS1_V15:MBEDTLS_SSL_PROTO_TLS1_2:MBEDTLS_RSA_C:MBEDTLS_ECP_DP_SECP384R1_ENABLED:MBEDTLS_SSL_PROTO_DTLS:MBEDTLS_SSL_RENEGOTIATION:MBEDTLS_ENTROPY_C:MBEDTLS_CTR_DRBG_C */
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05004960void renegotiation( int legacy_renegotiation )
4961{
4962 handshake_test_options options;
4963 init_handshake_options( &options );
Andrzej Kurekda2b6782020-02-12 07:56:36 -05004964
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05004965 options.renegotiate = 1;
4966 options.legacy_renegotiation = legacy_renegotiation;
4967 options.dtls = 1;
Andrzej Kurek316da1f2020-02-26 09:03:47 -05004968
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05004969 perform_handshake( &options );
4970 /* The goto below is used to avoid an "unused label" warning.*/
4971 goto exit;
Andrzej Kurekf40daa32020-02-04 09:00:01 -05004972}
4973/* END_CASE */
Andrzej Kurek0afa2a12020-03-03 10:39:58 -05004974
Manuel Pégourié-Gonnardd12402f2020-05-20 10:34:25 +02004975/* BEGIN_CASE depends_on:MBEDTLS_X509_CRT_PARSE_C:!MBEDTLS_USE_PSA_CRYPTO:MBEDTLS_PKCS1_V15:MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH:MBEDTLS_SSL_PROTO_TLS1_2:MBEDTLS_RSA_C:MBEDTLS_ECP_DP_SECP384R1_ENABLED:MBEDTLS_ENTROPY_C:MBEDTLS_CTR_DRBG_C */
Andrzej Kurek0afa2a12020-03-03 10:39:58 -05004976void resize_buffers( int mfl, int renegotiation, int legacy_renegotiation,
Andrzej Kurek8ea68722020-04-03 06:40:47 -04004977 int serialize, int dtls, char *cipher )
Andrzej Kurek0afa2a12020-03-03 10:39:58 -05004978{
4979 handshake_test_options options;
4980 init_handshake_options( &options );
4981
4982 options.mfl = mfl;
Andrzej Kurek8ea68722020-04-03 06:40:47 -04004983 options.cipher = cipher;
Andrzej Kurek0afa2a12020-03-03 10:39:58 -05004984 options.renegotiate = renegotiation;
4985 options.legacy_renegotiation = legacy_renegotiation;
4986 options.serialize = serialize;
4987 options.dtls = dtls;
4988 options.resize_buffers = 1;
4989
4990 perform_handshake( &options );
4991 /* The goto below is used to avoid an "unused label" warning.*/
4992 goto exit;
4993}
4994/* END_CASE */
4995
Manuel Pégourié-Gonnardd12402f2020-05-20 10:34:25 +02004996/* BEGIN_CASE depends_on:MBEDTLS_X509_CRT_PARSE_C:!MBEDTLS_USE_PSA_CRYPTO:MBEDTLS_PKCS1_V15:MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH:MBEDTLS_SSL_CONTEXT_SERIALIZATION:MBEDTLS_SSL_PROTO_TLS1_2:MBEDTLS_RSA_C:MBEDTLS_ECP_DP_SECP384R1_ENABLED:MBEDTLS_SSL_PROTO_DTLS:MBEDTLS_ENTROPY_C:MBEDTLS_CTR_DRBG_C */
Andrzej Kurek0afa2a12020-03-03 10:39:58 -05004997void resize_buffers_serialize_mfl( int mfl )
4998{
Andrzej Kurek8ea68722020-04-03 06:40:47 -04004999 test_resize_buffers( mfl, 0, MBEDTLS_SSL_LEGACY_NO_RENEGOTIATION, 1, 1,
5000 (char *) "" );
Andrzej Kurek0afa2a12020-03-03 10:39:58 -05005001
5002 /* The goto below is used to avoid an "unused label" warning.*/
5003 goto exit;
5004}
5005/* END_CASE */
5006
Manuel Pégourié-Gonnardd12402f2020-05-20 10:34:25 +02005007/* BEGIN_CASE depends_on:MBEDTLS_X509_CRT_PARSE_C:!MBEDTLS_USE_PSA_CRYPTO:MBEDTLS_PKCS1_V15:MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH:MBEDTLS_SSL_RENEGOTIATION:MBEDTLS_SSL_PROTO_TLS1_2:MBEDTLS_RSA_C:MBEDTLS_ECP_DP_SECP384R1_ENABLED:MBEDTLS_ENTROPY_C:MBEDTLS_CTR_DRBG_C */
Andrzej Kurek8ea68722020-04-03 06:40:47 -04005008void resize_buffers_renegotiate_mfl( int mfl, int legacy_renegotiation,
5009 char *cipher )
Andrzej Kurek0afa2a12020-03-03 10:39:58 -05005010{
Andrzej Kurek8ea68722020-04-03 06:40:47 -04005011 test_resize_buffers( mfl, 1, legacy_renegotiation, 0, 1, cipher );
Andrzej Kurek0afa2a12020-03-03 10:39:58 -05005012
5013 /* The goto below is used to avoid an "unused label" warning.*/
5014 goto exit;
5015}
5016/* END_CASE */
Manuel Pégourié-Gonnard045f0942020-07-02 11:34:02 +02005017
Manuel Pégourié-Gonnarded0e8642020-07-21 11:20:30 +02005018/* BEGIN_CASE depends_on:MBEDTLS_SSL_SOME_SUITES_USE_TLS_CBC:MBEDTLS_TEST_HOOKS */
Manuel Pégourié-Gonnard045f0942020-07-02 11:34:02 +02005019void ssl_cf_hmac( int hash )
5020{
5021 /*
Gabor Mezei90437e32021-10-20 11:59:27 +02005022 * Test the function mbedtls_ct_hmac() against a reference
Manuel Pégourié-Gonnard045f0942020-07-02 11:34:02 +02005023 * implementation.
Manuel Pégourié-Gonnard045f0942020-07-02 11:34:02 +02005024 */
Neil Armstrong2968d302022-02-25 15:09:36 +01005025#if defined(MBEDTLS_USE_PSA_CRYPTO)
5026 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
5027 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
5028 psa_algorithm_t alg;
5029 psa_mac_operation_t operation = PSA_MAC_OPERATION_INIT;
5030#else
Manuel Pégourié-Gonnard045f0942020-07-02 11:34:02 +02005031 mbedtls_md_context_t ctx, ref_ctx;
5032 const mbedtls_md_info_t *md_info;
Neil Armstrong2968d302022-02-25 15:09:36 +01005033#endif /* MBEDTLS_USE_PSA_CRYPTO */
Manuel Pégourié-Gonnard045f0942020-07-02 11:34:02 +02005034 size_t out_len, block_size;
5035 size_t min_in_len, in_len, max_in_len, i;
5036 /* TLS additional data is 13 bytes (hence the "lucky 13" name) */
5037 unsigned char add_data[13];
5038 unsigned char ref_out[MBEDTLS_MD_MAX_SIZE];
5039 unsigned char *data = NULL;
5040 unsigned char *out = NULL;
5041 unsigned char rec_num = 0;
5042
Neil Armstrong2968d302022-02-25 15:09:36 +01005043 USE_PSA_INIT( );
5044
5045#if defined(MBEDTLS_USE_PSA_CRYPTO)
5046 alg = PSA_ALG_HMAC( mbedtls_psa_translate_md( hash ) );
5047
5048 out_len = PSA_HASH_LENGTH( alg );
5049 block_size = PSA_HASH_BLOCK_LENGTH( alg );
5050
5051 /* mbedtls_ct_hmac() requires the key to be exportable */
5052 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_EXPORT |
5053 PSA_KEY_USAGE_VERIFY_HASH );
5054 psa_set_key_algorithm( &attributes, PSA_ALG_HMAC( alg ) );
5055 psa_set_key_type( &attributes, PSA_KEY_TYPE_HMAC );
5056#else
Manuel Pégourié-Gonnard045f0942020-07-02 11:34:02 +02005057 mbedtls_md_init( &ctx );
5058 mbedtls_md_init( &ref_ctx );
5059
5060 md_info = mbedtls_md_info_from_type( hash );
5061 TEST_ASSERT( md_info != NULL );
5062 out_len = mbedtls_md_get_size( md_info );
5063 TEST_ASSERT( out_len != 0 );
5064 block_size = hash == MBEDTLS_MD_SHA384 ? 128 : 64;
Neil Armstrong2968d302022-02-25 15:09:36 +01005065#endif /* MBEDTLS_USE_PSA_CRYPTO */
Manuel Pégourié-Gonnard045f0942020-07-02 11:34:02 +02005066
5067 /* Use allocated out buffer to catch overwrites */
5068 ASSERT_ALLOC( out, out_len );
5069
Neil Armstrong2968d302022-02-25 15:09:36 +01005070#if defined(MBEDTLS_USE_PSA_CRYPTO)
5071 /* Set up dummy key */
5072 memset( ref_out, 42, sizeof( ref_out ) );
5073 TEST_EQUAL( PSA_SUCCESS, psa_import_key( &attributes,
5074 ref_out, out_len,
5075 &key ) );
5076#else
Manuel Pégourié-Gonnard045f0942020-07-02 11:34:02 +02005077 /* Set up contexts with the given hash and a dummy key */
5078 TEST_EQUAL( 0, mbedtls_md_setup( &ctx, md_info, 1 ) );
5079 TEST_EQUAL( 0, mbedtls_md_setup( &ref_ctx, md_info, 1 ) );
5080 memset( ref_out, 42, sizeof( ref_out ) );
5081 TEST_EQUAL( 0, mbedtls_md_hmac_starts( &ctx, ref_out, out_len ) );
5082 TEST_EQUAL( 0, mbedtls_md_hmac_starts( &ref_ctx, ref_out, out_len ) );
5083 memset( ref_out, 0, sizeof( ref_out ) );
Neil Armstrong2968d302022-02-25 15:09:36 +01005084#endif
Manuel Pégourié-Gonnard045f0942020-07-02 11:34:02 +02005085
5086 /*
5087 * Test all possible lengths up to a point. The difference between
5088 * max_in_len and min_in_len is at most 255, and make sure they both vary
5089 * by at least one block size.
5090 */
5091 for( max_in_len = 0; max_in_len <= 255 + block_size; max_in_len++ )
5092 {
Chris Jones9634bb12021-01-20 15:56:42 +00005093 mbedtls_test_set_step( max_in_len * 10000 );
Manuel Pégourié-Gonnardca8287c2020-07-22 10:29:39 +02005094
Manuel Pégourié-Gonnard045f0942020-07-02 11:34:02 +02005095 /* Use allocated in buffer to catch overreads */
Manuel Pégourié-Gonnardc3219002020-07-22 10:32:52 +02005096 ASSERT_ALLOC( data, max_in_len );
Manuel Pégourié-Gonnard045f0942020-07-02 11:34:02 +02005097
5098 min_in_len = max_in_len > 255 ? max_in_len - 255 : 0;
5099 for( in_len = min_in_len; in_len <= max_in_len; in_len++ )
5100 {
Chris Jones9634bb12021-01-20 15:56:42 +00005101 mbedtls_test_set_step( max_in_len * 10000 + in_len );
Manuel Pégourié-Gonnardca8287c2020-07-22 10:29:39 +02005102
Manuel Pégourié-Gonnard045f0942020-07-02 11:34:02 +02005103 /* Set up dummy data and add_data */
5104 rec_num++;
5105 memset( add_data, rec_num, sizeof( add_data ) );
5106 for( i = 0; i < in_len; i++ )
5107 data[i] = ( i & 0xff ) ^ rec_num;
5108
5109 /* Get the function's result */
Manuel Pégourié-Gonnard9670a592020-07-10 10:21:46 +02005110 TEST_CF_SECRET( &in_len, sizeof( in_len ) );
Neil Armstrong2968d302022-02-25 15:09:36 +01005111#if defined(MBEDTLS_USE_PSA_CRYPTO)
5112 TEST_EQUAL( 0, mbedtls_ct_hmac( key, PSA_ALG_HMAC( alg ),
5113 add_data, sizeof( add_data ),
5114 data, in_len,
5115 min_in_len, max_in_len,
5116 out ) );
5117#else
Gabor Mezei90437e32021-10-20 11:59:27 +02005118 TEST_EQUAL( 0, mbedtls_ct_hmac( &ctx, add_data, sizeof( add_data ),
gabor-mezei-arm9fa43ce2021-09-28 16:14:47 +02005119 data, in_len,
5120 min_in_len, max_in_len,
5121 out ) );
Neil Armstrong2968d302022-02-25 15:09:36 +01005122#endif /* MBEDTLS_USE_PSA_CRYPTO */
Manuel Pégourié-Gonnard9670a592020-07-10 10:21:46 +02005123 TEST_CF_PUBLIC( &in_len, sizeof( in_len ) );
5124 TEST_CF_PUBLIC( out, out_len );
Manuel Pégourié-Gonnard045f0942020-07-02 11:34:02 +02005125
Neil Armstrong2968d302022-02-25 15:09:36 +01005126#if defined(MBEDTLS_USE_PSA_CRYPTO)
5127 TEST_EQUAL( PSA_SUCCESS, psa_mac_verify_setup( &operation,
5128 key, alg ) );
5129 TEST_EQUAL( PSA_SUCCESS, psa_mac_update( &operation, add_data,
5130 sizeof( add_data ) ) );
5131 TEST_EQUAL( PSA_SUCCESS, psa_mac_update( &operation,
5132 data, in_len ) );
5133 TEST_EQUAL( PSA_SUCCESS, psa_mac_verify_finish( &operation,
5134 out, out_len ) );
5135#else
Manuel Pégourié-Gonnard045f0942020-07-02 11:34:02 +02005136 /* Compute the reference result */
5137 TEST_EQUAL( 0, mbedtls_md_hmac_update( &ref_ctx, add_data,
5138 sizeof( add_data ) ) );
5139 TEST_EQUAL( 0, mbedtls_md_hmac_update( &ref_ctx, data, in_len ) );
5140 TEST_EQUAL( 0, mbedtls_md_hmac_finish( &ref_ctx, ref_out ) );
5141 TEST_EQUAL( 0, mbedtls_md_hmac_reset( &ref_ctx ) );
5142
5143 /* Compare */
5144 ASSERT_COMPARE( out, out_len, ref_out, out_len );
Neil Armstrong2968d302022-02-25 15:09:36 +01005145#endif /* MBEDTLS_USE_PSA_CRYPTO */
Manuel Pégourié-Gonnard045f0942020-07-02 11:34:02 +02005146 }
5147
5148 mbedtls_free( data );
5149 data = NULL;
5150 }
5151
5152exit:
Neil Armstrong2968d302022-02-25 15:09:36 +01005153#if defined(MBEDTLS_USE_PSA_CRYPTO)
5154 psa_mac_abort( &operation );
5155 psa_destroy_key( key );
5156#else
Manuel Pégourié-Gonnard045f0942020-07-02 11:34:02 +02005157 mbedtls_md_free( &ref_ctx );
5158 mbedtls_md_free( &ctx );
Neil Armstrong2968d302022-02-25 15:09:36 +01005159#endif /* MBEDTLS_USE_PSA_CRYPTO */
Manuel Pégourié-Gonnard045f0942020-07-02 11:34:02 +02005160
5161 mbedtls_free( data );
5162 mbedtls_free( out );
Neil Armstrong2968d302022-02-25 15:09:36 +01005163
5164 USE_PSA_DONE( );
Manuel Pégourié-Gonnard045f0942020-07-02 11:34:02 +02005165}
5166/* END_CASE */
Manuel Pégourié-Gonnard7fe2c5f2020-08-18 12:02:54 +02005167
5168/* BEGIN_CASE depends_on:MBEDTLS_SSL_SOME_SUITES_USE_TLS_CBC:MBEDTLS_TEST_HOOKS */
5169void ssl_cf_memcpy_offset( int offset_min, int offset_max, int len )
5170{
5171 unsigned char *dst = NULL;
5172 unsigned char *src = NULL;
5173 size_t src_len = offset_max + len;
5174 size_t secret;
5175
5176 ASSERT_ALLOC( dst, len );
5177 ASSERT_ALLOC( src, src_len );
5178
5179 /* Fill src in a way that we can detect if we copied the right bytes */
5180 mbedtls_test_rnd_std_rand( NULL, src, src_len );
5181
5182 for( secret = offset_min; secret <= (size_t) offset_max; secret++ )
5183 {
Chris Jones9634bb12021-01-20 15:56:42 +00005184 mbedtls_test_set_step( (int) secret );
Manuel Pégourié-Gonnard7fe2c5f2020-08-18 12:02:54 +02005185
5186 TEST_CF_SECRET( &secret, sizeof( secret ) );
Gabor Mezei90437e32021-10-20 11:59:27 +02005187 mbedtls_ct_memcpy_offset( dst, src, secret,
gabor-mezei-arm9fa43ce2021-09-28 16:14:47 +02005188 offset_min, offset_max, len );
Manuel Pégourié-Gonnard7fe2c5f2020-08-18 12:02:54 +02005189 TEST_CF_PUBLIC( &secret, sizeof( secret ) );
5190 TEST_CF_PUBLIC( dst, len );
5191
5192 ASSERT_COMPARE( dst, len, src + secret, len );
5193 }
5194
5195exit:
5196 mbedtls_free( dst );
5197 mbedtls_free( src );
5198}
5199/* END_CASE */
Hanno Becker6667ffd2021-04-19 21:59:22 +01005200
5201/* BEGIN_CASE depends_on:MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED */
5202void test_multiple_psks()
5203{
5204 unsigned char psk0[10] = { 0 };
5205 unsigned char psk0_identity[] = { 'f', 'o', 'o' };
5206
5207 unsigned char psk1[10] = { 0 };
5208 unsigned char psk1_identity[] = { 'b', 'a', 'r' };
5209
5210 mbedtls_ssl_config conf;
5211
5212 mbedtls_ssl_config_init( &conf );
5213
5214 TEST_ASSERT( mbedtls_ssl_conf_psk( &conf,
5215 psk0, sizeof( psk0 ),
5216 psk0_identity, sizeof( psk0_identity ) ) == 0 );
5217 TEST_ASSERT( mbedtls_ssl_conf_psk( &conf,
5218 psk1, sizeof( psk1 ),
5219 psk1_identity, sizeof( psk1_identity ) ) ==
5220 MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE );
5221
5222exit:
5223
5224 mbedtls_ssl_config_free( &conf );
5225}
5226/* END_CASE */
5227
5228/* BEGIN_CASE depends_on:MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED:MBEDTLS_USE_PSA_CRYPTO */
5229void test_multiple_psks_opaque( int mode )
5230{
5231 /*
5232 * Mode 0: Raw PSK, then opaque PSK
5233 * Mode 1: Opaque PSK, then raw PSK
5234 * Mode 2: 2x opaque PSK
5235 */
5236
5237 unsigned char psk0_raw[10] = { 0 };
5238 unsigned char psk0_raw_identity[] = { 'f', 'o', 'o' };
5239
Andrzej Kurek03e01462022-01-03 12:53:24 +01005240 mbedtls_svc_key_id_t psk0_opaque = mbedtls_svc_key_id_make( 0x1, (psa_key_id_t) 1 );
5241
Hanno Becker6667ffd2021-04-19 21:59:22 +01005242 unsigned char psk0_opaque_identity[] = { 'f', 'o', 'o' };
5243
5244 unsigned char psk1_raw[10] = { 0 };
5245 unsigned char psk1_raw_identity[] = { 'b', 'a', 'r' };
5246
Andrzej Kurek03e01462022-01-03 12:53:24 +01005247 mbedtls_svc_key_id_t psk1_opaque = mbedtls_svc_key_id_make( 0x1, (psa_key_id_t) 2 );
5248
Hanno Becker6667ffd2021-04-19 21:59:22 +01005249 unsigned char psk1_opaque_identity[] = { 'b', 'a', 'r' };
5250
5251 mbedtls_ssl_config conf;
5252
5253 USE_PSA_INIT( );
5254 mbedtls_ssl_config_init( &conf );
5255
5256 switch( mode )
5257 {
5258 case 0:
5259
5260 TEST_ASSERT( mbedtls_ssl_conf_psk( &conf,
5261 psk0_raw, sizeof( psk0_raw ),
5262 psk0_raw_identity, sizeof( psk0_raw_identity ) )
5263 == 0 );
5264 TEST_ASSERT( mbedtls_ssl_conf_psk_opaque( &conf,
5265 psk1_opaque,
5266 psk1_opaque_identity, sizeof( psk1_opaque_identity ) )
5267 == MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE );
5268 break;
5269
5270 case 1:
5271
5272 TEST_ASSERT( mbedtls_ssl_conf_psk_opaque( &conf,
5273 psk0_opaque,
5274 psk0_opaque_identity, sizeof( psk0_opaque_identity ) )
5275 == 0 );
5276 TEST_ASSERT( mbedtls_ssl_conf_psk( &conf,
5277 psk1_raw, sizeof( psk1_raw ),
5278 psk1_raw_identity, sizeof( psk1_raw_identity ) )
5279 == MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE );
5280
5281 break;
5282
5283 case 2:
5284
5285 TEST_ASSERT( mbedtls_ssl_conf_psk_opaque( &conf,
5286 psk0_opaque,
5287 psk0_opaque_identity, sizeof( psk0_opaque_identity ) )
5288 == 0 );
5289 TEST_ASSERT( mbedtls_ssl_conf_psk_opaque( &conf,
5290 psk1_opaque,
5291 psk1_opaque_identity, sizeof( psk1_opaque_identity ) )
5292 == MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE );
5293
5294 break;
5295
5296 default:
5297 TEST_ASSERT( 0 );
5298 break;
5299 }
5300
5301exit:
5302
5303 mbedtls_ssl_config_free( &conf );
5304 USE_PSA_DONE( );
5305
5306}
5307/* END_CASE */
Brett Warren7f813d52021-10-20 23:08:38 +01005308
5309/* BEGIN_CASE depends_on:MBEDTLS_ECP_C:!MBEDTLS_DEPRECATED_REMOVED:!MBEDTLS_DEPRECATED_WARNING:MBEDTLS_ECP_DP_SECP192R1_ENABLED:MBEDTLS_ECP_DP_SECP224R1_ENABLED:MBEDTLS_ECP_DP_SECP256R1_ENABLED */
5310void conf_curve()
5311{
5312
5313 mbedtls_ecp_group_id curve_list[] = { MBEDTLS_ECP_DP_SECP192R1,
5314 MBEDTLS_ECP_DP_SECP224R1,
5315 MBEDTLS_ECP_DP_SECP256R1,
5316 MBEDTLS_ECP_DP_NONE };
5317 mbedtls_ecp_group_id iana_tls_group_list[] = { MBEDTLS_SSL_IANA_TLS_GROUP_SECP192R1,
5318 MBEDTLS_SSL_IANA_TLS_GROUP_SECP224R1,
5319 MBEDTLS_SSL_IANA_TLS_GROUP_SECP256R1,
5320 MBEDTLS_SSL_IANA_TLS_GROUP_NONE };
5321
5322 mbedtls_ssl_config conf;
5323 mbedtls_ssl_config_init( &conf );
Jerry Yubaa49342022-02-15 10:26:40 +08005324#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
Brett Warren7f813d52021-10-20 23:08:38 +01005325 mbedtls_ssl_conf_max_version( &conf, 3, 3 );
5326 mbedtls_ssl_conf_min_version( &conf, 3, 3 );
Jerry Yubaa49342022-02-15 10:26:40 +08005327#else
5328 mbedtls_ssl_conf_max_version( &conf, 3, 4 );
5329 mbedtls_ssl_conf_min_version( &conf, 3, 4 );
5330#endif
Brett Warren7f813d52021-10-20 23:08:38 +01005331 mbedtls_ssl_conf_curves( &conf, curve_list );
5332
5333 mbedtls_ssl_context ssl;
5334 mbedtls_ssl_init( &ssl );
Paul Elliott46a6c202021-12-09 18:16:13 +00005335 TEST_ASSERT( mbedtls_ssl_setup( &ssl, &conf ) == 0 );
Brett Warren7f813d52021-10-20 23:08:38 +01005336
5337 TEST_ASSERT( ssl.handshake != NULL && ssl.handshake->group_list != NULL );
5338 TEST_ASSERT( ssl.conf != NULL && ssl.conf->group_list == NULL );
5339
5340 TEST_EQUAL( ssl.handshake->group_list[ARRAY_LENGTH( iana_tls_group_list ) - 1], MBEDTLS_SSL_IANA_TLS_GROUP_NONE );
5341
5342 for( size_t i = 0; i < ARRAY_LENGTH( iana_tls_group_list ); i++ )
5343 TEST_EQUAL( iana_tls_group_list[i], ssl.handshake->group_list[i] );
5344
5345 mbedtls_ssl_free( &ssl );
5346 mbedtls_ssl_config_free( &conf );
5347}
5348/* END_CASE */
5349
5350/* BEGIN_CASE depends_on:MBEDTLS_DEPRECATED_REMOVED */
5351void conf_group()
5352{
5353 uint16_t iana_tls_group_list[] = { MBEDTLS_SSL_IANA_TLS_GROUP_SECP192R1,
5354 MBEDTLS_SSL_IANA_TLS_GROUP_SECP224R1,
5355 MBEDTLS_SSL_IANA_TLS_GROUP_SECP256R1,
5356 MBEDTLS_SSL_IANA_TLS_GROUP_NONE };
5357
5358 mbedtls_ssl_config conf;
5359 mbedtls_ssl_config_init( &conf );
5360
5361 mbedtls_ssl_conf_max_version( &conf, 3, 3 );
5362 mbedtls_ssl_conf_min_version( &conf, 3, 3 );
5363
5364 mbedtls_ssl_conf_groups( &conf, iana_tls_group_list );
5365
5366 mbedtls_ssl_context ssl;
5367 mbedtls_ssl_init( &ssl );
Paul Elliott46a6c202021-12-09 18:16:13 +00005368 TEST_ASSERT( mbedtls_ssl_setup( &ssl, &conf ) == 0 );
Brett Warren7f813d52021-10-20 23:08:38 +01005369
5370 TEST_ASSERT( ssl.conf != NULL && ssl.conf->group_list != NULL );
5371
5372 TEST_EQUAL( ssl.conf->group_list[ARRAY_LENGTH( iana_tls_group_list ) - 1], MBEDTLS_SSL_IANA_TLS_GROUP_NONE );
5373
5374 for( size_t i = 0; i < ARRAY_LENGTH( iana_tls_group_list ); i++ )
5375 TEST_EQUAL( iana_tls_group_list[i], ssl.conf->group_list[i] );
5376
5377 mbedtls_ssl_free( &ssl );
5378 mbedtls_ssl_config_free( &conf );
5379}
5380/* END_CASE */