blob: 453e8e78086fa0234689cbd639fc2a1b7ad2aa19 [file] [log] [blame]
Yanray Wang47907a42022-10-24 14:42:01 +08001/** \file ssl_helpers.c
2 *
3 * \brief Helper functions to set up a TLS connection.
4 */
5
6/*
7 * Copyright The Mbed TLS Contributors
Dave Rodgman16799db2023-11-02 19:47:20 +00008 * SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
Yanray Wang47907a42022-10-24 14:42:01 +08009 */
10
11#include <test/ssl_helpers.h>
Valerio Setti384fbde2024-01-02 13:26:40 +010012#include "mbedtls/psa_util.h"
Yanray Wange6afd912022-10-27 12:11:18 +080013
Yanray Wang4d07d1c2022-10-27 15:28:16 +080014#if defined(MBEDTLS_SSL_TLS_C)
Ronald Cron10b040f2024-02-05 09:38:09 +010015int mbedtls_test_random(void *p_rng, unsigned char *output, size_t output_len)
Yanray Wange6afd912022-10-27 12:11:18 +080016{
17 (void) p_rng;
18 for (size_t i = 0; i < output_len; i++) {
19 output[i] = rand();
20 }
21
22 return 0;
23}
Yanray Wange6afd912022-10-27 12:11:18 +080024
Yanray Wange6afd912022-10-27 12:11:18 +080025void mbedtls_test_ssl_log_analyzer(void *ctx, int level,
26 const char *file, int line,
27 const char *str)
28{
29 mbedtls_test_ssl_log_pattern *p = (mbedtls_test_ssl_log_pattern *) ctx;
30
Manuel Pégourié-Gonnard6637ef72025-02-11 13:19:45 +010031/* Change 0 to 1 for debugging of test cases that use this function. */
32#if 0
33 const char *q, *basename;
34 /* Extract basename from file */
35 for (q = basename = file; *q != '\0'; q++) {
36 if (*q == '/' || *q == '\\') {
37 basename = q + 1;
38 }
39 }
40 printf("%s:%04d: |%d| %s",
41 basename, line, level, str);
42#else
Yanray Wange6afd912022-10-27 12:11:18 +080043 (void) level;
44 (void) line;
45 (void) file;
Manuel Pégourié-Gonnard6637ef72025-02-11 13:19:45 +010046#endif
Yanray Wange6afd912022-10-27 12:11:18 +080047
48 if (NULL != p &&
49 NULL != p->pattern &&
50 NULL != strstr(str, p->pattern)) {
51 p->counter++;
52 }
53}
54
55void mbedtls_test_init_handshake_options(
56 mbedtls_test_handshake_test_options *opts)
57{
58#if defined(MBEDTLS_SSL_HANDSHAKE_WITH_CERT_ENABLED)
Ronald Cron987cf892024-03-04 10:24:27 +010059 static int rng_seed = 0xBEEF;
Yanray Wanga72bc9a2023-12-01 23:34:27 +080060
Yanray Wange6afd912022-10-27 12:11:18 +080061 srand(rng_seed);
62 rng_seed += 0xD0;
63#endif
Ronald Cronb4ad3e72024-01-26 14:57:53 +010064
65 memset(opts, 0, sizeof(*opts));
66
Yanray Wange6afd912022-10-27 12:11:18 +080067 opts->cipher = "";
68 opts->client_min_version = MBEDTLS_SSL_VERSION_UNKNOWN;
69 opts->client_max_version = MBEDTLS_SSL_VERSION_UNKNOWN;
70 opts->server_min_version = MBEDTLS_SSL_VERSION_UNKNOWN;
71 opts->server_max_version = MBEDTLS_SSL_VERSION_UNKNOWN;
Ronald Cron097ba142023-03-08 16:18:00 +010072 opts->expected_negotiated_version = MBEDTLS_SSL_VERSION_TLS1_3;
Yanray Wange6afd912022-10-27 12:11:18 +080073 opts->pk_alg = MBEDTLS_PK_RSA;
Yanray Wange6afd912022-10-27 12:11:18 +080074 opts->srv_auth_mode = MBEDTLS_SSL_VERIFY_NONE;
Yanray Wange6afd912022-10-27 12:11:18 +080075 opts->mfl = MBEDTLS_SSL_MAX_FRAG_LEN_NONE;
76 opts->cli_msg_len = 100;
77 opts->srv_msg_len = 100;
78 opts->expected_cli_fragments = 1;
79 opts->expected_srv_fragments = 1;
Yanray Wange6afd912022-10-27 12:11:18 +080080 opts->legacy_renegotiation = MBEDTLS_SSL_LEGACY_NO_RENEGOTIATION;
Yanray Wange6afd912022-10-27 12:11:18 +080081 opts->resize_buffers = 1;
Ronald Cronced99be2024-01-26 15:49:12 +010082 opts->early_data = MBEDTLS_SSL_EARLY_DATA_DISABLED;
Ronald Cron5d3036e2024-02-23 07:43:45 +010083 opts->max_early_data_size = -1;
Yanray Wange6afd912022-10-27 12:11:18 +080084#if defined(MBEDTLS_SSL_CACHE_C)
Tom Cosgrove05b2a872023-07-21 11:31:13 +010085 TEST_CALLOC(opts->cache, 1);
Yanray Wange6afd912022-10-27 12:11:18 +080086 mbedtls_ssl_cache_init(opts->cache);
Pengyu Lv5cbb93e2023-07-10 11:09:40 +080087#if defined(MBEDTLS_HAVE_TIME)
88 TEST_EQUAL(mbedtls_ssl_cache_get_timeout(opts->cache),
89 MBEDTLS_SSL_CACHE_DEFAULT_TIMEOUT);
90#endif
Yanray Wange6afd912022-10-27 12:11:18 +080091exit:
92 return;
93#endif
94}
95
96void mbedtls_test_free_handshake_options(
97 mbedtls_test_handshake_test_options *opts)
98{
99#if defined(MBEDTLS_SSL_CACHE_C)
100 mbedtls_ssl_cache_free(opts->cache);
101 mbedtls_free(opts->cache);
102#else
103 (void) opts;
104#endif
105}
106
107#if defined(MBEDTLS_TEST_HOOKS)
108static void set_chk_buf_ptr_args(
109 mbedtls_ssl_chk_buf_ptr_args *args,
110 unsigned char *cur, unsigned char *end, size_t need)
111{
112 args->cur = cur;
113 args->end = end;
114 args->need = need;
115}
116
117static void reset_chk_buf_ptr_args(mbedtls_ssl_chk_buf_ptr_args *args)
118{
119 memset(args, 0, sizeof(*args));
120}
121#endif /* MBEDTLS_TEST_HOOKS */
122
Yanray Wange6afd912022-10-27 12:11:18 +0800123void mbedtls_test_ssl_buffer_init(mbedtls_test_ssl_buffer *buf)
124{
125 memset(buf, 0, sizeof(*buf));
126}
127
Yanray Wange6afd912022-10-27 12:11:18 +0800128int mbedtls_test_ssl_buffer_setup(mbedtls_test_ssl_buffer *buf,
129 size_t capacity)
130{
131 buf->buffer = (unsigned char *) mbedtls_calloc(capacity,
132 sizeof(unsigned char));
133 if (NULL == buf->buffer) {
134 return MBEDTLS_ERR_SSL_ALLOC_FAILED;
135 }
136 buf->capacity = capacity;
137
138 return 0;
139}
140
141void mbedtls_test_ssl_buffer_free(mbedtls_test_ssl_buffer *buf)
142{
143 if (buf->buffer != NULL) {
144 mbedtls_free(buf->buffer);
145 }
146
147 memset(buf, 0, sizeof(*buf));
148}
149
Yanray Wange6afd912022-10-27 12:11:18 +0800150int mbedtls_test_ssl_buffer_put(mbedtls_test_ssl_buffer *buf,
151 const unsigned char *input, size_t input_len)
152{
153 size_t overflow = 0;
154
155 if ((buf == NULL) || (buf->buffer == NULL)) {
156 return -1;
157 }
158
159 /* Reduce input_len to a number that fits in the buffer. */
160 if ((buf->content_length + input_len) > buf->capacity) {
161 input_len = buf->capacity - buf->content_length;
162 }
163
164 if (input == NULL) {
165 return (input_len == 0) ? 0 : -1;
166 }
167
168 /* Check if the buffer has not come full circle and free space is not in
169 * the middle */
170 if (buf->start + buf->content_length < buf->capacity) {
171
172 /* Calculate the number of bytes that need to be placed at lower memory
173 * address */
174 if (buf->start + buf->content_length + input_len
175 > buf->capacity) {
176 overflow = (buf->start + buf->content_length + input_len)
177 % buf->capacity;
178 }
179
180 memcpy(buf->buffer + buf->start + buf->content_length, input,
181 input_len - overflow);
182 memcpy(buf->buffer, input + input_len - overflow, overflow);
183
184 } else {
185 /* The buffer has come full circle and free space is in the middle */
186 memcpy(buf->buffer + buf->start + buf->content_length - buf->capacity,
187 input, input_len);
188 }
189
190 buf->content_length += input_len;
Yanray Wanga8f445e2022-11-03 11:51:59 +0800191 return (input_len > INT_MAX) ? INT_MAX : (int) input_len;
Yanray Wange6afd912022-10-27 12:11:18 +0800192}
193
Yanray Wange6afd912022-10-27 12:11:18 +0800194int mbedtls_test_ssl_buffer_get(mbedtls_test_ssl_buffer *buf,
195 unsigned char *output, size_t output_len)
196{
197 size_t overflow = 0;
198
199 if ((buf == NULL) || (buf->buffer == NULL)) {
200 return -1;
201 }
202
203 if (output == NULL && output_len == 0) {
204 return 0;
205 }
206
207 if (buf->content_length < output_len) {
208 output_len = buf->content_length;
209 }
210
211 /* Calculate the number of bytes that need to be drawn from lower memory
212 * address */
213 if (buf->start + output_len > buf->capacity) {
214 overflow = (buf->start + output_len) % buf->capacity;
215 }
216
217 if (output != NULL) {
218 memcpy(output, buf->buffer + buf->start, output_len - overflow);
219 memcpy(output + output_len - overflow, buf->buffer, overflow);
220 }
221
222 buf->content_length -= output_len;
223 buf->start = (buf->start + output_len) % buf->capacity;
224
Yanray Wanga8f445e2022-11-03 11:51:59 +0800225 return (output_len > INT_MAX) ? INT_MAX : (int) output_len;
Yanray Wange6afd912022-10-27 12:11:18 +0800226}
227
Yanray Wangd19894f2023-03-16 11:47:39 +0800228int mbedtls_test_ssl_message_queue_setup(
229 mbedtls_test_ssl_message_queue *queue, size_t capacity)
Yanray Wange6afd912022-10-27 12:11:18 +0800230{
231 queue->messages = (size_t *) mbedtls_calloc(capacity, sizeof(size_t));
232 if (NULL == queue->messages) {
233 return MBEDTLS_ERR_SSL_ALLOC_FAILED;
234 }
235
Yanray Wanga8f445e2022-11-03 11:51:59 +0800236 queue->capacity = (capacity > INT_MAX) ? INT_MAX : (int) capacity;
Yanray Wange6afd912022-10-27 12:11:18 +0800237 queue->pos = 0;
238 queue->num = 0;
239
240 return 0;
241}
242
Yanray Wangd19894f2023-03-16 11:47:39 +0800243void mbedtls_test_ssl_message_queue_free(
244 mbedtls_test_ssl_message_queue *queue)
Yanray Wange6afd912022-10-27 12:11:18 +0800245{
246 if (queue == NULL) {
247 return;
248 }
249
250 if (queue->messages != NULL) {
251 mbedtls_free(queue->messages);
252 }
253
254 memset(queue, 0, sizeof(*queue));
255}
256
Yanray Wange6afd912022-10-27 12:11:18 +0800257int mbedtls_test_ssl_message_queue_push_info(
258 mbedtls_test_ssl_message_queue *queue, size_t len)
259{
260 int place;
261 if (queue == NULL) {
262 return MBEDTLS_TEST_ERROR_ARG_NULL;
263 }
264
265 if (queue->num >= queue->capacity) {
266 return MBEDTLS_ERR_SSL_WANT_WRITE;
267 }
268
269 place = (queue->pos + queue->num) % queue->capacity;
270 queue->messages[place] = len;
271 queue->num++;
Yanray Wanga8f445e2022-11-03 11:51:59 +0800272 return (len > INT_MAX) ? INT_MAX : (int) len;
Yanray Wange6afd912022-10-27 12:11:18 +0800273}
274
Yanray Wange6afd912022-10-27 12:11:18 +0800275int mbedtls_test_ssl_message_queue_pop_info(
276 mbedtls_test_ssl_message_queue *queue, size_t buf_len)
277{
278 size_t message_length;
279 if (queue == NULL) {
280 return MBEDTLS_TEST_ERROR_ARG_NULL;
281 }
282 if (queue->num == 0) {
283 return MBEDTLS_ERR_SSL_WANT_READ;
284 }
285
286 message_length = queue->messages[queue->pos];
287 queue->messages[queue->pos] = 0;
288 queue->num--;
289 queue->pos++;
290 queue->pos %= queue->capacity;
291 if (queue->pos < 0) {
292 queue->pos += queue->capacity;
293 }
294
Yanray Wanga8f445e2022-11-03 11:51:59 +0800295 return (message_length > INT_MAX && buf_len > INT_MAX) ? INT_MAX :
296 (message_length > buf_len) ? (int) buf_len : (int) message_length;
Yanray Wange6afd912022-10-27 12:11:18 +0800297}
298
299/*
300 * Take a peek on the info about the next message length from the queue.
301 * This will be the oldest inserted message length(fifo).
302 *
303 * \retval MBEDTLS_TEST_ERROR_ARG_NULL, if the queue is null.
304 * \retval MBEDTLS_ERR_SSL_WANT_READ, if the queue is empty.
305 * \retval 0, if the peek was successful.
306 * \retval MBEDTLS_TEST_ERROR_MESSAGE_TRUNCATED, if the given buffer length is
307 * too small to fit the message. In this case the \p msg_len will be
308 * set to the full message length so that the
309 * caller knows what portion of the message can be dropped.
310 */
Yanray Wang5e22a922023-03-16 14:57:54 +0800311static int test_ssl_message_queue_peek_info(
312 mbedtls_test_ssl_message_queue *queue,
313 size_t buf_len, size_t *msg_len)
Yanray Wange6afd912022-10-27 12:11:18 +0800314{
315 if (queue == NULL || msg_len == NULL) {
316 return MBEDTLS_TEST_ERROR_ARG_NULL;
317 }
318 if (queue->num == 0) {
319 return MBEDTLS_ERR_SSL_WANT_READ;
320 }
321
322 *msg_len = queue->messages[queue->pos];
323 return (*msg_len > buf_len) ? MBEDTLS_TEST_ERROR_MESSAGE_TRUNCATED : 0;
324}
325
Yanray Wang5f86a422023-03-15 16:02:29 +0800326void mbedtls_test_mock_socket_init(mbedtls_test_mock_socket *socket)
Yanray Wange6afd912022-10-27 12:11:18 +0800327{
328 memset(socket, 0, sizeof(*socket));
329}
330
Yanray Wange6afd912022-10-27 12:11:18 +0800331void mbedtls_test_mock_socket_close(mbedtls_test_mock_socket *socket)
332{
333 if (socket == NULL) {
334 return;
335 }
336
337 if (socket->input != NULL) {
338 mbedtls_test_ssl_buffer_free(socket->input);
339 mbedtls_free(socket->input);
340 }
341
342 if (socket->output != NULL) {
343 mbedtls_test_ssl_buffer_free(socket->output);
344 mbedtls_free(socket->output);
345 }
346
347 if (socket->peer != NULL) {
348 memset(socket->peer, 0, sizeof(*socket->peer));
349 }
350
351 memset(socket, 0, sizeof(*socket));
352}
353
Yanray Wange6afd912022-10-27 12:11:18 +0800354int mbedtls_test_mock_socket_connect(mbedtls_test_mock_socket *peer1,
355 mbedtls_test_mock_socket *peer2,
356 size_t bufsize)
357{
358 int ret = -1;
359
360 peer1->output =
361 (mbedtls_test_ssl_buffer *) mbedtls_calloc(
362 1, sizeof(mbedtls_test_ssl_buffer));
363 if (peer1->output == NULL) {
364 ret = MBEDTLS_ERR_SSL_ALLOC_FAILED;
365 goto exit;
366 }
367 mbedtls_test_ssl_buffer_init(peer1->output);
368 if (0 != (ret = mbedtls_test_ssl_buffer_setup(peer1->output, bufsize))) {
369 goto exit;
370 }
371
372 peer2->output =
373 (mbedtls_test_ssl_buffer *) mbedtls_calloc(
374 1, sizeof(mbedtls_test_ssl_buffer));
375 if (peer2->output == NULL) {
376 ret = MBEDTLS_ERR_SSL_ALLOC_FAILED;
377 goto exit;
378 }
379 mbedtls_test_ssl_buffer_init(peer2->output);
380 if (0 != (ret = mbedtls_test_ssl_buffer_setup(peer2->output, bufsize))) {
381 goto exit;
382 }
383
384 peer1->peer = peer2;
385 peer2->peer = peer1;
386 peer1->input = peer2->output;
387 peer2->input = peer1->output;
388
389 peer1->status = peer2->status = MBEDTLS_MOCK_SOCKET_CONNECTED;
390 ret = 0;
391
392exit:
393
394 if (ret != 0) {
395 mbedtls_test_mock_socket_close(peer1);
396 mbedtls_test_mock_socket_close(peer2);
397 }
398
399 return ret;
400}
401
Yanray Wangaf727a22023-03-13 19:22:36 +0800402int mbedtls_test_mock_tcp_send_b(void *ctx,
403 const unsigned char *buf, size_t len)
Yanray Wange6afd912022-10-27 12:11:18 +0800404{
405 mbedtls_test_mock_socket *socket = (mbedtls_test_mock_socket *) ctx;
406
407 if (socket == NULL || socket->status != MBEDTLS_MOCK_SOCKET_CONNECTED) {
408 return -1;
409 }
410
411 return mbedtls_test_ssl_buffer_put(socket->output, buf, len);
412}
413
414int mbedtls_test_mock_tcp_recv_b(void *ctx, unsigned char *buf, size_t len)
415{
416 mbedtls_test_mock_socket *socket = (mbedtls_test_mock_socket *) ctx;
417
418 if (socket == NULL || socket->status != MBEDTLS_MOCK_SOCKET_CONNECTED) {
419 return -1;
420 }
421
422 return mbedtls_test_ssl_buffer_get(socket->input, buf, len);
423}
424
Yanray Wang34634352023-02-14 17:56:51 +0800425int mbedtls_test_mock_tcp_send_nb(void *ctx,
426 const unsigned char *buf, size_t len)
Yanray Wange6afd912022-10-27 12:11:18 +0800427{
428 mbedtls_test_mock_socket *socket = (mbedtls_test_mock_socket *) ctx;
429
430 if (socket == NULL || socket->status != MBEDTLS_MOCK_SOCKET_CONNECTED) {
431 return -1;
432 }
433
434 if (socket->output->capacity == socket->output->content_length) {
435 return MBEDTLS_ERR_SSL_WANT_WRITE;
436 }
437
438 return mbedtls_test_ssl_buffer_put(socket->output, buf, len);
439}
440
441int mbedtls_test_mock_tcp_recv_nb(void *ctx, unsigned char *buf, size_t len)
442{
443 mbedtls_test_mock_socket *socket = (mbedtls_test_mock_socket *) ctx;
444
445 if (socket == NULL || socket->status != MBEDTLS_MOCK_SOCKET_CONNECTED) {
446 return -1;
447 }
448
449 if (socket->input->content_length == 0) {
450 return MBEDTLS_ERR_SSL_WANT_READ;
451 }
452
453 return mbedtls_test_ssl_buffer_get(socket->input, buf, len);
454}
455
Yanray Wangd19894f2023-03-16 11:47:39 +0800456void mbedtls_test_message_socket_init(
457 mbedtls_test_message_socket_context *ctx)
Yanray Wange6afd912022-10-27 12:11:18 +0800458{
459 ctx->queue_input = NULL;
460 ctx->queue_output = NULL;
461 ctx->socket = NULL;
462}
463
Yanray Wange6afd912022-10-27 12:11:18 +0800464int mbedtls_test_message_socket_setup(
465 mbedtls_test_ssl_message_queue *queue_input,
466 mbedtls_test_ssl_message_queue *queue_output,
467 size_t queue_capacity,
468 mbedtls_test_mock_socket *socket,
469 mbedtls_test_message_socket_context *ctx)
470{
471 int ret = mbedtls_test_ssl_message_queue_setup(queue_input, queue_capacity);
472 if (ret != 0) {
473 return ret;
474 }
475 ctx->queue_input = queue_input;
476 ctx->queue_output = queue_output;
477 ctx->socket = socket;
Yanray Wang5f86a422023-03-15 16:02:29 +0800478 mbedtls_test_mock_socket_init(socket);
Yanray Wange6afd912022-10-27 12:11:18 +0800479
480 return 0;
481}
482
Yanray Wangd19894f2023-03-16 11:47:39 +0800483void mbedtls_test_message_socket_close(
484 mbedtls_test_message_socket_context *ctx)
Yanray Wange6afd912022-10-27 12:11:18 +0800485{
486 if (ctx == NULL) {
487 return;
488 }
489
490 mbedtls_test_ssl_message_queue_free(ctx->queue_input);
491 mbedtls_test_mock_socket_close(ctx->socket);
492 memset(ctx, 0, sizeof(*ctx));
493}
494
Yanray Wang34634352023-02-14 17:56:51 +0800495int mbedtls_test_mock_tcp_send_msg(void *ctx,
496 const unsigned char *buf, size_t len)
Yanray Wange6afd912022-10-27 12:11:18 +0800497{
498 mbedtls_test_ssl_message_queue *queue;
499 mbedtls_test_mock_socket *socket;
500 mbedtls_test_message_socket_context *context =
501 (mbedtls_test_message_socket_context *) ctx;
502
503 if (context == NULL || context->socket == NULL
504 || context->queue_output == NULL) {
505 return MBEDTLS_TEST_ERROR_CONTEXT_ERROR;
506 }
507
508 queue = context->queue_output;
509 socket = context->socket;
510
511 if (queue->num >= queue->capacity) {
512 return MBEDTLS_ERR_SSL_WANT_WRITE;
513 }
514
515 if (mbedtls_test_mock_tcp_send_b(socket, buf, len) != (int) len) {
516 return MBEDTLS_TEST_ERROR_SEND_FAILED;
517 }
518
519 return mbedtls_test_ssl_message_queue_push_info(queue, len);
520}
521
Yanray Wang34634352023-02-14 17:56:51 +0800522int mbedtls_test_mock_tcp_recv_msg(void *ctx,
523 unsigned char *buf, size_t buf_len)
Yanray Wange6afd912022-10-27 12:11:18 +0800524{
525 mbedtls_test_ssl_message_queue *queue;
526 mbedtls_test_mock_socket *socket;
527 mbedtls_test_message_socket_context *context =
528 (mbedtls_test_message_socket_context *) ctx;
529 size_t drop_len = 0;
530 size_t msg_len;
531 int ret;
532
533 if (context == NULL || context->socket == NULL
534 || context->queue_input == NULL) {
535 return MBEDTLS_TEST_ERROR_CONTEXT_ERROR;
536 }
537
538 queue = context->queue_input;
539 socket = context->socket;
540
541 /* Peek first, so that in case of a socket error the data remains in
542 * the queue. */
Yanray Wang5e22a922023-03-16 14:57:54 +0800543 ret = test_ssl_message_queue_peek_info(queue, buf_len, &msg_len);
Yanray Wange6afd912022-10-27 12:11:18 +0800544 if (ret == MBEDTLS_TEST_ERROR_MESSAGE_TRUNCATED) {
545 /* Calculate how much to drop */
546 drop_len = msg_len - buf_len;
547
548 /* Set the requested message len to be buffer length */
549 msg_len = buf_len;
550 } else if (ret != 0) {
551 return ret;
552 }
553
554 if (mbedtls_test_mock_tcp_recv_b(socket, buf, msg_len) != (int) msg_len) {
555 return MBEDTLS_TEST_ERROR_RECV_FAILED;
556 }
557
558 if (ret == MBEDTLS_TEST_ERROR_MESSAGE_TRUNCATED) {
559 /* Drop the remaining part of the message */
Yanray Wangaf727a22023-03-13 19:22:36 +0800560 if (mbedtls_test_mock_tcp_recv_b(socket, NULL, drop_len) !=
561 (int) drop_len) {
Yanray Wange6afd912022-10-27 12:11:18 +0800562 /* Inconsistent state - part of the message was read,
563 * and a part couldn't. Not much we can do here, but it should not
564 * happen in test environment, unless forced manually. */
565 }
566 }
Tomás Gonzáleza9b90de2024-02-01 11:12:20 +0000567 ret = mbedtls_test_ssl_message_queue_pop_info(queue, buf_len);
568 if (ret < 0) {
569 return ret;
570 }
Yanray Wange6afd912022-10-27 12:11:18 +0800571
Yanray Wanga8f445e2022-11-03 11:51:59 +0800572 return (msg_len > INT_MAX) ? INT_MAX : (int) msg_len;
Yanray Wange6afd912022-10-27 12:11:18 +0800573}
574
575#if defined(MBEDTLS_SSL_HANDSHAKE_WITH_CERT_ENABLED)
576
577/*
578 * Deinitializes certificates from endpoint represented by \p ep.
579 */
Yanray Wangf6f71902023-03-15 16:05:14 +0800580static void test_ssl_endpoint_certificate_free(mbedtls_test_ssl_endpoint *ep)
Yanray Wange6afd912022-10-27 12:11:18 +0800581{
Gilles Peskineb6bb3fb2025-05-26 21:57:52 +0200582 if (ep->ca_chain != NULL) {
583 mbedtls_x509_crt_free(ep->ca_chain);
584 mbedtls_free(ep->ca_chain);
585 ep->ca_chain = NULL;
586 }
587 if (ep->cert != NULL) {
588 mbedtls_x509_crt_free(ep->cert);
589 mbedtls_free(ep->cert);
590 ep->cert = NULL;
591 }
592 if (ep->pkey != NULL) {
Yanray Wange6afd912022-10-27 12:11:18 +0800593#if defined(MBEDTLS_USE_PSA_CRYPTO)
Gilles Peskineb6bb3fb2025-05-26 21:57:52 +0200594 if (mbedtls_pk_get_type(ep->pkey) == MBEDTLS_PK_OPAQUE) {
595 psa_destroy_key(ep->pkey->priv_id);
Yanray Wange6afd912022-10-27 12:11:18 +0800596 }
Gilles Peskineb6bb3fb2025-05-26 21:57:52 +0200597#endif
598 mbedtls_pk_free(ep->pkey);
599 mbedtls_free(ep->pkey);
600 ep->pkey = NULL;
Yanray Wange6afd912022-10-27 12:11:18 +0800601 }
602}
603
Yanray Wange6afd912022-10-27 12:11:18 +0800604int mbedtls_test_ssl_endpoint_certificate_init(mbedtls_test_ssl_endpoint *ep,
605 int pk_alg,
606 int opaque_alg, int opaque_alg2,
607 int opaque_usage)
608{
609 int i = 0;
610 int ret = -1;
Gilles Peskine946bf142025-04-08 09:48:40 +0200611 int ok = 0;
Yanray Wange6afd912022-10-27 12:11:18 +0800612#if defined(MBEDTLS_USE_PSA_CRYPTO)
613 mbedtls_svc_key_id_t key_slot = MBEDTLS_SVC_KEY_ID_INIT;
614#endif
615
616 if (ep == NULL) {
617 return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
618 }
619
Gilles Peskineb6bb3fb2025-05-26 21:57:52 +0200620 TEST_CALLOC(ep->ca_chain, 1);
621 TEST_CALLOC(ep->cert, 1);
622 TEST_CALLOC(ep->pkey, 1);
Yanray Wange6afd912022-10-27 12:11:18 +0800623
Gilles Peskineb6bb3fb2025-05-26 21:57:52 +0200624 mbedtls_x509_crt_init(ep->ca_chain);
625 mbedtls_x509_crt_init(ep->cert);
626 mbedtls_pk_init(ep->pkey);
Yanray Wange6afd912022-10-27 12:11:18 +0800627
628 /* Load the trusted CA */
629
630 for (i = 0; mbedtls_test_cas_der[i] != NULL; i++) {
631 ret = mbedtls_x509_crt_parse_der(
Gilles Peskineb6bb3fb2025-05-26 21:57:52 +0200632 ep->ca_chain,
Yanray Wange6afd912022-10-27 12:11:18 +0800633 (const unsigned char *) mbedtls_test_cas_der[i],
634 mbedtls_test_cas_der_len[i]);
Gilles Peskine353eb332025-05-14 17:42:53 +0200635 TEST_EQUAL(ret, 0);
Yanray Wange6afd912022-10-27 12:11:18 +0800636 }
637
638 /* Load own certificate and private key */
639
640 if (ep->conf.endpoint == MBEDTLS_SSL_IS_SERVER) {
641 if (pk_alg == MBEDTLS_PK_RSA) {
642 ret = mbedtls_x509_crt_parse(
Gilles Peskineb6bb3fb2025-05-26 21:57:52 +0200643 ep->cert,
Yanray Wange6afd912022-10-27 12:11:18 +0800644 (const unsigned char *) mbedtls_test_srv_crt_rsa_sha256_der,
645 mbedtls_test_srv_crt_rsa_sha256_der_len);
Gilles Peskine353eb332025-05-14 17:42:53 +0200646 TEST_EQUAL(ret, 0);
Yanray Wange6afd912022-10-27 12:11:18 +0800647
648 ret = mbedtls_pk_parse_key(
Gilles Peskineb6bb3fb2025-05-26 21:57:52 +0200649 ep->pkey,
Yanray Wange6afd912022-10-27 12:11:18 +0800650 (const unsigned char *) mbedtls_test_srv_key_rsa_der,
Ben Taylor440cb2a2025-03-05 09:40:08 +0000651 mbedtls_test_srv_key_rsa_der_len, NULL, 0);
Gilles Peskine353eb332025-05-14 17:42:53 +0200652 TEST_EQUAL(ret, 0);
Yanray Wange6afd912022-10-27 12:11:18 +0800653 } else {
654 ret = mbedtls_x509_crt_parse(
Gilles Peskineb6bb3fb2025-05-26 21:57:52 +0200655 ep->cert,
Yanray Wange6afd912022-10-27 12:11:18 +0800656 (const unsigned char *) mbedtls_test_srv_crt_ec_der,
657 mbedtls_test_srv_crt_ec_der_len);
Gilles Peskine353eb332025-05-14 17:42:53 +0200658 TEST_EQUAL(ret, 0);
Yanray Wange6afd912022-10-27 12:11:18 +0800659
660 ret = mbedtls_pk_parse_key(
Gilles Peskineb6bb3fb2025-05-26 21:57:52 +0200661 ep->pkey,
Yanray Wange6afd912022-10-27 12:11:18 +0800662 (const unsigned char *) mbedtls_test_srv_key_ec_der,
Ben Taylor440cb2a2025-03-05 09:40:08 +0000663 mbedtls_test_srv_key_ec_der_len, NULL, 0);
Gilles Peskine353eb332025-05-14 17:42:53 +0200664 TEST_EQUAL(ret, 0);
Yanray Wange6afd912022-10-27 12:11:18 +0800665 }
666 } else {
667 if (pk_alg == MBEDTLS_PK_RSA) {
668 ret = mbedtls_x509_crt_parse(
Gilles Peskineb6bb3fb2025-05-26 21:57:52 +0200669 ep->cert,
Yanray Wange6afd912022-10-27 12:11:18 +0800670 (const unsigned char *) mbedtls_test_cli_crt_rsa_der,
671 mbedtls_test_cli_crt_rsa_der_len);
Gilles Peskine353eb332025-05-14 17:42:53 +0200672 TEST_EQUAL(ret, 0);
Yanray Wange6afd912022-10-27 12:11:18 +0800673
674 ret = mbedtls_pk_parse_key(
Gilles Peskineb6bb3fb2025-05-26 21:57:52 +0200675 ep->pkey,
Yanray Wange6afd912022-10-27 12:11:18 +0800676 (const unsigned char *) mbedtls_test_cli_key_rsa_der,
Ben Taylor440cb2a2025-03-05 09:40:08 +0000677 mbedtls_test_cli_key_rsa_der_len, NULL, 0);
Gilles Peskine353eb332025-05-14 17:42:53 +0200678 TEST_EQUAL(ret, 0);
Yanray Wange6afd912022-10-27 12:11:18 +0800679 } else {
680 ret = mbedtls_x509_crt_parse(
Gilles Peskineb6bb3fb2025-05-26 21:57:52 +0200681 ep->cert,
Yanray Wange6afd912022-10-27 12:11:18 +0800682 (const unsigned char *) mbedtls_test_cli_crt_ec_der,
683 mbedtls_test_cli_crt_ec_len);
Gilles Peskine353eb332025-05-14 17:42:53 +0200684 TEST_EQUAL(ret, 0);
Yanray Wange6afd912022-10-27 12:11:18 +0800685
686 ret = mbedtls_pk_parse_key(
Gilles Peskineb6bb3fb2025-05-26 21:57:52 +0200687 ep->pkey,
Yanray Wange6afd912022-10-27 12:11:18 +0800688 (const unsigned char *) mbedtls_test_cli_key_ec_der,
Ben Taylor440cb2a2025-03-05 09:40:08 +0000689 mbedtls_test_cli_key_ec_der_len, NULL, 0);
Gilles Peskine353eb332025-05-14 17:42:53 +0200690 TEST_EQUAL(ret, 0);
Yanray Wange6afd912022-10-27 12:11:18 +0800691 }
692 }
693
694#if defined(MBEDTLS_USE_PSA_CRYPTO)
695 if (opaque_alg != 0) {
Valerio Setti1fa2f6e2024-02-27 08:11:25 +0100696 psa_key_attributes_t key_attr = PSA_KEY_ATTRIBUTES_INIT;
697 /* Use a fake key usage to get a successful initial guess for the PSA attributes. */
Gilles Peskineb6bb3fb2025-05-26 21:57:52 +0200698 TEST_EQUAL(mbedtls_pk_get_psa_attributes(ep->pkey, PSA_KEY_USAGE_SIGN_HASH,
Valerio Setti1fa2f6e2024-02-27 08:11:25 +0100699 &key_attr), 0);
Valerio Settia9de9442024-02-27 13:56:09 +0100700 /* Then manually usage, alg and alg2 as requested by the test. */
Valerio Setti1fa2f6e2024-02-27 08:11:25 +0100701 psa_set_key_usage_flags(&key_attr, opaque_usage);
702 psa_set_key_algorithm(&key_attr, opaque_alg);
703 if (opaque_alg2 != PSA_ALG_NONE) {
704 psa_set_key_enrollment_algorithm(&key_attr, opaque_alg2);
705 }
Gilles Peskineb6bb3fb2025-05-26 21:57:52 +0200706 TEST_EQUAL(mbedtls_pk_import_into_psa(ep->pkey, &key_attr, &key_slot), 0);
707 mbedtls_pk_free(ep->pkey);
708 mbedtls_pk_init(ep->pkey);
709 TEST_EQUAL(mbedtls_pk_setup_opaque(ep->pkey, key_slot), 0);
Yanray Wange6afd912022-10-27 12:11:18 +0800710 }
711#else
712 (void) opaque_alg;
713 (void) opaque_alg2;
714 (void) opaque_usage;
715#endif
716
Gilles Peskineb6bb3fb2025-05-26 21:57:52 +0200717 mbedtls_ssl_conf_ca_chain(&(ep->conf), ep->ca_chain, NULL);
Yanray Wange6afd912022-10-27 12:11:18 +0800718
Gilles Peskineb6bb3fb2025-05-26 21:57:52 +0200719 ret = mbedtls_ssl_conf_own_cert(&(ep->conf), ep->cert,
720 ep->pkey);
Gilles Peskine353eb332025-05-14 17:42:53 +0200721 TEST_EQUAL(ret, 0);
Yanray Wange6afd912022-10-27 12:11:18 +0800722
Gilles Peskine946bf142025-04-08 09:48:40 +0200723 ok = 1;
724
Yanray Wange6afd912022-10-27 12:11:18 +0800725exit:
Gilles Peskine946bf142025-04-08 09:48:40 +0200726 if (ret == 0 && !ok) {
727 /* Exiting due to a test assertion that isn't ret == 0 */
728 ret = -1;
729 }
Yanray Wange6afd912022-10-27 12:11:18 +0800730 if (ret != 0) {
Yanray Wangf6f71902023-03-15 16:05:14 +0800731 test_ssl_endpoint_certificate_free(ep);
Yanray Wange6afd912022-10-27 12:11:18 +0800732 }
733
734 return ret;
735}
736
Yanray Wange6afd912022-10-27 12:11:18 +0800737int mbedtls_test_ssl_endpoint_init(
738 mbedtls_test_ssl_endpoint *ep, int endpoint_type,
Gilles Peskine9b993682025-05-27 18:44:12 +0200739 const mbedtls_test_handshake_test_options *options,
Yanray Wange6afd912022-10-27 12:11:18 +0800740 mbedtls_test_message_socket_context *dtls_context,
741 mbedtls_test_ssl_message_queue *input_queue,
Ronald Cronfb536472024-01-26 14:55:25 +0100742 mbedtls_test_ssl_message_queue *output_queue)
Yanray Wange6afd912022-10-27 12:11:18 +0800743{
Gilles Peskine29969592025-05-27 19:24:28 +0200744 (void) dtls_context; // no longer used
Gilles Peskine6c154e72025-05-27 20:23:52 +0200745 (void) input_queue; // no longer used
746 (void) output_queue; // no longer used
Gilles Peskine29969592025-05-27 19:24:28 +0200747
Yanray Wange6afd912022-10-27 12:11:18 +0800748 int ret = -1;
749 uintptr_t user_data_n;
750
Yanray Wange6afd912022-10-27 12:11:18 +0800751 if (ep == NULL) {
752 return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
753 }
754
755 memset(ep, 0, sizeof(*ep));
756
757 ep->name = (endpoint_type == MBEDTLS_SSL_IS_SERVER) ? "Server" : "Client";
758
759 mbedtls_ssl_init(&(ep->ssl));
760 mbedtls_ssl_config_init(&(ep->conf));
Gilles Peskine29969592025-05-27 19:24:28 +0200761 mbedtls_test_message_socket_init(&ep->dtls_context);
Yanray Wange6afd912022-10-27 12:11:18 +0800762
763 TEST_ASSERT(mbedtls_ssl_conf_get_user_data_p(&ep->conf) == NULL);
764 TEST_EQUAL(mbedtls_ssl_conf_get_user_data_n(&ep->conf), 0);
765 TEST_ASSERT(mbedtls_ssl_get_user_data_p(&ep->ssl) == NULL);
766 TEST_EQUAL(mbedtls_ssl_get_user_data_n(&ep->ssl), 0);
767
768 (void) mbedtls_test_rnd_std_rand(NULL,
769 (void *) &user_data_n,
770 sizeof(user_data_n));
771 mbedtls_ssl_conf_set_user_data_n(&ep->conf, user_data_n);
772 mbedtls_ssl_set_user_data_n(&ep->ssl, user_data_n);
773
Gilles Peskine6c154e72025-05-27 20:23:52 +0200774 mbedtls_test_mock_socket_init(&(ep->socket));
Yanray Wange6afd912022-10-27 12:11:18 +0800775
776 /* Non-blocking callbacks without timeout */
Gilles Peskine29969592025-05-27 19:24:28 +0200777 if (options->dtls) {
778 mbedtls_ssl_set_bio(&(ep->ssl), &ep->dtls_context,
Yanray Wange6afd912022-10-27 12:11:18 +0800779 mbedtls_test_mock_tcp_send_msg,
780 mbedtls_test_mock_tcp_recv_msg,
781 NULL);
Gilles Peskine0677e022025-05-27 18:05:20 +0200782#if defined(MBEDTLS_TIMING_C)
783 mbedtls_ssl_set_timer_cb(&ep->ssl, &ep->timer,
784 mbedtls_timing_set_delay,
785 mbedtls_timing_get_delay);
786#endif
Yanray Wange6afd912022-10-27 12:11:18 +0800787 } else {
788 mbedtls_ssl_set_bio(&(ep->ssl), &(ep->socket),
789 mbedtls_test_mock_tcp_send_nb,
790 mbedtls_test_mock_tcp_recv_nb,
791 NULL);
792 }
793
794 ret = mbedtls_ssl_config_defaults(&(ep->conf), endpoint_type,
Gilles Peskine29969592025-05-27 19:24:28 +0200795 options->dtls ?
Yanray Wange6afd912022-10-27 12:11:18 +0800796 MBEDTLS_SSL_TRANSPORT_DATAGRAM :
797 MBEDTLS_SSL_TRANSPORT_STREAM,
798 MBEDTLS_SSL_PRESET_DEFAULT);
Gilles Peskine353eb332025-05-14 17:42:53 +0200799 TEST_EQUAL(ret, 0);
Yanray Wange6afd912022-10-27 12:11:18 +0800800
Ronald Crona697a712023-03-09 17:47:42 +0100801 if (MBEDTLS_SSL_IS_CLIENT == endpoint_type) {
802 if (options->client_min_version != MBEDTLS_SSL_VERSION_UNKNOWN) {
803 mbedtls_ssl_conf_min_tls_version(&(ep->conf),
804 options->client_min_version);
805 }
806
807 if (options->client_max_version != MBEDTLS_SSL_VERSION_UNKNOWN) {
808 mbedtls_ssl_conf_max_tls_version(&(ep->conf),
809 options->client_max_version);
810 }
811 } else {
812 if (options->server_min_version != MBEDTLS_SSL_VERSION_UNKNOWN) {
813 mbedtls_ssl_conf_min_tls_version(&(ep->conf),
814 options->server_min_version);
815 }
816
817 if (options->server_max_version != MBEDTLS_SSL_VERSION_UNKNOWN) {
818 mbedtls_ssl_conf_max_tls_version(&(ep->conf),
819 options->server_max_version);
820 }
821 }
822
Ronald Cronfb536472024-01-26 14:55:25 +0100823 if (options->group_list != NULL) {
824 mbedtls_ssl_conf_groups(&(ep->conf), options->group_list);
Yanray Wange6afd912022-10-27 12:11:18 +0800825 }
826
827 mbedtls_ssl_conf_authmode(&(ep->conf), MBEDTLS_SSL_VERIFY_REQUIRED);
828
Ronald Cronced99be2024-01-26 15:49:12 +0100829#if defined(MBEDTLS_SSL_EARLY_DATA)
830 mbedtls_ssl_conf_early_data(&(ep->conf), options->early_data);
Ronald Cron5d3036e2024-02-23 07:43:45 +0100831#if defined(MBEDTLS_SSL_SRV_C)
832 if (endpoint_type == MBEDTLS_SSL_IS_SERVER &&
833 (options->max_early_data_size >= 0)) {
834 mbedtls_ssl_conf_max_early_data_size(&(ep->conf),
835 options->max_early_data_size);
836 }
837#endif
Waleed Elmelegy4dfb0e72024-03-14 01:48:40 +0000838#if defined(MBEDTLS_SSL_ALPN)
839 /* check that alpn_list contains at least one valid entry */
840 if (options->alpn_list[0] != NULL) {
841 mbedtls_ssl_conf_alpn_protocols(&(ep->conf), options->alpn_list);
842 }
843#endif
Ronald Cronced99be2024-01-26 15:49:12 +0100844#endif
845
Yanray Wange6afd912022-10-27 12:11:18 +0800846#if defined(MBEDTLS_SSL_CACHE_C) && defined(MBEDTLS_SSL_SRV_C)
847 if (endpoint_type == MBEDTLS_SSL_IS_SERVER && options->cache != NULL) {
848 mbedtls_ssl_conf_session_cache(&(ep->conf), options->cache,
849 mbedtls_ssl_cache_get,
850 mbedtls_ssl_cache_set);
851 }
852#endif
853
854 ret = mbedtls_ssl_setup(&(ep->ssl), &(ep->conf));
Gilles Peskine353eb332025-05-14 17:42:53 +0200855 TEST_EQUAL(ret, 0);
Yanray Wange6afd912022-10-27 12:11:18 +0800856
Gilles Peskine856a3702025-02-13 17:28:49 +0100857 if (MBEDTLS_SSL_IS_CLIENT == endpoint_type) {
858 ret = mbedtls_ssl_set_hostname(&(ep->ssl), "localhost");
Gilles Peskine55b8bb42025-04-08 09:44:34 +0200859 TEST_EQUAL(ret, 0);
Gilles Peskine856a3702025-02-13 17:28:49 +0100860 }
861
Yanray Wange6afd912022-10-27 12:11:18 +0800862#if defined(MBEDTLS_SSL_PROTO_DTLS) && defined(MBEDTLS_SSL_SRV_C)
Gilles Peskine29969592025-05-27 19:24:28 +0200863 if (endpoint_type == MBEDTLS_SSL_IS_SERVER && options->dtls) {
Yanray Wange6afd912022-10-27 12:11:18 +0800864 mbedtls_ssl_conf_dtls_cookies(&(ep->conf), NULL, NULL, NULL);
865 }
866#endif
867
Ronald Cronec3408d2024-01-16 17:50:40 +0100868#if defined(MBEDTLS_DEBUG_C)
869#if defined(MBEDTLS_SSL_SRV_C)
870 if (endpoint_type == MBEDTLS_SSL_IS_SERVER &&
871 options->srv_log_fun != NULL) {
872 mbedtls_ssl_conf_dbg(&(ep->conf), options->srv_log_fun,
873 options->srv_log_obj);
874 }
875#endif
876#if defined(MBEDTLS_SSL_CLI_C)
877 if (endpoint_type == MBEDTLS_SSL_IS_CLIENT &&
878 options->cli_log_fun != NULL) {
879 mbedtls_ssl_conf_dbg(&(ep->conf), options->cli_log_fun,
880 options->cli_log_obj);
881 }
882#endif
883#endif /* MBEDTLS_DEBUG_C */
884
Yanray Wange6afd912022-10-27 12:11:18 +0800885 ret = mbedtls_test_ssl_endpoint_certificate_init(ep, options->pk_alg,
886 options->opaque_alg,
887 options->opaque_alg2,
888 options->opaque_usage);
Gilles Peskine353eb332025-05-14 17:42:53 +0200889 TEST_EQUAL(ret, 0);
Yanray Wange6afd912022-10-27 12:11:18 +0800890
891 TEST_EQUAL(mbedtls_ssl_conf_get_user_data_n(&ep->conf), user_data_n);
892 mbedtls_ssl_conf_set_user_data_p(&ep->conf, ep);
893 TEST_EQUAL(mbedtls_ssl_get_user_data_n(&ep->ssl), user_data_n);
894 mbedtls_ssl_set_user_data_p(&ep->ssl, ep);
895
Gilles Peskine946bf142025-04-08 09:48:40 +0200896 return 0;
897
Yanray Wange6afd912022-10-27 12:11:18 +0800898exit:
Gilles Peskine946bf142025-04-08 09:48:40 +0200899 if (ret == 0) {
900 /* Exiting due to a test assertion that isn't ret == 0 */
901 ret = -1;
902 }
Yanray Wange6afd912022-10-27 12:11:18 +0800903 return ret;
904}
905
Yanray Wange6afd912022-10-27 12:11:18 +0800906void mbedtls_test_ssl_endpoint_free(
907 mbedtls_test_ssl_endpoint *ep,
908 mbedtls_test_message_socket_context *context)
909{
Gilles Peskine29969592025-05-27 19:24:28 +0200910 (void) context; // no longer used
911
Yanray Wange6afd912022-10-27 12:11:18 +0800912 mbedtls_ssl_free(&(ep->ssl));
913 mbedtls_ssl_config_free(&(ep->conf));
914
Gilles Peskine2744a432025-05-27 13:27:22 +0200915 mbedtls_free(ep->ciphersuites);
916 ep->ciphersuites = NULL;
917 test_ssl_endpoint_certificate_free(ep);
918
Gilles Peskine29969592025-05-27 19:24:28 +0200919 if (ep->dtls_context.socket != NULL) {
920 mbedtls_test_message_socket_close(&ep->dtls_context);
Yanray Wange6afd912022-10-27 12:11:18 +0800921 } else {
922 mbedtls_test_mock_socket_close(&(ep->socket));
923 }
924}
925
Gilles Peskineb092e782025-05-27 20:15:03 +0200926int mbedtls_test_ssl_dtls_join_endpoints(mbedtls_test_ssl_endpoint *client,
927 mbedtls_test_ssl_endpoint *server)
928{
929 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
930
Gilles Peskine6c154e72025-05-27 20:23:52 +0200931 ret = mbedtls_test_message_socket_setup(&client->queue_input,
932 &server->queue_input,
933 100, &(client->socket),
934 &client->dtls_context);
935 TEST_EQUAL(ret, 0);
Gilles Peskineb092e782025-05-27 20:15:03 +0200936
Gilles Peskine6c154e72025-05-27 20:23:52 +0200937 ret = mbedtls_test_message_socket_setup(&server->queue_input,
938 &client->queue_input,
939 100, &(server->socket),
940 &server->dtls_context);
941 TEST_EQUAL(ret, 0);
942
943exit:
Gilles Peskineb092e782025-05-27 20:15:03 +0200944 return ret;
945}
946
Yanray Wange6afd912022-10-27 12:11:18 +0800947int mbedtls_test_move_handshake_to_state(mbedtls_ssl_context *ssl,
948 mbedtls_ssl_context *second_ssl,
949 int state)
950{
951 enum { BUFFSIZE = 1024 };
952 int max_steps = 1000;
953 int ret = 0;
954
955 if (ssl == NULL || second_ssl == NULL) {
956 return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
957 }
958
959 /* Perform communication via connected sockets */
960 while ((ssl->state != state) && (--max_steps >= 0)) {
961 /* If /p second_ssl ends the handshake procedure before /p ssl then
962 * there is no need to call the next step */
963 if (!mbedtls_ssl_is_handshake_over(second_ssl)) {
964 ret = mbedtls_ssl_handshake_step(second_ssl);
965 if (ret != 0 && ret != MBEDTLS_ERR_SSL_WANT_READ &&
966 ret != MBEDTLS_ERR_SSL_WANT_WRITE) {
967 return ret;
968 }
969 }
970
971 /* We only care about the \p ssl state and returns, so we call it last,
972 * to leave the iteration as soon as the state is as expected. */
973 ret = mbedtls_ssl_handshake_step(ssl);
974 if (ret != 0 && ret != MBEDTLS_ERR_SSL_WANT_READ &&
975 ret != MBEDTLS_ERR_SSL_WANT_WRITE) {
976 return ret;
977 }
978 }
979
980 return (max_steps >= 0) ? ret : -1;
981}
982
983#endif /* MBEDTLS_SSL_HANDSHAKE_WITH_CERT_ENABLED */
984
985/*
986 * Write application data. Increase write counter if necessary.
987 */
Michael Schuster54300d42024-06-04 02:30:22 +0200988static int mbedtls_ssl_write_fragment(mbedtls_ssl_context *ssl,
Michael Schusterbd89b792024-06-04 02:41:10 +0200989 unsigned char *buf, int buf_len,
990 int *written,
991 const int expected_fragments)
Yanray Wange6afd912022-10-27 12:11:18 +0800992{
Agathiyan Bragadeesh93212652023-07-12 11:22:59 +0100993 int ret;
Yanray Wange6afd912022-10-27 12:11:18 +0800994 /* Verify that calling mbedtls_ssl_write with a NULL buffer and zero length is
995 * a valid no-op for TLS connections. */
996 if (ssl->conf->transport != MBEDTLS_SSL_TRANSPORT_DATAGRAM) {
Gilles Peskine353eb332025-05-14 17:42:53 +0200997 TEST_EQUAL(mbedtls_ssl_write(ssl, NULL, 0), 0);
Yanray Wange6afd912022-10-27 12:11:18 +0800998 }
999
Agathiyan Bragadeesh93212652023-07-12 11:22:59 +01001000 ret = mbedtls_ssl_write(ssl, buf + *written, buf_len - *written);
Yanray Wange6afd912022-10-27 12:11:18 +08001001 if (ret > 0) {
1002 *written += ret;
1003 }
1004
1005 if (expected_fragments == 0) {
1006 /* Used for DTLS and the message size larger than MFL. In that case
1007 * the message can not be fragmented and the library should return
1008 * MBEDTLS_ERR_SSL_BAD_INPUT_DATA error. This error must be returned
Yanray Wangb088bfc2023-03-16 12:15:49 +08001009 * to prevent a dead loop inside mbedtls_test_ssl_exchange_data(). */
Yanray Wange6afd912022-10-27 12:11:18 +08001010 return ret;
1011 } else if (expected_fragments == 1) {
1012 /* Used for TLS/DTLS and the message size lower than MFL */
1013 TEST_ASSERT(ret == buf_len ||
1014 ret == MBEDTLS_ERR_SSL_WANT_READ ||
1015 ret == MBEDTLS_ERR_SSL_WANT_WRITE);
1016 } else {
1017 /* Used for TLS and the message size larger than MFL */
1018 TEST_ASSERT(expected_fragments > 1);
1019 TEST_ASSERT((ret >= 0 && ret <= buf_len) ||
1020 ret == MBEDTLS_ERR_SSL_WANT_READ ||
1021 ret == MBEDTLS_ERR_SSL_WANT_WRITE);
1022 }
1023
1024 return 0;
1025
1026exit:
1027 /* Some of the tests failed */
1028 return -1;
1029}
1030
1031/*
1032 * Read application data and increase read counter and fragments counter
1033 * if necessary.
1034 */
Michael Schuster54300d42024-06-04 02:30:22 +02001035static int mbedtls_ssl_read_fragment(mbedtls_ssl_context *ssl,
Michael Schusterbd89b792024-06-04 02:41:10 +02001036 unsigned char *buf, int buf_len,
1037 int *read, int *fragments,
1038 const int expected_fragments)
Yanray Wange6afd912022-10-27 12:11:18 +08001039{
Agathiyan Bragadeesh93212652023-07-12 11:22:59 +01001040 int ret;
Yanray Wange6afd912022-10-27 12:11:18 +08001041 /* Verify that calling mbedtls_ssl_write with a NULL buffer and zero length is
1042 * a valid no-op for TLS connections. */
1043 if (ssl->conf->transport != MBEDTLS_SSL_TRANSPORT_DATAGRAM) {
Gilles Peskine353eb332025-05-14 17:42:53 +02001044 TEST_EQUAL(mbedtls_ssl_read(ssl, NULL, 0), 0);
Yanray Wange6afd912022-10-27 12:11:18 +08001045 }
1046
Agathiyan Bragadeesh93212652023-07-12 11:22:59 +01001047 ret = mbedtls_ssl_read(ssl, buf + *read, buf_len - *read);
Yanray Wange6afd912022-10-27 12:11:18 +08001048 if (ret > 0) {
1049 (*fragments)++;
1050 *read += ret;
1051 }
1052
1053 if (expected_fragments == 0) {
Gilles Peskine353eb332025-05-14 17:42:53 +02001054 TEST_EQUAL(ret, 0);
Yanray Wange6afd912022-10-27 12:11:18 +08001055 } else if (expected_fragments == 1) {
1056 TEST_ASSERT(ret == buf_len ||
1057 ret == MBEDTLS_ERR_SSL_WANT_READ ||
1058 ret == MBEDTLS_ERR_SSL_WANT_WRITE);
1059 } else {
1060 TEST_ASSERT(expected_fragments > 1);
1061 TEST_ASSERT((ret >= 0 && ret <= buf_len) ||
1062 ret == MBEDTLS_ERR_SSL_WANT_READ ||
1063 ret == MBEDTLS_ERR_SSL_WANT_WRITE);
1064 }
1065
1066 return 0;
1067
1068exit:
1069 /* Some of the tests failed */
1070 return -1;
1071}
1072
Yanray Wangead70c82023-03-16 12:04:49 +08001073#if defined(MBEDTLS_SSL_HANDSHAKE_WITH_CERT_ENABLED)
Gilles Peskine2744a432025-05-27 13:27:22 +02001074static int set_ciphersuite(mbedtls_test_ssl_endpoint *ep,
1075 const char *cipher)
Yanray Wange6afd912022-10-27 12:11:18 +08001076{
Gilles Peskine2744a432025-05-27 13:27:22 +02001077 if (cipher == NULL || cipher[0] == 0) {
1078 return 1;
1079 }
Yanray Wange6afd912022-10-27 12:11:18 +08001080
Gilles Peskine2744a432025-05-27 13:27:22 +02001081 int ok = 0;
1082
1083 TEST_CALLOC(ep->ciphersuites, 2);
1084 ep->ciphersuites[0] = mbedtls_ssl_get_ciphersuite_id(cipher);
1085 ep->ciphersuites[1] = 0;
1086
1087 const mbedtls_ssl_ciphersuite_t *ciphersuite_info =
1088 mbedtls_ssl_ciphersuite_from_id(ep->ciphersuites[0]);
Yanray Wange6afd912022-10-27 12:11:18 +08001089
1090 TEST_ASSERT(ciphersuite_info != NULL);
Gilles Peskine2744a432025-05-27 13:27:22 +02001091 TEST_ASSERT(ciphersuite_info->min_tls_version <= ep->conf.max_tls_version);
1092 TEST_ASSERT(ciphersuite_info->max_tls_version >= ep->conf.min_tls_version);
Yanray Wange6afd912022-10-27 12:11:18 +08001093
Gilles Peskine2744a432025-05-27 13:27:22 +02001094 if (ep->conf.max_tls_version > ciphersuite_info->max_tls_version) {
1095 ep->conf.max_tls_version = (mbedtls_ssl_protocol_version) ciphersuite_info->max_tls_version;
Yanray Wange6afd912022-10-27 12:11:18 +08001096 }
Gilles Peskine2744a432025-05-27 13:27:22 +02001097 if (ep->conf.min_tls_version < ciphersuite_info->min_tls_version) {
1098 ep->conf.min_tls_version = (mbedtls_ssl_protocol_version) ciphersuite_info->min_tls_version;
Yanray Wange6afd912022-10-27 12:11:18 +08001099 }
1100
Gilles Peskine2744a432025-05-27 13:27:22 +02001101 mbedtls_ssl_conf_ciphersuites(&ep->conf, ep->ciphersuites);
1102 ok = 1;
Yanray Wange6afd912022-10-27 12:11:18 +08001103
1104exit:
Gilles Peskine2744a432025-05-27 13:27:22 +02001105 return ok;
Yanray Wange6afd912022-10-27 12:11:18 +08001106}
Yanray Wangead70c82023-03-16 12:04:49 +08001107#endif /* MBEDTLS_SSL_HANDSHAKE_WITH_CERT_ENABLED */
Yanray Wange6afd912022-10-27 12:11:18 +08001108
Yanray Wangead70c82023-03-16 12:04:49 +08001109#if defined(MBEDTLS_SSL_HANDSHAKE_WITH_CERT_ENABLED) && \
1110 defined(MBEDTLS_SSL_HANDSHAKE_WITH_PSK_ENABLED) && \
1111 defined(MBEDTLS_SSL_SRV_C)
1112static int psk_dummy_callback(void *p_info, mbedtls_ssl_context *ssl,
1113 const unsigned char *name, size_t name_len)
Yanray Wange6afd912022-10-27 12:11:18 +08001114{
1115 (void) p_info;
1116 (void) ssl;
1117 (void) name;
1118 (void) name_len;
1119
1120 return 0;
1121}
Yanray Wangead70c82023-03-16 12:04:49 +08001122#endif /* MBEDTLS_SSL_HANDSHAKE_WITH_CERT_ENABLED &&
1123 MBEDTLS_SSL_HANDSHAKE_WITH_PSK_ENABLED &&
1124 MBEDTLS_SSL_SRV_C */
Yanray Wange6afd912022-10-27 12:11:18 +08001125
1126#if defined(MBEDTLS_SSL_PROTO_TLS1_2) && \
Elena Uziunaite74342c72024-07-05 11:31:29 +01001127 defined(PSA_WANT_ALG_CBC_NO_PADDING) && defined(PSA_WANT_KEY_TYPE_AES)
Yanray Wange6afd912022-10-27 12:11:18 +08001128int mbedtls_test_psa_cipher_encrypt_helper(mbedtls_ssl_transform *transform,
1129 const unsigned char *iv,
1130 size_t iv_len,
1131 const unsigned char *input,
1132 size_t ilen,
1133 unsigned char *output,
1134 size_t *olen)
1135{
1136#if defined(MBEDTLS_USE_PSA_CRYPTO)
1137 psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
1138 psa_cipher_operation_t cipher_op = PSA_CIPHER_OPERATION_INIT;
1139 size_t part_len;
1140
1141 status = psa_cipher_encrypt_setup(&cipher_op,
1142 transform->psa_key_enc,
1143 transform->psa_alg);
1144
1145 if (status != PSA_SUCCESS) {
1146 return PSA_TO_MBEDTLS_ERR(status);
1147 }
1148
1149 status = psa_cipher_set_iv(&cipher_op, iv, iv_len);
1150
1151 if (status != PSA_SUCCESS) {
1152 return PSA_TO_MBEDTLS_ERR(status);
1153 }
1154
1155 status = psa_cipher_update(&cipher_op, input, ilen, output, ilen, olen);
1156
1157 if (status != PSA_SUCCESS) {
1158 return PSA_TO_MBEDTLS_ERR(status);
1159 }
1160
1161 status = psa_cipher_finish(&cipher_op, output + *olen, ilen - *olen,
1162 &part_len);
1163
1164 if (status != PSA_SUCCESS) {
1165 return PSA_TO_MBEDTLS_ERR(status);
1166 }
1167
1168 *olen += part_len;
1169 return 0;
1170#else
1171 return mbedtls_cipher_crypt(&transform->cipher_ctx_enc,
1172 iv, iv_len, input, ilen, output, olen);
1173#endif /* MBEDTLS_USE_PSA_CRYPTO */
1174}
Elena Uziunaite74342c72024-07-05 11:31:29 +01001175#endif /* MBEDTLS_SSL_PROTO_TLS1_2 && PSA_WANT_ALG_CBC_NO_PADDING &&
Elena Uziunaite6121a342024-07-05 11:16:53 +01001176 PSA_WANT_KEY_TYPE_AES */
Yanray Wange6afd912022-10-27 12:11:18 +08001177
Valerio Setti31ad3a12023-10-27 11:55:02 +02001178static void mbedtls_test_ssl_cipher_info_from_type(mbedtls_cipher_type_t cipher_type,
1179 mbedtls_cipher_mode_t *cipher_mode,
1180 size_t *key_bits, size_t *iv_len)
1181{
1182 switch (cipher_type) {
1183 case MBEDTLS_CIPHER_AES_128_CBC:
1184 *cipher_mode = MBEDTLS_MODE_CBC;
1185 *key_bits = 128;
1186 *iv_len = 16;
1187 break;
1188 case MBEDTLS_CIPHER_AES_256_CBC:
1189 *cipher_mode = MBEDTLS_MODE_CBC;
1190 *key_bits = 256;
1191 *iv_len = 16;
1192 break;
1193 case MBEDTLS_CIPHER_ARIA_128_CBC:
1194 *cipher_mode = MBEDTLS_MODE_CBC;
1195 *key_bits = 128;
1196 *iv_len = 16;
1197 break;
1198 case MBEDTLS_CIPHER_ARIA_256_CBC:
1199 *cipher_mode = MBEDTLS_MODE_CBC;
1200 *key_bits = 256;
1201 *iv_len = 16;
1202 break;
1203 case MBEDTLS_CIPHER_CAMELLIA_128_CBC:
1204 *cipher_mode = MBEDTLS_MODE_CBC;
1205 *key_bits = 128;
1206 *iv_len = 16;
1207 break;
1208 case MBEDTLS_CIPHER_CAMELLIA_256_CBC:
1209 *cipher_mode = MBEDTLS_MODE_CBC;
1210 *key_bits = 256;
1211 *iv_len = 16;
1212 break;
1213
1214 case MBEDTLS_CIPHER_AES_128_CCM:
1215 *cipher_mode = MBEDTLS_MODE_CCM;
1216 *key_bits = 128;
1217 *iv_len = 12;
1218 break;
1219 case MBEDTLS_CIPHER_AES_192_CCM:
1220 *cipher_mode = MBEDTLS_MODE_CCM;
1221 *key_bits = 192;
1222 *iv_len = 12;
1223 break;
1224 case MBEDTLS_CIPHER_AES_256_CCM:
1225 *cipher_mode = MBEDTLS_MODE_CCM;
1226 *key_bits = 256;
1227 *iv_len = 12;
1228 break;
1229 case MBEDTLS_CIPHER_CAMELLIA_128_CCM:
1230 *cipher_mode = MBEDTLS_MODE_CCM;
1231 *key_bits = 128;
1232 *iv_len = 12;
1233 break;
1234 case MBEDTLS_CIPHER_CAMELLIA_192_CCM:
1235 *cipher_mode = MBEDTLS_MODE_CCM;
1236 *key_bits = 192;
1237 *iv_len = 12;
1238 break;
1239 case MBEDTLS_CIPHER_CAMELLIA_256_CCM:
1240 *cipher_mode = MBEDTLS_MODE_CCM;
1241 *key_bits = 256;
1242 *iv_len = 12;
1243 break;
1244
1245 case MBEDTLS_CIPHER_AES_128_GCM:
1246 *cipher_mode = MBEDTLS_MODE_GCM;
1247 *key_bits = 128;
1248 *iv_len = 12;
1249 break;
1250 case MBEDTLS_CIPHER_AES_192_GCM:
1251 *cipher_mode = MBEDTLS_MODE_GCM;
1252 *key_bits = 192;
1253 *iv_len = 12;
1254 break;
1255 case MBEDTLS_CIPHER_AES_256_GCM:
1256 *cipher_mode = MBEDTLS_MODE_GCM;
1257 *key_bits = 256;
1258 *iv_len = 12;
1259 break;
1260 case MBEDTLS_CIPHER_CAMELLIA_128_GCM:
1261 *cipher_mode = MBEDTLS_MODE_GCM;
1262 *key_bits = 128;
1263 *iv_len = 12;
1264 break;
1265 case MBEDTLS_CIPHER_CAMELLIA_192_GCM:
1266 *cipher_mode = MBEDTLS_MODE_GCM;
1267 *key_bits = 192;
1268 *iv_len = 12;
1269 break;
1270 case MBEDTLS_CIPHER_CAMELLIA_256_GCM:
1271 *cipher_mode = MBEDTLS_MODE_GCM;
1272 *key_bits = 256;
1273 *iv_len = 12;
1274 break;
1275
1276 case MBEDTLS_CIPHER_CHACHA20_POLY1305:
1277 *cipher_mode = MBEDTLS_MODE_CHACHAPOLY;
1278 *key_bits = 256;
1279 *iv_len = 12;
1280 break;
1281
1282 case MBEDTLS_CIPHER_NULL:
1283 *cipher_mode = MBEDTLS_MODE_STREAM;
1284 *key_bits = 0;
1285 *iv_len = 0;
1286 break;
1287
1288 default:
1289 *cipher_mode = MBEDTLS_MODE_NONE;
1290 *key_bits = 0;
1291 *iv_len = 0;
1292 }
1293}
1294
Yanray Wange6afd912022-10-27 12:11:18 +08001295int mbedtls_test_ssl_build_transforms(mbedtls_ssl_transform *t_in,
1296 mbedtls_ssl_transform *t_out,
1297 int cipher_type, int hash_id,
1298 int etm, int tag_mode,
1299 mbedtls_ssl_protocol_version tls_version,
1300 size_t cid0_len,
1301 size_t cid1_len)
1302{
Valerio Setti31ad3a12023-10-27 11:55:02 +02001303 mbedtls_cipher_mode_t cipher_mode = MBEDTLS_MODE_NONE;
1304 size_t key_bits = 0;
Yanray Wange6afd912022-10-27 12:11:18 +08001305 int ret = 0;
1306
1307#if defined(MBEDTLS_USE_PSA_CRYPTO)
1308 psa_key_type_t key_type;
1309 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
1310 psa_algorithm_t alg;
Yanray Wange6afd912022-10-27 12:11:18 +08001311 psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
Valerio Setti3d59ebe2023-10-30 11:56:56 +01001312#else
Valerio Setti31ad3a12023-10-27 11:55:02 +02001313 mbedtls_cipher_info_t const *cipher_info;
Yanray Wange6afd912022-10-27 12:11:18 +08001314#endif
1315
Valerio Setti31ad3a12023-10-27 11:55:02 +02001316 size_t keylen, maclen, ivlen = 0;
Yanray Wange6afd912022-10-27 12:11:18 +08001317 unsigned char *key0 = NULL, *key1 = NULL;
1318 unsigned char *md0 = NULL, *md1 = NULL;
1319 unsigned char iv_enc[16], iv_dec[16];
1320
1321#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
1322 unsigned char cid0[SSL_CID_LEN_MIN];
1323 unsigned char cid1[SSL_CID_LEN_MIN];
1324
1325 mbedtls_test_rnd_std_rand(NULL, cid0, sizeof(cid0));
1326 mbedtls_test_rnd_std_rand(NULL, cid1, sizeof(cid1));
1327#else
1328 ((void) cid0_len);
1329 ((void) cid1_len);
1330#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
1331
1332 maclen = 0;
Valerio Setti31ad3a12023-10-27 11:55:02 +02001333 mbedtls_test_ssl_cipher_info_from_type((mbedtls_cipher_type_t) cipher_type,
1334 &cipher_mode, &key_bits, &ivlen);
Yanray Wange6afd912022-10-27 12:11:18 +08001335
1336 /* Pick keys */
Valerio Setti31ad3a12023-10-27 11:55:02 +02001337 keylen = key_bits / 8;
Yanray Wange6afd912022-10-27 12:11:18 +08001338 /* Allocate `keylen + 1` bytes to ensure that we get
1339 * a non-NULL pointers from `mbedtls_calloc` even if
1340 * `keylen == 0` in the case of the NULL cipher. */
1341 CHK((key0 = mbedtls_calloc(1, keylen + 1)) != NULL);
1342 CHK((key1 = mbedtls_calloc(1, keylen + 1)) != NULL);
1343 memset(key0, 0x1, keylen);
1344 memset(key1, 0x2, keylen);
1345
1346#if !defined(MBEDTLS_USE_PSA_CRYPTO)
Valerio Setti31ad3a12023-10-27 11:55:02 +02001347 /* Pick cipher */
1348 cipher_info = mbedtls_cipher_info_from_type((mbedtls_cipher_type_t) cipher_type);
1349 CHK(cipher_info != NULL);
1350 CHK(mbedtls_cipher_info_get_iv_size(cipher_info) <= 16);
1351 CHK(mbedtls_cipher_info_get_key_bitlen(cipher_info) % 8 == 0);
Valerio Setti3d59ebe2023-10-30 11:56:56 +01001352
Yanray Wange6afd912022-10-27 12:11:18 +08001353 /* Setup cipher contexts */
1354 CHK(mbedtls_cipher_setup(&t_in->cipher_ctx_enc, cipher_info) == 0);
1355 CHK(mbedtls_cipher_setup(&t_in->cipher_ctx_dec, cipher_info) == 0);
1356 CHK(mbedtls_cipher_setup(&t_out->cipher_ctx_enc, cipher_info) == 0);
1357 CHK(mbedtls_cipher_setup(&t_out->cipher_ctx_dec, cipher_info) == 0);
1358
1359#if defined(MBEDTLS_CIPHER_MODE_CBC)
Valerio Setti31ad3a12023-10-27 11:55:02 +02001360 if (cipher_mode == MBEDTLS_MODE_CBC) {
Yanray Wange6afd912022-10-27 12:11:18 +08001361 CHK(mbedtls_cipher_set_padding_mode(&t_in->cipher_ctx_enc,
1362 MBEDTLS_PADDING_NONE) == 0);
1363 CHK(mbedtls_cipher_set_padding_mode(&t_in->cipher_ctx_dec,
1364 MBEDTLS_PADDING_NONE) == 0);
1365 CHK(mbedtls_cipher_set_padding_mode(&t_out->cipher_ctx_enc,
1366 MBEDTLS_PADDING_NONE) == 0);
1367 CHK(mbedtls_cipher_set_padding_mode(&t_out->cipher_ctx_dec,
1368 MBEDTLS_PADDING_NONE) == 0);
1369 }
1370#endif /* MBEDTLS_CIPHER_MODE_CBC */
1371
1372 CHK(mbedtls_cipher_setkey(&t_in->cipher_ctx_enc, key0,
Yanray Wanga8f445e2022-11-03 11:51:59 +08001373 (keylen << 3 > INT_MAX) ? INT_MAX : (int) keylen << 3,
1374 MBEDTLS_ENCRYPT)
1375 == 0);
Yanray Wange6afd912022-10-27 12:11:18 +08001376 CHK(mbedtls_cipher_setkey(&t_in->cipher_ctx_dec, key1,
Yanray Wanga8f445e2022-11-03 11:51:59 +08001377 (keylen << 3 > INT_MAX) ? INT_MAX : (int) keylen << 3,
1378 MBEDTLS_DECRYPT)
1379 == 0);
Yanray Wange6afd912022-10-27 12:11:18 +08001380 CHK(mbedtls_cipher_setkey(&t_out->cipher_ctx_enc, key1,
Yanray Wanga8f445e2022-11-03 11:51:59 +08001381 (keylen << 3 > INT_MAX) ? INT_MAX : (int) keylen << 3,
1382 MBEDTLS_ENCRYPT)
1383 == 0);
Yanray Wange6afd912022-10-27 12:11:18 +08001384 CHK(mbedtls_cipher_setkey(&t_out->cipher_ctx_dec, key0,
Yanray Wanga8f445e2022-11-03 11:51:59 +08001385 (keylen << 3 > INT_MAX) ? INT_MAX : (int) keylen << 3,
1386 MBEDTLS_DECRYPT)
1387 == 0);
Valerio Setti31ad3a12023-10-27 11:55:02 +02001388#endif /* !MBEDTLS_USE_PSA_CRYPTO */
Yanray Wange6afd912022-10-27 12:11:18 +08001389
1390 /* Setup MAC contexts */
1391#if defined(MBEDTLS_SSL_SOME_SUITES_USE_MAC)
Valerio Setti31ad3a12023-10-27 11:55:02 +02001392 if (cipher_mode == MBEDTLS_MODE_CBC ||
1393 cipher_mode == MBEDTLS_MODE_STREAM) {
Yanray Wange6afd912022-10-27 12:11:18 +08001394#if !defined(MBEDTLS_USE_PSA_CRYPTO)
Agathiyan Bragadeesh2f017a82023-07-12 11:21:54 +01001395 mbedtls_md_info_t const *md_info = mbedtls_md_info_from_type((mbedtls_md_type_t) hash_id);
Yanray Wange6afd912022-10-27 12:11:18 +08001396 CHK(md_info != NULL);
1397#endif
Agathiyan Bragadeesh2f017a82023-07-12 11:21:54 +01001398 maclen = mbedtls_md_get_size_from_type((mbedtls_md_type_t) hash_id);
Yanray Wange6afd912022-10-27 12:11:18 +08001399 CHK(maclen != 0);
1400 /* Pick hash keys */
1401 CHK((md0 = mbedtls_calloc(1, maclen)) != NULL);
1402 CHK((md1 = mbedtls_calloc(1, maclen)) != NULL);
1403 memset(md0, 0x5, maclen);
1404 memset(md1, 0x6, maclen);
1405
1406#if defined(MBEDTLS_USE_PSA_CRYPTO)
Manuel Pégourié-Gonnard2d6d9932023-03-28 11:38:08 +02001407 alg = mbedtls_md_psa_alg_from_type(hash_id);
Yanray Wange6afd912022-10-27 12:11:18 +08001408
1409 CHK(alg != 0);
1410
1411 t_out->psa_mac_alg = PSA_ALG_HMAC(alg);
1412 t_in->psa_mac_alg = PSA_ALG_HMAC(alg);
1413 t_in->psa_mac_enc = MBEDTLS_SVC_KEY_ID_INIT;
1414 t_out->psa_mac_enc = MBEDTLS_SVC_KEY_ID_INIT;
1415 t_in->psa_mac_dec = MBEDTLS_SVC_KEY_ID_INIT;
1416 t_out->psa_mac_dec = MBEDTLS_SVC_KEY_ID_INIT;
1417
1418 psa_reset_key_attributes(&attributes);
1419 psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_SIGN_MESSAGE);
1420 psa_set_key_algorithm(&attributes, PSA_ALG_HMAC(alg));
1421 psa_set_key_type(&attributes, PSA_KEY_TYPE_HMAC);
1422
1423 CHK(psa_import_key(&attributes,
1424 md0, maclen,
1425 &t_in->psa_mac_enc) == PSA_SUCCESS);
1426
1427 CHK(psa_import_key(&attributes,
1428 md1, maclen,
1429 &t_out->psa_mac_enc) == PSA_SUCCESS);
1430
Valerio Setti31ad3a12023-10-27 11:55:02 +02001431 if (cipher_mode == MBEDTLS_MODE_STREAM ||
Yanray Wange6afd912022-10-27 12:11:18 +08001432 etm == MBEDTLS_SSL_ETM_DISABLED) {
1433 /* mbedtls_ct_hmac() requires the key to be exportable */
1434 psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_EXPORT |
1435 PSA_KEY_USAGE_VERIFY_HASH);
1436 } else {
1437 psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_VERIFY_HASH);
1438 }
1439
1440 CHK(psa_import_key(&attributes,
1441 md1, maclen,
1442 &t_in->psa_mac_dec) == PSA_SUCCESS);
1443
1444 CHK(psa_import_key(&attributes,
1445 md0, maclen,
1446 &t_out->psa_mac_dec) == PSA_SUCCESS);
1447#else
1448 CHK(mbedtls_md_setup(&t_out->md_ctx_enc, md_info, 1) == 0);
1449 CHK(mbedtls_md_setup(&t_out->md_ctx_dec, md_info, 1) == 0);
1450 CHK(mbedtls_md_setup(&t_in->md_ctx_enc, md_info, 1) == 0);
1451 CHK(mbedtls_md_setup(&t_in->md_ctx_dec, md_info, 1) == 0);
1452
1453 CHK(mbedtls_md_hmac_starts(&t_in->md_ctx_enc,
1454 md0, maclen) == 0);
1455 CHK(mbedtls_md_hmac_starts(&t_in->md_ctx_dec,
1456 md1, maclen) == 0);
1457 CHK(mbedtls_md_hmac_starts(&t_out->md_ctx_enc,
1458 md1, maclen) == 0);
1459 CHK(mbedtls_md_hmac_starts(&t_out->md_ctx_dec,
1460 md0, maclen) == 0);
1461#endif
1462 }
1463#else
1464 ((void) hash_id);
1465#endif /* MBEDTLS_SSL_SOME_SUITES_USE_MAC */
1466
1467
1468 /* Pick IV's (regardless of whether they
1469 * are being used by the transform). */
Yanray Wange6afd912022-10-27 12:11:18 +08001470 memset(iv_enc, 0x3, sizeof(iv_enc));
1471 memset(iv_dec, 0x4, sizeof(iv_dec));
1472
1473 /*
1474 * Setup transforms
1475 */
1476
1477#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC) && \
1478 defined(MBEDTLS_SSL_SOME_SUITES_USE_MAC)
1479 t_out->encrypt_then_mac = etm;
1480 t_in->encrypt_then_mac = etm;
1481#else
1482 ((void) etm);
1483#endif
1484
1485 t_out->tls_version = tls_version;
1486 t_in->tls_version = tls_version;
1487 t_out->ivlen = ivlen;
1488 t_in->ivlen = ivlen;
1489
Valerio Setti31ad3a12023-10-27 11:55:02 +02001490 switch (cipher_mode) {
Yanray Wange6afd912022-10-27 12:11:18 +08001491 case MBEDTLS_MODE_GCM:
1492 case MBEDTLS_MODE_CCM:
1493#if defined(MBEDTLS_SSL_PROTO_TLS1_3)
1494 if (tls_version == MBEDTLS_SSL_VERSION_TLS1_3) {
1495 t_out->fixed_ivlen = 12;
1496 t_in->fixed_ivlen = 12;
1497 } else
1498#endif /* MBEDTLS_SSL_PROTO_TLS1_3 */
1499 {
1500 t_out->fixed_ivlen = 4;
1501 t_in->fixed_ivlen = 4;
1502 }
1503 t_out->maclen = 0;
1504 t_in->maclen = 0;
1505 switch (tag_mode) {
1506 case 0: /* Full tag */
1507 t_out->taglen = 16;
1508 t_in->taglen = 16;
1509 break;
1510 case 1: /* Partial tag */
1511 t_out->taglen = 8;
1512 t_in->taglen = 8;
1513 break;
1514 default:
1515 ret = 1;
1516 goto cleanup;
1517 }
1518 break;
1519
1520 case MBEDTLS_MODE_CHACHAPOLY:
1521 t_out->fixed_ivlen = 12;
1522 t_in->fixed_ivlen = 12;
1523 t_out->maclen = 0;
1524 t_in->maclen = 0;
1525 switch (tag_mode) {
1526 case 0: /* Full tag */
1527 t_out->taglen = 16;
1528 t_in->taglen = 16;
1529 break;
1530 case 1: /* Partial tag */
1531 t_out->taglen = 8;
1532 t_in->taglen = 8;
1533 break;
1534 default:
1535 ret = 1;
1536 goto cleanup;
1537 }
1538 break;
1539
1540 case MBEDTLS_MODE_STREAM:
1541 case MBEDTLS_MODE_CBC:
1542 t_out->fixed_ivlen = 0; /* redundant, must be 0 */
1543 t_in->fixed_ivlen = 0; /* redundant, must be 0 */
1544 t_out->taglen = 0;
1545 t_in->taglen = 0;
1546 switch (tag_mode) {
1547 case 0: /* Full tag */
1548 t_out->maclen = maclen;
1549 t_in->maclen = maclen;
1550 break;
1551 default:
1552 ret = 1;
1553 goto cleanup;
1554 }
1555 break;
1556 default:
1557 ret = 1;
1558 goto cleanup;
1559 break;
1560 }
1561
1562 /* Setup IV's */
1563
1564 memcpy(&t_in->iv_dec, iv_dec, sizeof(iv_dec));
1565 memcpy(&t_in->iv_enc, iv_enc, sizeof(iv_enc));
1566 memcpy(&t_out->iv_dec, iv_enc, sizeof(iv_enc));
1567 memcpy(&t_out->iv_enc, iv_dec, sizeof(iv_dec));
1568
1569#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
1570 /* Add CID */
1571 memcpy(&t_in->in_cid, cid0, cid0_len);
1572 memcpy(&t_in->out_cid, cid1, cid1_len);
Yanray Wanga8f445e2022-11-03 11:51:59 +08001573 t_in->in_cid_len = (uint8_t) cid0_len;
1574 t_in->out_cid_len = (uint8_t) cid1_len;
Yanray Wange6afd912022-10-27 12:11:18 +08001575 memcpy(&t_out->in_cid, cid1, cid1_len);
1576 memcpy(&t_out->out_cid, cid0, cid0_len);
Yanray Wanga8f445e2022-11-03 11:51:59 +08001577 t_out->in_cid_len = (uint8_t) cid1_len;
1578 t_out->out_cid_len = (uint8_t) cid0_len;
Yanray Wange6afd912022-10-27 12:11:18 +08001579#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
1580
1581#if defined(MBEDTLS_USE_PSA_CRYPTO)
1582 status = mbedtls_ssl_cipher_to_psa(cipher_type,
1583 t_in->taglen,
1584 &alg,
1585 &key_type,
1586 &key_bits);
1587
1588 if (status != PSA_SUCCESS) {
1589 ret = PSA_TO_MBEDTLS_ERR(status);
1590 goto cleanup;
1591 }
1592
1593 t_in->psa_alg = alg;
1594 t_out->psa_alg = alg;
1595
1596 if (alg != MBEDTLS_SSL_NULL_CIPHER) {
1597 psa_reset_key_attributes(&attributes);
1598 psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_ENCRYPT);
1599 psa_set_key_algorithm(&attributes, alg);
1600 psa_set_key_type(&attributes, key_type);
1601
1602 status = psa_import_key(&attributes,
1603 key0,
1604 PSA_BITS_TO_BYTES(key_bits),
1605 &t_in->psa_key_enc);
1606
1607 if (status != PSA_SUCCESS) {
1608 ret = PSA_TO_MBEDTLS_ERR(status);
1609 goto cleanup;
1610 }
1611
1612 status = psa_import_key(&attributes,
1613 key1,
1614 PSA_BITS_TO_BYTES(key_bits),
1615 &t_out->psa_key_enc);
1616
1617 if (status != PSA_SUCCESS) {
1618 ret = PSA_TO_MBEDTLS_ERR(status);
1619 goto cleanup;
1620 }
1621
1622 psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_DECRYPT);
1623
1624 status = psa_import_key(&attributes,
1625 key1,
1626 PSA_BITS_TO_BYTES(key_bits),
1627 &t_in->psa_key_dec);
1628
1629 if (status != PSA_SUCCESS) {
1630 ret = PSA_TO_MBEDTLS_ERR(status);
1631 goto cleanup;
1632 }
1633
1634 status = psa_import_key(&attributes,
1635 key0,
1636 PSA_BITS_TO_BYTES(key_bits),
1637 &t_out->psa_key_dec);
1638
1639 if (status != PSA_SUCCESS) {
1640 ret = PSA_TO_MBEDTLS_ERR(status);
1641 goto cleanup;
1642 }
1643 }
1644#endif /* MBEDTLS_USE_PSA_CRYPTO */
1645
1646cleanup:
1647
1648 mbedtls_free(key0);
1649 mbedtls_free(key1);
1650
1651 mbedtls_free(md0);
1652 mbedtls_free(md1);
1653
1654 return ret;
1655}
1656
Gilles Peskine9099d3f2023-09-18 13:11:50 +02001657#if defined(MBEDTLS_SSL_SOME_SUITES_USE_MAC)
1658int mbedtls_test_ssl_prepare_record_mac(mbedtls_record *record,
1659 mbedtls_ssl_transform *transform_out)
1660{
1661#if defined(MBEDTLS_USE_PSA_CRYPTO)
1662 psa_mac_operation_t operation = PSA_MAC_OPERATION_INIT;
1663#endif
1664
1665 /* Serialized version of record header for MAC purposes */
1666 unsigned char add_data[13];
1667 memcpy(add_data, record->ctr, 8);
1668 add_data[8] = record->type;
1669 add_data[9] = record->ver[0];
1670 add_data[10] = record->ver[1];
1671 add_data[11] = (record->data_len >> 8) & 0xff;
1672 add_data[12] = (record->data_len >> 0) & 0xff;
1673
1674 /* MAC with additional data */
1675#if defined(MBEDTLS_USE_PSA_CRYPTO)
1676 size_t sign_mac_length = 0;
1677 TEST_EQUAL(PSA_SUCCESS, psa_mac_sign_setup(&operation,
1678 transform_out->psa_mac_enc,
1679 transform_out->psa_mac_alg));
1680 TEST_EQUAL(PSA_SUCCESS, psa_mac_update(&operation, add_data, 13));
1681 TEST_EQUAL(PSA_SUCCESS, psa_mac_update(&operation,
1682 record->buf + record->data_offset,
1683 record->data_len));
1684 /* Use a temporary buffer for the MAC, because with the truncated HMAC
1685 * extension, there might not be enough room in the record for the
1686 * full-length MAC. */
1687 unsigned char mac[PSA_HASH_MAX_SIZE];
1688 TEST_EQUAL(PSA_SUCCESS, psa_mac_sign_finish(&operation,
1689 mac, sizeof(mac),
1690 &sign_mac_length));
1691#else
1692 TEST_EQUAL(0, mbedtls_md_hmac_update(&transform_out->md_ctx_enc, add_data, 13));
1693 TEST_EQUAL(0, mbedtls_md_hmac_update(&transform_out->md_ctx_enc,
1694 record->buf + record->data_offset,
1695 record->data_len));
1696 /* Use a temporary buffer for the MAC, because with the truncated HMAC
1697 * extension, there might not be enough room in the record for the
1698 * full-length MAC. */
1699 unsigned char mac[MBEDTLS_MD_MAX_SIZE];
1700 TEST_EQUAL(0, mbedtls_md_hmac_finish(&transform_out->md_ctx_enc, mac));
1701#endif
1702 memcpy(record->buf + record->data_offset + record->data_len, mac, transform_out->maclen);
1703 record->data_len += transform_out->maclen;
1704
1705 return 0;
1706
1707exit:
1708#if defined(MBEDTLS_USE_PSA_CRYPTO)
1709 psa_mac_abort(&operation);
1710#endif
1711 return -1;
1712}
1713#endif /* MBEDTLS_SSL_SOME_SUITES_USE_MAC */
1714
Jerry Yu28547c42023-10-31 14:42:50 +08001715#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
Yanray Wange6afd912022-10-27 12:11:18 +08001716int mbedtls_test_ssl_tls12_populate_session(mbedtls_ssl_session *session,
1717 int ticket_len,
Ronald Cron7b1921a2023-11-23 12:31:56 +01001718 int endpoint_type,
Yanray Wange6afd912022-10-27 12:11:18 +08001719 const char *crt_file)
1720{
Ronald Cronc57f86e2023-11-22 09:50:01 +01001721 (void) ticket_len;
1722
Yanray Wange6afd912022-10-27 12:11:18 +08001723#if defined(MBEDTLS_HAVE_TIME)
1724 session->start = mbedtls_time(NULL) - 42;
1725#endif
1726 session->tls_version = MBEDTLS_SSL_VERSION_TLS1_2;
Ronald Cronc7fa82e2024-02-09 09:33:09 +01001727
1728 TEST_ASSERT(endpoint_type == MBEDTLS_SSL_IS_CLIENT ||
1729 endpoint_type == MBEDTLS_SSL_IS_SERVER);
1730
1731 session->endpoint = endpoint_type;
Yanray Wange6afd912022-10-27 12:11:18 +08001732 session->ciphersuite = 0xabcd;
1733 session->id_len = sizeof(session->id);
1734 memset(session->id, 66, session->id_len);
1735 memset(session->master, 17, sizeof(session->master));
1736
1737#if defined(MBEDTLS_SSL_HANDSHAKE_WITH_CERT_ENABLED) && defined(MBEDTLS_FS_IO)
1738 if (crt_file != NULL && strlen(crt_file) != 0) {
1739 mbedtls_x509_crt tmp_crt;
1740 int ret;
1741
1742 mbedtls_x509_crt_init(&tmp_crt);
1743 ret = mbedtls_x509_crt_parse_file(&tmp_crt, crt_file);
1744 if (ret != 0) {
1745 return ret;
1746 }
1747
1748#if defined(MBEDTLS_SSL_KEEP_PEER_CERTIFICATE)
1749 /* Move temporary CRT. */
1750 session->peer_cert = mbedtls_calloc(1, sizeof(*session->peer_cert));
1751 if (session->peer_cert == NULL) {
1752 return -1;
1753 }
1754 *session->peer_cert = tmp_crt;
1755 memset(&tmp_crt, 0, sizeof(tmp_crt));
1756#else /* MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
1757 /* Calculate digest of temporary CRT. */
1758 session->peer_cert_digest =
1759 mbedtls_calloc(1, MBEDTLS_SSL_PEER_CERT_DIGEST_DFL_LEN);
1760 if (session->peer_cert_digest == NULL) {
1761 return -1;
1762 }
1763
1764#if defined(MBEDTLS_USE_PSA_CRYPTO)
Manuel Pégourié-Gonnard2d6d9932023-03-28 11:38:08 +02001765 psa_algorithm_t psa_alg = mbedtls_md_psa_alg_from_type(
Yanray Wange6afd912022-10-27 12:11:18 +08001766 MBEDTLS_SSL_PEER_CERT_DIGEST_DFL_TYPE);
1767 size_t hash_size = 0;
1768 psa_status_t status = psa_hash_compute(
1769 psa_alg, tmp_crt.raw.p,
1770 tmp_crt.raw.len,
1771 session->peer_cert_digest,
1772 MBEDTLS_SSL_PEER_CERT_DIGEST_DFL_LEN,
1773 &hash_size);
1774 ret = PSA_TO_MBEDTLS_ERR(status);
1775#else
1776 ret = mbedtls_md(mbedtls_md_info_from_type(
1777 MBEDTLS_SSL_PEER_CERT_DIGEST_DFL_TYPE),
1778 tmp_crt.raw.p, tmp_crt.raw.len,
1779 session->peer_cert_digest);
1780#endif /* MBEDTLS_USE_PSA_CRYPTO */
1781 if (ret != 0) {
1782 return ret;
1783 }
1784 session->peer_cert_digest_type =
1785 MBEDTLS_SSL_PEER_CERT_DIGEST_DFL_TYPE;
1786 session->peer_cert_digest_len =
1787 MBEDTLS_SSL_PEER_CERT_DIGEST_DFL_LEN;
1788#endif /* MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
1789
1790 mbedtls_x509_crt_free(&tmp_crt);
1791 }
1792#else /* MBEDTLS_SSL_HANDSHAKE_WITH_CERT_ENABLED && MBEDTLS_FS_IO */
1793 (void) crt_file;
1794#endif /* MBEDTLS_SSL_HANDSHAKE_WITH_CERT_ENABLED && MBEDTLS_FS_IO */
1795 session->verify_result = 0xdeadbeef;
1796
Ronald Cronc57f86e2023-11-22 09:50:01 +01001797#if defined(MBEDTLS_SSL_SESSION_TICKETS)
1798#if defined(MBEDTLS_SSL_CLI_C)
Yanray Wange6afd912022-10-27 12:11:18 +08001799 if (ticket_len != 0) {
1800 session->ticket = mbedtls_calloc(1, ticket_len);
1801 if (session->ticket == NULL) {
1802 return -1;
1803 }
1804 memset(session->ticket, 33, ticket_len);
1805 }
1806 session->ticket_len = ticket_len;
1807 session->ticket_lifetime = 86401;
Ronald Cronc57f86e2023-11-22 09:50:01 +01001808#endif /* MBEDTLS_SSL_CLI_C */
1809
1810#if defined(MBEDTLS_SSL_SRV_C) && defined(MBEDTLS_HAVE_TIME)
1811 if (session->endpoint == MBEDTLS_SSL_IS_SERVER) {
1812 session->ticket_creation_time = mbedtls_ms_time() - 42;
1813 }
Yanray Wange6afd912022-10-27 12:11:18 +08001814#endif
Ronald Cronc57f86e2023-11-22 09:50:01 +01001815#endif /* MBEDTLS_SSL_SESSION_TICKETS */
Yanray Wange6afd912022-10-27 12:11:18 +08001816
1817#if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
1818 session->mfl_code = 1;
1819#endif
1820#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
1821 session->encrypt_then_mac = 1;
1822#endif
1823
Ronald Cronc7fa82e2024-02-09 09:33:09 +01001824exit:
Yanray Wange6afd912022-10-27 12:11:18 +08001825 return 0;
1826}
Jerry Yu28547c42023-10-31 14:42:50 +08001827#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
Yanray Wange6afd912022-10-27 12:11:18 +08001828
1829#if defined(MBEDTLS_SSL_PROTO_TLS1_3)
1830int mbedtls_test_ssl_tls13_populate_session(mbedtls_ssl_session *session,
1831 int ticket_len,
1832 int endpoint_type)
1833{
1834 ((void) ticket_len);
1835 session->tls_version = MBEDTLS_SSL_VERSION_TLS1_3;
1836 session->endpoint = endpoint_type == MBEDTLS_SSL_IS_CLIENT ?
1837 MBEDTLS_SSL_IS_CLIENT : MBEDTLS_SSL_IS_SERVER;
1838 session->ciphersuite = 0xabcd;
Ronald Cron18b92a12024-03-26 10:15:08 +01001839
1840#if defined(MBEDTLS_SSL_SESSION_TICKETS)
Yanray Wange6afd912022-10-27 12:11:18 +08001841 session->ticket_age_add = 0x87654321;
1842 session->ticket_flags = 0x7;
Yanray Wange6afd912022-10-27 12:11:18 +08001843 session->resumption_key_len = 32;
1844 memset(session->resumption_key, 0x99, sizeof(session->resumption_key));
Yanray Wange6afd912022-10-27 12:11:18 +08001845#endif
1846
Ronald Cron18b92a12024-03-26 10:15:08 +01001847#if defined(MBEDTLS_SSL_SRV_C)
1848 if (session->endpoint == MBEDTLS_SSL_IS_SERVER) {
1849#if defined(MBEDTLS_SSL_SESSION_TICKETS)
1850#if defined(MBEDTLS_SSL_EARLY_DATA) && defined(MBEDTLS_SSL_ALPN)
1851 int ret = mbedtls_ssl_session_set_ticket_alpn(session, "ALPNExample");
1852 if (ret != 0) {
1853 return -1;
1854 }
1855#endif
1856#if defined(MBEDTLS_HAVE_TIME)
1857 session->ticket_creation_time = mbedtls_ms_time() - 42;
1858#endif
1859#endif /* MBEDTLS_SSL_SESSION_TICKETS */
1860 }
1861#endif /* MBEDTLS_SSL_SRV_C */
1862
Yanray Wange6afd912022-10-27 12:11:18 +08001863#if defined(MBEDTLS_SSL_CLI_C)
1864 if (session->endpoint == MBEDTLS_SSL_IS_CLIENT) {
Ronald Cron18b92a12024-03-26 10:15:08 +01001865#if defined(MBEDTLS_SSL_SESSION_TICKETS)
Yanray Wange6afd912022-10-27 12:11:18 +08001866#if defined(MBEDTLS_HAVE_TIME)
Jerry Yu342a5552023-11-10 14:23:39 +08001867 session->ticket_reception_time = mbedtls_ms_time() - 40;
Yanray Wange6afd912022-10-27 12:11:18 +08001868#endif
1869 session->ticket_lifetime = 0xfedcba98;
1870
1871 session->ticket_len = ticket_len;
1872 if (ticket_len != 0) {
1873 session->ticket = mbedtls_calloc(1, ticket_len);
1874 if (session->ticket == NULL) {
1875 return -1;
1876 }
1877 memset(session->ticket, 33, ticket_len);
1878 }
Ronald Cron8d15e012024-03-27 09:30:13 +01001879#if defined(MBEDTLS_SSL_SERVER_NAME_INDICATION)
1880 char hostname[] = "hostname example";
1881 session->hostname = mbedtls_calloc(1, sizeof(hostname));
1882 if (session->hostname == NULL) {
1883 return -1;
1884 }
1885 memcpy(session->hostname, hostname, sizeof(hostname));
1886#endif
Ronald Cron18b92a12024-03-26 10:15:08 +01001887#endif /* MBEDTLS_SSL_SESSION_TICKETS */
Yanray Wange6afd912022-10-27 12:11:18 +08001888 }
1889#endif /* MBEDTLS_SSL_CLI_C */
1890
Ronald Cron18b92a12024-03-26 10:15:08 +01001891#if defined(MBEDTLS_SSL_EARLY_DATA)
1892 session->max_early_data_size = 0x87654321;
1893#endif /* MBEDTLS_SSL_EARLY_DATA */
1894
Waleed Elmelegy049cd302023-12-20 17:28:31 +00001895#if defined(MBEDTLS_SSL_RECORD_SIZE_LIMIT)
1896 session->record_size_limit = 2048;
1897#endif
1898
Yanray Wange6afd912022-10-27 12:11:18 +08001899 return 0;
1900}
1901#endif /* MBEDTLS_SSL_PROTO_TLS1_3 */
1902
Yanray Wangb088bfc2023-03-16 12:15:49 +08001903int mbedtls_test_ssl_exchange_data(
1904 mbedtls_ssl_context *ssl_1,
1905 int msg_len_1, const int expected_fragments_1,
1906 mbedtls_ssl_context *ssl_2,
1907 int msg_len_2, const int expected_fragments_2)
Yanray Wange6afd912022-10-27 12:11:18 +08001908{
1909 unsigned char *msg_buf_1 = malloc(msg_len_1);
1910 unsigned char *msg_buf_2 = malloc(msg_len_2);
1911 unsigned char *in_buf_1 = malloc(msg_len_2);
1912 unsigned char *in_buf_2 = malloc(msg_len_1);
1913 int msg_type, ret = -1;
1914
1915 /* Perform this test with two message types. At first use a message
1916 * consisting of only 0x00 for the client and only 0xFF for the server.
1917 * At the second time use message with generated data */
1918 for (msg_type = 0; msg_type < 2; msg_type++) {
1919 int written_1 = 0;
1920 int written_2 = 0;
1921 int read_1 = 0;
1922 int read_2 = 0;
1923 int fragments_1 = 0;
1924 int fragments_2 = 0;
1925
1926 if (msg_type == 0) {
1927 memset(msg_buf_1, 0x00, msg_len_1);
1928 memset(msg_buf_2, 0xff, msg_len_2);
1929 } else {
1930 int i, j = 0;
1931 for (i = 0; i < msg_len_1; i++) {
1932 msg_buf_1[i] = j++ & 0xFF;
1933 }
1934 for (i = 0; i < msg_len_2; i++) {
1935 msg_buf_2[i] = (j -= 5) & 0xFF;
1936 }
1937 }
1938
1939 while (read_1 < msg_len_2 || read_2 < msg_len_1) {
1940 /* ssl_1 sending */
1941 if (msg_len_1 > written_1) {
1942 ret = mbedtls_ssl_write_fragment(ssl_1, msg_buf_1,
1943 msg_len_1, &written_1,
1944 expected_fragments_1);
1945 if (expected_fragments_1 == 0) {
1946 /* This error is expected when the message is too large and
1947 * cannot be fragmented */
Gilles Peskine353eb332025-05-14 17:42:53 +02001948 TEST_EQUAL(ret, MBEDTLS_ERR_SSL_BAD_INPUT_DATA);
Yanray Wange6afd912022-10-27 12:11:18 +08001949 msg_len_1 = 0;
1950 } else {
Gilles Peskine353eb332025-05-14 17:42:53 +02001951 TEST_EQUAL(ret, 0);
Yanray Wange6afd912022-10-27 12:11:18 +08001952 }
1953 }
1954
1955 /* ssl_2 sending */
1956 if (msg_len_2 > written_2) {
1957 ret = mbedtls_ssl_write_fragment(ssl_2, msg_buf_2,
1958 msg_len_2, &written_2,
1959 expected_fragments_2);
1960 if (expected_fragments_2 == 0) {
1961 /* This error is expected when the message is too large and
1962 * cannot be fragmented */
Gilles Peskine353eb332025-05-14 17:42:53 +02001963 TEST_EQUAL(ret, MBEDTLS_ERR_SSL_BAD_INPUT_DATA);
Yanray Wange6afd912022-10-27 12:11:18 +08001964 msg_len_2 = 0;
1965 } else {
Gilles Peskine353eb332025-05-14 17:42:53 +02001966 TEST_EQUAL(ret, 0);
Yanray Wange6afd912022-10-27 12:11:18 +08001967 }
1968 }
1969
1970 /* ssl_1 reading */
1971 if (read_1 < msg_len_2) {
1972 ret = mbedtls_ssl_read_fragment(ssl_1, in_buf_1,
1973 msg_len_2, &read_1,
1974 &fragments_2,
1975 expected_fragments_2);
Gilles Peskine353eb332025-05-14 17:42:53 +02001976 TEST_EQUAL(ret, 0);
Yanray Wange6afd912022-10-27 12:11:18 +08001977 }
1978
1979 /* ssl_2 reading */
1980 if (read_2 < msg_len_1) {
1981 ret = mbedtls_ssl_read_fragment(ssl_2, in_buf_2,
1982 msg_len_1, &read_2,
1983 &fragments_1,
1984 expected_fragments_1);
Gilles Peskine353eb332025-05-14 17:42:53 +02001985 TEST_EQUAL(ret, 0);
Yanray Wange6afd912022-10-27 12:11:18 +08001986 }
1987 }
1988
1989 ret = -1;
Gilles Peskine353eb332025-05-14 17:42:53 +02001990 TEST_EQUAL(0, memcmp(msg_buf_1, in_buf_2, msg_len_1));
1991 TEST_EQUAL(0, memcmp(msg_buf_2, in_buf_1, msg_len_2));
1992 TEST_EQUAL(fragments_1, expected_fragments_1);
1993 TEST_EQUAL(fragments_2, expected_fragments_2);
Yanray Wange6afd912022-10-27 12:11:18 +08001994 }
1995
1996 ret = 0;
1997
1998exit:
1999 free(msg_buf_1);
2000 free(in_buf_1);
2001 free(msg_buf_2);
2002 free(in_buf_2);
2003
2004 return ret;
2005}
2006
2007/*
2008 * Perform data exchanging between \p ssl_1 and \p ssl_2. Both of endpoints
2009 * must be initialized and connected beforehand.
2010 *
2011 * \retval 0 on success, otherwise error code.
2012 */
Yanray Wangead70c82023-03-16 12:04:49 +08002013#if defined(MBEDTLS_SSL_HANDSHAKE_WITH_CERT_ENABLED) && \
2014 (defined(MBEDTLS_SSL_RENEGOTIATION) || \
2015 defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH))
2016static int exchange_data(mbedtls_ssl_context *ssl_1,
2017 mbedtls_ssl_context *ssl_2)
Yanray Wange6afd912022-10-27 12:11:18 +08002018{
Yanray Wangb088bfc2023-03-16 12:15:49 +08002019 return mbedtls_test_ssl_exchange_data(ssl_1, 256, 1,
2020 ssl_2, 256, 1);
Yanray Wange6afd912022-10-27 12:11:18 +08002021}
Yanray Wangead70c82023-03-16 12:04:49 +08002022#endif /* MBEDTLS_SSL_HANDSHAKE_WITH_CERT_ENABLED &&
2023 (MBEDTLS_SSL_RENEGOTIATION ||
2024 MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH) */
Yanray Wange6afd912022-10-27 12:11:18 +08002025
2026#if defined(MBEDTLS_SSL_HANDSHAKE_WITH_CERT_ENABLED)
2027static int check_ssl_version(
2028 mbedtls_ssl_protocol_version expected_negotiated_version,
2029 const mbedtls_ssl_context *ssl)
2030{
2031 const char *version_string = mbedtls_ssl_get_version(ssl);
2032 mbedtls_ssl_protocol_version version_number =
2033 mbedtls_ssl_get_version_number(ssl);
2034
2035 TEST_EQUAL(ssl->tls_version, expected_negotiated_version);
2036
2037 if (ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM) {
2038 TEST_EQUAL(version_string[0], 'D');
2039 ++version_string;
2040 }
2041
2042 switch (expected_negotiated_version) {
2043 case MBEDTLS_SSL_VERSION_TLS1_2:
2044 TEST_EQUAL(version_number, MBEDTLS_SSL_VERSION_TLS1_2);
Gilles Peskine353eb332025-05-14 17:42:53 +02002045 TEST_EQUAL(strcmp(version_string, "TLSv1.2"), 0);
Yanray Wange6afd912022-10-27 12:11:18 +08002046 break;
2047
2048 case MBEDTLS_SSL_VERSION_TLS1_3:
2049 TEST_EQUAL(version_number, MBEDTLS_SSL_VERSION_TLS1_3);
Gilles Peskine353eb332025-05-14 17:42:53 +02002050 TEST_EQUAL(strcmp(version_string, "TLSv1.3"), 0);
Yanray Wange6afd912022-10-27 12:11:18 +08002051 break;
2052
2053 default:
Agathiyan Bragadeeshdc28a5a2023-07-18 11:45:28 +01002054 TEST_FAIL(
Agathiyan Bragadeeshebb40bc2023-07-14 17:28:27 +01002055 "Version check not implemented for this protocol version");
Yanray Wange6afd912022-10-27 12:11:18 +08002056 }
2057
2058 return 1;
2059
2060exit:
2061 return 0;
2062}
2063#endif /* MBEDTLS_SSL_HANDSHAKE_WITH_CERT_ENABLED */
2064
Yanray Wange6afd912022-10-27 12:11:18 +08002065#if defined(MBEDTLS_SSL_HANDSHAKE_WITH_CERT_ENABLED)
Max Fillingercf007ca2024-10-29 16:57:09 +01002066int mbedtls_test_ssl_do_handshake_with_endpoints(
2067 mbedtls_test_ssl_endpoint *server_ep,
2068 mbedtls_test_ssl_endpoint *client_ep,
Max Fillinger8f12e312024-10-30 00:29:37 +01002069 mbedtls_test_handshake_test_options *options,
Max Fillingercf007ca2024-10-29 16:57:09 +01002070 mbedtls_ssl_protocol_version proto)
2071{
2072 enum { BUFFSIZE = 1024 };
2073
2074 int ret = -1;
Max Fillingercf007ca2024-10-29 16:57:09 +01002075
Max Fillingeree467aa2024-11-08 22:17:33 +01002076 mbedtls_platform_zeroize(server_ep, sizeof(mbedtls_test_ssl_endpoint));
2077 mbedtls_platform_zeroize(client_ep, sizeof(mbedtls_test_ssl_endpoint));
2078
Max Fillinger8f12e312024-10-30 00:29:37 +01002079 mbedtls_test_init_handshake_options(options);
2080 options->server_min_version = proto;
2081 options->client_min_version = proto;
2082 options->server_max_version = proto;
2083 options->client_max_version = proto;
Max Fillingercf007ca2024-10-29 16:57:09 +01002084
Max Fillinger8f12e312024-10-30 00:29:37 +01002085 ret = mbedtls_test_ssl_endpoint_init(client_ep, MBEDTLS_SSL_IS_CLIENT, options,
Max Fillingercf007ca2024-10-29 16:57:09 +01002086 NULL, NULL, NULL);
2087 if (ret != 0) {
2088 return ret;
2089 }
Max Fillinger8f12e312024-10-30 00:29:37 +01002090 ret = mbedtls_test_ssl_endpoint_init(server_ep, MBEDTLS_SSL_IS_SERVER, options,
Max Fillingercf007ca2024-10-29 16:57:09 +01002091 NULL, NULL, NULL);
2092 if (ret != 0) {
2093 return ret;
2094 }
2095
2096 ret = mbedtls_test_mock_socket_connect(&client_ep->socket, &server_ep->socket, BUFFSIZE);
2097 if (ret != 0) {
2098 return ret;
2099 }
2100
Max Fillingerea1e7772024-10-30 00:49:10 +01002101 ret = mbedtls_test_move_handshake_to_state(&server_ep->ssl,
2102 &client_ep->ssl,
2103 MBEDTLS_SSL_HANDSHAKE_OVER);
Max Fillingercf007ca2024-10-29 16:57:09 +01002104 if (ret != 0 && ret != MBEDTLS_ERR_SSL_WANT_READ && ret != MBEDTLS_ERR_SSL_WANT_WRITE) {
2105 return ret;
2106 }
Max Fillingerea1e7772024-10-30 00:49:10 +01002107 ret = mbedtls_test_move_handshake_to_state(&client_ep->ssl,
2108 &server_ep->ssl,
2109 MBEDTLS_SSL_HANDSHAKE_OVER);
Max Fillingercf007ca2024-10-29 16:57:09 +01002110 if (ret != 0 && ret != MBEDTLS_ERR_SSL_WANT_READ && ret != MBEDTLS_ERR_SSL_WANT_WRITE) {
2111 return ret;
2112 }
Max Fillingerea1e7772024-10-30 00:49:10 +01002113 if (!mbedtls_ssl_is_handshake_over(&client_ep->ssl) ||
2114 !mbedtls_ssl_is_handshake_over(&server_ep->ssl)) {
Max Fillingercf007ca2024-10-29 16:57:09 +01002115 return -1;
2116 }
2117
2118 return 0;
2119}
2120#endif /* defined(MBEDTLS_SSL_HANDSHAKE_WITH_CERT_ENABLED) */
2121
2122#if defined(MBEDTLS_SSL_HANDSHAKE_WITH_CERT_ENABLED)
Yanray Wange6afd912022-10-27 12:11:18 +08002123void mbedtls_test_ssl_perform_handshake(
Gilles Peskine9b993682025-05-27 18:44:12 +02002124 const mbedtls_test_handshake_test_options *options)
Yanray Wange6afd912022-10-27 12:11:18 +08002125{
Yanray Wange6afd912022-10-27 12:11:18 +08002126 enum { BUFFSIZE = 17000 };
2127 mbedtls_test_ssl_endpoint client, server;
2128#if defined(MBEDTLS_SSL_HANDSHAKE_WITH_PSK_ENABLED)
2129 const char *psk_identity = "foo";
2130#endif
Yanray Wange6afd912022-10-27 12:11:18 +08002131#if defined(MBEDTLS_SSL_CONTEXT_SERIALIZATION)
2132 unsigned char *context_buf = NULL;
2133 size_t context_buf_len;
2134#endif
2135#if defined(MBEDTLS_SSL_RENEGOTIATION)
2136 int ret = -1;
2137#endif
2138 int expected_handshake_result = options->expected_handshake_result;
2139
Manuel Pégourié-Gonnard23fc4372023-03-17 13:34:11 +01002140 MD_OR_USE_PSA_INIT();
Yanray Wange6afd912022-10-27 12:11:18 +08002141 mbedtls_platform_zeroize(&client, sizeof(client));
2142 mbedtls_platform_zeroize(&server, sizeof(server));
Yanray Wange6afd912022-10-27 12:11:18 +08002143
Ronald Cronec3408d2024-01-16 17:50:40 +01002144#if defined(MBEDTLS_DEBUG_C)
2145 if (options->cli_log_fun || options->srv_log_fun) {
2146 mbedtls_debug_set_threshold(4);
2147 }
2148#endif
2149
Yanray Wange6afd912022-10-27 12:11:18 +08002150 /* Client side */
2151 if (options->dtls != 0) {
Gilles Peskine353eb332025-05-14 17:42:53 +02002152 TEST_EQUAL(mbedtls_test_ssl_endpoint_init(&client,
2153 MBEDTLS_SSL_IS_CLIENT,
Gilles Peskine6c154e72025-05-27 20:23:52 +02002154 options, NULL, NULL,
2155 NULL), 0);
Yanray Wange6afd912022-10-27 12:11:18 +08002156 } else {
Gilles Peskine353eb332025-05-14 17:42:53 +02002157 TEST_EQUAL(mbedtls_test_ssl_endpoint_init(&client,
2158 MBEDTLS_SSL_IS_CLIENT,
2159 options, NULL, NULL,
2160 NULL), 0);
Yanray Wange6afd912022-10-27 12:11:18 +08002161 }
2162
Gilles Peskine2744a432025-05-27 13:27:22 +02002163 TEST_ASSERT(set_ciphersuite(&client, options->cipher));
Yanray Wange6afd912022-10-27 12:11:18 +08002164
Yanray Wange6afd912022-10-27 12:11:18 +08002165 /* Server side */
2166 if (options->dtls != 0) {
Gilles Peskine353eb332025-05-14 17:42:53 +02002167 TEST_EQUAL(mbedtls_test_ssl_endpoint_init(&server,
2168 MBEDTLS_SSL_IS_SERVER,
Gilles Peskine6c154e72025-05-27 20:23:52 +02002169 options, NULL, NULL,
2170 NULL), 0);
Yanray Wange6afd912022-10-27 12:11:18 +08002171 } else {
Gilles Peskine353eb332025-05-14 17:42:53 +02002172 TEST_EQUAL(mbedtls_test_ssl_endpoint_init(&server,
2173 MBEDTLS_SSL_IS_SERVER,
2174 options, NULL, NULL,
2175 NULL), 0);
Yanray Wange6afd912022-10-27 12:11:18 +08002176 }
2177
2178 mbedtls_ssl_conf_authmode(&server.conf, options->srv_auth_mode);
2179
Gilles Peskineb092e782025-05-27 20:15:03 +02002180 if (options->dtls) {
2181 TEST_EQUAL(mbedtls_test_ssl_dtls_join_endpoints(&client, &server), 0);
2182 }
2183
Yanray Wange6afd912022-10-27 12:11:18 +08002184#if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
Gilles Peskine353eb332025-05-14 17:42:53 +02002185 TEST_EQUAL(mbedtls_ssl_conf_max_frag_len(&(server.conf),
2186 (unsigned char) options->mfl),
2187 0);
2188 TEST_EQUAL(mbedtls_ssl_conf_max_frag_len(&(client.conf),
2189 (unsigned char) options->mfl),
2190 0);
Yanray Wange6afd912022-10-27 12:11:18 +08002191#else
Gilles Peskine353eb332025-05-14 17:42:53 +02002192 TEST_EQUAL(MBEDTLS_SSL_MAX_FRAG_LEN_NONE, options->mfl);
Yanray Wange6afd912022-10-27 12:11:18 +08002193#endif /* MBEDTLS_SSL_MAX_FRAGMENT_LENGTH */
2194
2195#if defined(MBEDTLS_SSL_HANDSHAKE_WITH_PSK_ENABLED)
2196 if (options->psk_str != NULL && options->psk_str->len > 0) {
Gilles Peskine353eb332025-05-14 17:42:53 +02002197 TEST_EQUAL(mbedtls_ssl_conf_psk(
2198 &client.conf, options->psk_str->x,
2199 options->psk_str->len,
2200 (const unsigned char *) psk_identity,
2201 strlen(psk_identity)), 0);
Yanray Wange6afd912022-10-27 12:11:18 +08002202
Gilles Peskine353eb332025-05-14 17:42:53 +02002203 TEST_EQUAL(mbedtls_ssl_conf_psk(
2204 &server.conf, options->psk_str->x,
2205 options->psk_str->len,
2206 (const unsigned char *) psk_identity,
2207 strlen(psk_identity)), 0);
Yanray Wange6afd912022-10-27 12:11:18 +08002208#if defined(MBEDTLS_SSL_SRV_C)
2209 mbedtls_ssl_conf_psk_cb(&server.conf, psk_dummy_callback, NULL);
2210#endif
2211 }
2212#endif
2213#if defined(MBEDTLS_SSL_RENEGOTIATION)
2214 if (options->renegotiate) {
2215 mbedtls_ssl_conf_renegotiation(&(server.conf),
2216 MBEDTLS_SSL_RENEGOTIATION_ENABLED);
2217 mbedtls_ssl_conf_renegotiation(&(client.conf),
2218 MBEDTLS_SSL_RENEGOTIATION_ENABLED);
2219
2220 mbedtls_ssl_conf_legacy_renegotiation(&(server.conf),
2221 options->legacy_renegotiation);
2222 mbedtls_ssl_conf_legacy_renegotiation(&(client.conf),
2223 options->legacy_renegotiation);
2224 }
2225#endif /* MBEDTLS_SSL_RENEGOTIATION */
2226
Gilles Peskine353eb332025-05-14 17:42:53 +02002227 TEST_EQUAL(mbedtls_test_mock_socket_connect(&(client.socket),
2228 &(server.socket),
2229 BUFFSIZE), 0);
Yanray Wange6afd912022-10-27 12:11:18 +08002230
2231#if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
2232 if (options->resize_buffers != 0) {
2233 /* Ensure that the buffer sizes are appropriate before resizes */
Gilles Peskine353eb332025-05-14 17:42:53 +02002234 TEST_EQUAL(client.ssl.out_buf_len, MBEDTLS_SSL_OUT_BUFFER_LEN);
2235 TEST_EQUAL(client.ssl.in_buf_len, MBEDTLS_SSL_IN_BUFFER_LEN);
2236 TEST_EQUAL(server.ssl.out_buf_len, MBEDTLS_SSL_OUT_BUFFER_LEN);
2237 TEST_EQUAL(server.ssl.in_buf_len, MBEDTLS_SSL_IN_BUFFER_LEN);
Yanray Wange6afd912022-10-27 12:11:18 +08002238 }
2239#endif
2240
2241 if (options->expected_negotiated_version == MBEDTLS_SSL_VERSION_UNKNOWN) {
2242 expected_handshake_result = MBEDTLS_ERR_SSL_BAD_PROTOCOL_VERSION;
2243 }
2244
Gilles Peskine353eb332025-05-14 17:42:53 +02002245 TEST_EQUAL(mbedtls_test_move_handshake_to_state(&(client.ssl),
2246 &(server.ssl),
2247 MBEDTLS_SSL_HANDSHAKE_OVER),
2248 expected_handshake_result);
Yanray Wange6afd912022-10-27 12:11:18 +08002249
2250 if (expected_handshake_result != 0) {
2251 /* Connection will have failed by this point, skip to cleanup */
2252 goto exit;
2253 }
2254
Gilles Peskine353eb332025-05-14 17:42:53 +02002255 TEST_EQUAL(mbedtls_ssl_is_handshake_over(&client.ssl), 1);
Yanray Wange6afd912022-10-27 12:11:18 +08002256
2257 /* Make sure server state is moved to HANDSHAKE_OVER also. */
2258 TEST_EQUAL(mbedtls_test_move_handshake_to_state(&(server.ssl),
2259 &(client.ssl),
2260 MBEDTLS_SSL_HANDSHAKE_OVER),
2261 0);
2262
Gilles Peskine353eb332025-05-14 17:42:53 +02002263 TEST_EQUAL(mbedtls_ssl_is_handshake_over(&server.ssl), 1);
Yanray Wange6afd912022-10-27 12:11:18 +08002264 /* Check that both sides have negotiated the expected version. */
2265 mbedtls_test_set_step(0);
2266 if (!check_ssl_version(options->expected_negotiated_version,
2267 &client.ssl)) {
2268 goto exit;
2269 }
2270
2271 mbedtls_test_set_step(1);
2272 if (!check_ssl_version(options->expected_negotiated_version,
2273 &server.ssl)) {
2274 goto exit;
2275 }
2276
2277 if (options->expected_ciphersuite != 0) {
2278 TEST_EQUAL(server.ssl.session->ciphersuite,
2279 options->expected_ciphersuite);
2280 }
2281
2282#if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
2283 if (options->resize_buffers != 0) {
2284 /* A server, when using DTLS, might delay a buffer resize to happen
2285 * after it receives a message, so we force it. */
Gilles Peskine353eb332025-05-14 17:42:53 +02002286 TEST_EQUAL(exchange_data(&(client.ssl), &(server.ssl)), 0);
Yanray Wange6afd912022-10-27 12:11:18 +08002287
Gilles Peskine353eb332025-05-14 17:42:53 +02002288 TEST_EQUAL(client.ssl.out_buf_len,
2289 mbedtls_ssl_get_output_buflen(&client.ssl));
2290 TEST_EQUAL(client.ssl.in_buf_len,
2291 mbedtls_ssl_get_input_buflen(&client.ssl));
2292 TEST_EQUAL(server.ssl.out_buf_len,
2293 mbedtls_ssl_get_output_buflen(&server.ssl));
2294 TEST_EQUAL(server.ssl.in_buf_len,
2295 mbedtls_ssl_get_input_buflen(&server.ssl));
Yanray Wange6afd912022-10-27 12:11:18 +08002296 }
2297#endif
2298
2299 if (options->cli_msg_len != 0 || options->srv_msg_len != 0) {
2300 /* Start data exchanging test */
Gilles Peskine353eb332025-05-14 17:42:53 +02002301 TEST_EQUAL(mbedtls_test_ssl_exchange_data(
2302 &(client.ssl), options->cli_msg_len,
2303 options->expected_cli_fragments,
2304 &(server.ssl), options->srv_msg_len,
2305 options->expected_srv_fragments),
2306 0);
Yanray Wange6afd912022-10-27 12:11:18 +08002307 }
2308#if defined(MBEDTLS_SSL_CONTEXT_SERIALIZATION)
2309 if (options->serialize == 1) {
Gilles Peskine353eb332025-05-14 17:42:53 +02002310 TEST_EQUAL(options->dtls, 1);
Yanray Wange6afd912022-10-27 12:11:18 +08002311
Gilles Peskine353eb332025-05-14 17:42:53 +02002312 TEST_EQUAL(mbedtls_ssl_context_save(&(server.ssl), NULL,
2313 0, &context_buf_len),
2314 MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL);
Yanray Wange6afd912022-10-27 12:11:18 +08002315
2316 context_buf = mbedtls_calloc(1, context_buf_len);
2317 TEST_ASSERT(context_buf != NULL);
2318
Gilles Peskine353eb332025-05-14 17:42:53 +02002319 TEST_EQUAL(mbedtls_ssl_context_save(&(server.ssl), context_buf,
2320 context_buf_len,
2321 &context_buf_len),
2322 0);
Yanray Wange6afd912022-10-27 12:11:18 +08002323
2324 mbedtls_ssl_free(&(server.ssl));
2325 mbedtls_ssl_init(&(server.ssl));
2326
Gilles Peskine353eb332025-05-14 17:42:53 +02002327 TEST_EQUAL(mbedtls_ssl_setup(&(server.ssl), &(server.conf)), 0);
Yanray Wange6afd912022-10-27 12:11:18 +08002328
Gilles Peskine29969592025-05-27 19:24:28 +02002329 mbedtls_ssl_set_bio(&(server.ssl), &server.dtls_context,
Yanray Wange6afd912022-10-27 12:11:18 +08002330 mbedtls_test_mock_tcp_send_msg,
2331 mbedtls_test_mock_tcp_recv_msg,
2332 NULL);
2333
2334 mbedtls_ssl_set_user_data_p(&server.ssl, &server);
2335
2336#if defined(MBEDTLS_TIMING_C)
Gilles Peskine0677e022025-05-27 18:05:20 +02002337 mbedtls_ssl_set_timer_cb(&server.ssl, &server.timer,
Yanray Wange6afd912022-10-27 12:11:18 +08002338 mbedtls_timing_set_delay,
2339 mbedtls_timing_get_delay);
2340#endif
2341#if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
2342 if (options->resize_buffers != 0) {
2343 /* Ensure that the buffer sizes are appropriate before resizes */
Gilles Peskine353eb332025-05-14 17:42:53 +02002344 TEST_EQUAL(server.ssl.out_buf_len, MBEDTLS_SSL_OUT_BUFFER_LEN);
2345 TEST_EQUAL(server.ssl.in_buf_len, MBEDTLS_SSL_IN_BUFFER_LEN);
Yanray Wange6afd912022-10-27 12:11:18 +08002346 }
2347#endif
Gilles Peskine353eb332025-05-14 17:42:53 +02002348 TEST_EQUAL(mbedtls_ssl_context_load(&(server.ssl), context_buf,
2349 context_buf_len), 0);
Yanray Wange6afd912022-10-27 12:11:18 +08002350
2351#if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
2352 /* Validate buffer sizes after context deserialization */
2353 if (options->resize_buffers != 0) {
Gilles Peskine353eb332025-05-14 17:42:53 +02002354 TEST_EQUAL(server.ssl.out_buf_len,
2355 mbedtls_ssl_get_output_buflen(&server.ssl));
2356 TEST_EQUAL(server.ssl.in_buf_len,
2357 mbedtls_ssl_get_input_buflen(&server.ssl));
Yanray Wange6afd912022-10-27 12:11:18 +08002358 }
2359#endif
2360 /* Retest writing/reading */
2361 if (options->cli_msg_len != 0 || options->srv_msg_len != 0) {
Gilles Peskine353eb332025-05-14 17:42:53 +02002362 TEST_EQUAL(mbedtls_test_ssl_exchange_data(
2363 &(client.ssl), options->cli_msg_len,
2364 options->expected_cli_fragments,
2365 &(server.ssl), options->srv_msg_len,
2366 options->expected_srv_fragments),
2367 0);
Yanray Wange6afd912022-10-27 12:11:18 +08002368 }
2369 }
2370#endif /* MBEDTLS_SSL_CONTEXT_SERIALIZATION */
2371
2372#if defined(MBEDTLS_SSL_RENEGOTIATION)
2373 if (options->renegotiate) {
2374 /* Start test with renegotiation */
Gilles Peskine353eb332025-05-14 17:42:53 +02002375 TEST_EQUAL(server.ssl.renego_status,
2376 MBEDTLS_SSL_INITIAL_HANDSHAKE);
2377 TEST_EQUAL(client.ssl.renego_status,
2378 MBEDTLS_SSL_INITIAL_HANDSHAKE);
Yanray Wange6afd912022-10-27 12:11:18 +08002379
2380 /* After calling this function for the server, it only sends a handshake
2381 * request. All renegotiation should happen during data exchanging */
Gilles Peskine353eb332025-05-14 17:42:53 +02002382 TEST_EQUAL(mbedtls_ssl_renegotiate(&(server.ssl)), 0);
2383 TEST_EQUAL(server.ssl.renego_status,
2384 MBEDTLS_SSL_RENEGOTIATION_PENDING);
2385 TEST_EQUAL(client.ssl.renego_status,
2386 MBEDTLS_SSL_INITIAL_HANDSHAKE);
Yanray Wange6afd912022-10-27 12:11:18 +08002387
Gilles Peskine353eb332025-05-14 17:42:53 +02002388 TEST_EQUAL(exchange_data(&(client.ssl), &(server.ssl)), 0);
2389 TEST_EQUAL(server.ssl.renego_status,
2390 MBEDTLS_SSL_RENEGOTIATION_DONE);
2391 TEST_EQUAL(client.ssl.renego_status,
2392 MBEDTLS_SSL_RENEGOTIATION_DONE);
Yanray Wange6afd912022-10-27 12:11:18 +08002393
2394 /* After calling mbedtls_ssl_renegotiate for the client,
2395 * all renegotiation should happen inside this function.
2396 * However in this test, we cannot perform simultaneous communication
2397 * between client and server so this function will return waiting error
2398 * on the socket. All rest of renegotiation should happen
2399 * during data exchanging */
2400 ret = mbedtls_ssl_renegotiate(&(client.ssl));
2401#if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
2402 if (options->resize_buffers != 0) {
2403 /* Ensure that the buffer sizes are appropriate before resizes */
Gilles Peskine353eb332025-05-14 17:42:53 +02002404 TEST_EQUAL(client.ssl.out_buf_len, MBEDTLS_SSL_OUT_BUFFER_LEN);
2405 TEST_EQUAL(client.ssl.in_buf_len, MBEDTLS_SSL_IN_BUFFER_LEN);
Yanray Wange6afd912022-10-27 12:11:18 +08002406 }
2407#endif
2408 TEST_ASSERT(ret == 0 ||
2409 ret == MBEDTLS_ERR_SSL_WANT_READ ||
2410 ret == MBEDTLS_ERR_SSL_WANT_WRITE);
Gilles Peskine353eb332025-05-14 17:42:53 +02002411 TEST_EQUAL(server.ssl.renego_status,
2412 MBEDTLS_SSL_RENEGOTIATION_DONE);
2413 TEST_EQUAL(client.ssl.renego_status,
2414 MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS);
Yanray Wange6afd912022-10-27 12:11:18 +08002415
Gilles Peskine353eb332025-05-14 17:42:53 +02002416 TEST_EQUAL(exchange_data(&(client.ssl), &(server.ssl)), 0);
2417 TEST_EQUAL(server.ssl.renego_status,
2418 MBEDTLS_SSL_RENEGOTIATION_DONE);
2419 TEST_EQUAL(client.ssl.renego_status,
2420 MBEDTLS_SSL_RENEGOTIATION_DONE);
Yanray Wange6afd912022-10-27 12:11:18 +08002421#if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
2422 /* Validate buffer sizes after renegotiation */
2423 if (options->resize_buffers != 0) {
Gilles Peskine353eb332025-05-14 17:42:53 +02002424 TEST_EQUAL(client.ssl.out_buf_len,
2425 mbedtls_ssl_get_output_buflen(&client.ssl));
2426 TEST_EQUAL(client.ssl.in_buf_len,
2427 mbedtls_ssl_get_input_buflen(&client.ssl));
2428 TEST_EQUAL(server.ssl.out_buf_len,
2429 mbedtls_ssl_get_output_buflen(&server.ssl));
2430 TEST_EQUAL(server.ssl.in_buf_len,
2431 mbedtls_ssl_get_input_buflen(&server.ssl));
Yanray Wange6afd912022-10-27 12:11:18 +08002432 }
2433#endif /* MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH */
2434 }
2435#endif /* MBEDTLS_SSL_RENEGOTIATION */
2436
2437 TEST_ASSERT(mbedtls_ssl_conf_get_user_data_p(&client.conf) == &client);
2438 TEST_ASSERT(mbedtls_ssl_get_user_data_p(&client.ssl) == &client);
2439 TEST_ASSERT(mbedtls_ssl_conf_get_user_data_p(&server.conf) == &server);
2440 TEST_ASSERT(mbedtls_ssl_get_user_data_p(&server.ssl) == &server);
2441
2442exit:
Gilles Peskine29969592025-05-27 19:24:28 +02002443 mbedtls_test_ssl_endpoint_free(&client, NULL);
2444 mbedtls_test_ssl_endpoint_free(&server, NULL);
Yanray Wange6afd912022-10-27 12:11:18 +08002445#if defined(MBEDTLS_DEBUG_C)
2446 if (options->cli_log_fun || options->srv_log_fun) {
2447 mbedtls_debug_set_threshold(0);
2448 }
2449#endif
2450#if defined(MBEDTLS_SSL_CONTEXT_SERIALIZATION)
2451 if (context_buf != NULL) {
2452 mbedtls_free(context_buf);
2453 }
2454#endif
Manuel Pégourié-Gonnard23fc4372023-03-17 13:34:11 +01002455 MD_OR_USE_PSA_DONE();
Yanray Wange6afd912022-10-27 12:11:18 +08002456}
2457#endif /* MBEDTLS_SSL_HANDSHAKE_WITH_CERT_ENABLED */
2458
2459#if defined(MBEDTLS_TEST_HOOKS)
Yanray Wangf56181a2023-03-16 12:21:33 +08002460int mbedtls_test_tweak_tls13_certificate_msg_vector_len(
Yanray Wange6afd912022-10-27 12:11:18 +08002461 unsigned char *buf, unsigned char **end, int tweak,
2462 int *expected_result, mbedtls_ssl_chk_buf_ptr_args *args)
2463{
2464/*
2465 * The definition of the tweaks assume that the certificate list contains only
2466 * one certificate.
2467 */
2468
2469/*
2470 * struct {
2471 * opaque cert_data<1..2^24-1>;
2472 * Extension extensions<0..2^16-1>;
2473 * } CertificateEntry;
2474 *
2475 * struct {
2476 * opaque certificate_request_context<0..2^8-1>;
2477 * CertificateEntry certificate_list<0..2^24-1>;
2478 * } Certificate;
2479 */
2480 unsigned char *p_certificate_request_context_len = buf;
2481 size_t certificate_request_context_len = buf[0];
2482
2483 unsigned char *p_certificate_list_len =
2484 buf + 1 + certificate_request_context_len;
2485 unsigned char *certificate_list = p_certificate_list_len + 3;
2486 size_t certificate_list_len =
2487 MBEDTLS_GET_UINT24_BE(p_certificate_list_len, 0);
2488
2489 unsigned char *p_cert_data_len = certificate_list;
2490 unsigned char *cert_data = p_cert_data_len + 3;
2491 size_t cert_data_len = MBEDTLS_GET_UINT24_BE(p_cert_data_len, 0);
2492
2493 unsigned char *p_extensions_len = cert_data + cert_data_len;
2494 unsigned char *extensions = p_extensions_len + 2;
2495 size_t extensions_len = MBEDTLS_GET_UINT16_BE(p_extensions_len, 0);
2496
2497 *expected_result = MBEDTLS_ERR_SSL_DECODE_ERROR;
2498
2499 switch (tweak) {
2500 case 1:
2501 /* Failure when checking if the certificate request context length
2502 * and certificate list length can be read
2503 */
2504 *end = buf + 3;
2505 set_chk_buf_ptr_args(args, buf, *end, 4);
2506 break;
2507
2508 case 2:
2509 /* Invalid certificate request context length.
2510 */
2511 *p_certificate_request_context_len =
Yanray Wanga8f445e2022-11-03 11:51:59 +08002512 (unsigned char) certificate_request_context_len + 1;
Yanray Wange6afd912022-10-27 12:11:18 +08002513 reset_chk_buf_ptr_args(args);
2514 break;
2515
2516 case 3:
2517 /* Failure when checking if certificate_list data can be read. */
2518 MBEDTLS_PUT_UINT24_BE(certificate_list_len + 1,
2519 p_certificate_list_len, 0);
2520 set_chk_buf_ptr_args(args, certificate_list, *end,
2521 certificate_list_len + 1);
2522 break;
2523
2524 case 4:
2525 /* Failure when checking if the cert_data length can be read. */
2526 MBEDTLS_PUT_UINT24_BE(2, p_certificate_list_len, 0);
2527 set_chk_buf_ptr_args(args, p_cert_data_len, certificate_list + 2, 3);
2528 break;
2529
2530 case 5:
2531 /* Failure when checking if cert_data data can be read. */
2532 MBEDTLS_PUT_UINT24_BE(certificate_list_len - 3 + 1,
2533 p_cert_data_len, 0);
2534 set_chk_buf_ptr_args(args, cert_data,
2535 certificate_list + certificate_list_len,
2536 certificate_list_len - 3 + 1);
2537 break;
2538
2539 case 6:
2540 /* Failure when checking if the extensions length can be read. */
2541 MBEDTLS_PUT_UINT24_BE(certificate_list_len - extensions_len - 1,
2542 p_certificate_list_len, 0);
2543 set_chk_buf_ptr_args(
2544 args, p_extensions_len,
2545 certificate_list + certificate_list_len - extensions_len - 1, 2);
2546 break;
2547
2548 case 7:
2549 /* Failure when checking if extensions data can be read. */
2550 MBEDTLS_PUT_UINT16_BE(extensions_len + 1, p_extensions_len, 0);
2551
2552 set_chk_buf_ptr_args(
2553 args, extensions,
2554 certificate_list + certificate_list_len, extensions_len + 1);
2555 break;
2556
2557 default:
2558 return -1;
2559 }
2560
2561 return 0;
2562}
2563#endif /* MBEDTLS_TEST_HOOKS */
Ronald Cron77abfe62024-01-15 11:17:31 +01002564
Ronald Cronfaf026c2024-01-31 14:32:06 +01002565/*
2566 * Functions for tests based on tickets. Implementations of the
2567 * write/parse ticket interfaces as defined by mbedtls_ssl_ticket_write/parse_t.
2568 * Basically same implementations as in ticket.c without the encryption. That
2569 * way we can tweak easily tickets characteristics to simulate misbehaving
2570 * peers.
2571 */
Ronald Cron77abfe62024-01-15 11:17:31 +01002572#if defined(MBEDTLS_SSL_SESSION_TICKETS)
2573int mbedtls_test_ticket_write(
2574 void *p_ticket, const mbedtls_ssl_session *session,
2575 unsigned char *start, const unsigned char *end,
2576 size_t *tlen, uint32_t *lifetime)
2577{
2578 int ret;
2579 ((void) p_ticket);
2580
2581 if ((ret = mbedtls_ssl_session_save(session, start, end - start,
2582 tlen)) != 0) {
2583 return ret;
2584 }
2585
2586 /* Maximum ticket lifetime as defined in RFC 8446 */
2587 *lifetime = 7 * 24 * 3600;
2588
2589 return 0;
2590}
2591
2592int mbedtls_test_ticket_parse(void *p_ticket, mbedtls_ssl_session *session,
2593 unsigned char *buf, size_t len)
2594{
2595 ((void) p_ticket);
2596
2597 return mbedtls_ssl_session_load(session, buf, len);
2598}
2599#endif /* MBEDTLS_SSL_SESSION_TICKETS */
Ronald Cron1f6e4e42024-01-26 16:31:33 +01002600
2601#if defined(MBEDTLS_SSL_CLI_C) && defined(MBEDTLS_SSL_SRV_C) && \
2602 defined(MBEDTLS_SSL_PROTO_TLS1_3) && defined(MBEDTLS_SSL_SESSION_TICKETS) && \
2603 defined(MBEDTLS_SSL_HANDSHAKE_WITH_CERT_ENABLED)
2604int mbedtls_test_get_tls13_ticket(
2605 mbedtls_test_handshake_test_options *client_options,
2606 mbedtls_test_handshake_test_options *server_options,
2607 mbedtls_ssl_session *session)
2608{
2609 int ret = -1;
Gilles Peskine946bf142025-04-08 09:48:40 +02002610 int ok = 0;
Ronald Cron1f6e4e42024-01-26 16:31:33 +01002611 unsigned char buf[64];
2612 mbedtls_test_ssl_endpoint client_ep, server_ep;
2613
2614 mbedtls_platform_zeroize(&client_ep, sizeof(client_ep));
2615 mbedtls_platform_zeroize(&server_ep, sizeof(server_ep));
2616
2617 ret = mbedtls_test_ssl_endpoint_init(&client_ep, MBEDTLS_SSL_IS_CLIENT,
2618 client_options, NULL, NULL, NULL);
2619 TEST_EQUAL(ret, 0);
2620
2621 ret = mbedtls_test_ssl_endpoint_init(&server_ep, MBEDTLS_SSL_IS_SERVER,
2622 server_options, NULL, NULL, NULL);
2623 TEST_EQUAL(ret, 0);
2624
2625 mbedtls_ssl_conf_session_tickets_cb(&server_ep.conf,
2626 mbedtls_test_ticket_write,
2627 mbedtls_test_ticket_parse,
2628 NULL);
2629
2630 ret = mbedtls_test_mock_socket_connect(&(client_ep.socket),
2631 &(server_ep.socket), 1024);
2632 TEST_EQUAL(ret, 0);
2633
2634 TEST_EQUAL(mbedtls_test_move_handshake_to_state(
2635 &(server_ep.ssl), &(client_ep.ssl),
2636 MBEDTLS_SSL_HANDSHAKE_OVER), 0);
2637
2638 TEST_EQUAL(server_ep.ssl.handshake->new_session_tickets_count, 0);
2639
2640 do {
2641 ret = mbedtls_ssl_read(&(client_ep.ssl), buf, sizeof(buf));
2642 } while (ret != MBEDTLS_ERR_SSL_RECEIVED_NEW_SESSION_TICKET);
2643
2644 ret = mbedtls_ssl_get_session(&(client_ep.ssl), session);
2645 TEST_EQUAL(ret, 0);
2646
Gilles Peskine946bf142025-04-08 09:48:40 +02002647 ok = 1;
2648
Ronald Cron1f6e4e42024-01-26 16:31:33 +01002649exit:
2650 mbedtls_test_ssl_endpoint_free(&client_ep, NULL);
2651 mbedtls_test_ssl_endpoint_free(&server_ep, NULL);
2652
Gilles Peskine946bf142025-04-08 09:48:40 +02002653 if (ret == 0 && !ok) {
2654 /* Exiting due to a test assertion that isn't ret == 0 */
2655 ret = -1;
2656 }
Ronald Cron1f6e4e42024-01-26 16:31:33 +01002657 return ret;
2658}
2659#endif /* MBEDTLS_SSL_CLI_C && MBEDTLS_SSL_SRV_C &&
2660 MBEDTLS_SSL_PROTO_TLS1_3 && MBEDTLS_SSL_SESSION_TICKETS &&
2661 MBEDTLS_SSL_HANDSHAKE_WITH_CERT_ENABLED */
2662
Yanray Wang4d07d1c2022-10-27 15:28:16 +08002663#endif /* MBEDTLS_SSL_TLS_C */