blob: 4657df5be76dc9e924787dca253338e63f3cdf7d [file] [log] [blame]
Manuel Pégourié-Gonnard4956fd72014-09-24 11:13:44 +02001/* BEGIN_HEADER */
Manuel Pégourié-Gonnard7f809972015-03-09 17:05:11 +00002#include <mbedtls/ssl.h>
Manuel Pégourié-Gonnard5e94dde2015-05-26 11:57:05 +02003#include <mbedtls/ssl_internal.h>
Piotr Nowicki2a1f1782020-01-13 09:42:10 +01004#include <mbedtls/ctr_drbg.h>
5#include <mbedtls/entropy.h>
6#include <mbedtls/certs.h>
Andrzej Kurek941962e2020-02-07 09:20:32 -05007#include <mbedtls/timing.h>
Piotr Nowickibde7ee82020-02-21 10:59:50 +01008#include <mbedtls/debug.h>
Hanno Becker73c825a2020-09-08 10:52:58 +01009#include <ssl_tls13_keys.h>
Yanray Wang5fce1452022-10-24 14:42:01 +080010#include <test/ssl_helpers.h>
Piotr Nowickibde7ee82020-02-21 10:59:50 +010011
Gabor Mezeic0ae1cf2021-10-20 12:09:35 +020012#include <constant_time_internal.h>
Manuel Pégourié-Gonnard045f0942020-07-02 11:34:02 +020013
Manuel Pégourié-Gonnard9670a592020-07-10 10:21:46 +020014#include <test/constant_flow.h>
15
Andrzej Kurek01bdab32023-01-17 11:12:11 -050016#if defined(MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED) || \
17 defined(MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED) || \
18 defined(MBEDTLS_KEY_EXCHANGE_RSA_ENABLED)
19#define MBEDTLS_CAN_HANDLE_RSA_TEST_KEY
20#endif
21
Gilles Peskine1b6c09a2023-01-11 14:52:35 +010022enum {
23#define MBEDTLS_SSL_TLS1_3_LABEL(name, string) \
24 tls1_3_label_ ## name,
25 MBEDTLS_SSL_TLS1_3_LABEL_LIST
Hanno Becker70d7fb02020-09-09 10:11:21 +010026#undef MBEDTLS_SSL_TLS1_3_LABEL
Hanno Becker1413bd82020-09-09 12:46:09 +010027};
Hanno Becker70d7fb02020-09-09 10:11:21 +010028
Gilles Peskine1b6c09a2023-01-11 14:52:35 +010029typedef struct log_pattern {
Piotr Nowickibde7ee82020-02-21 10:59:50 +010030 const char *pattern;
31 size_t counter;
32} log_pattern;
33
Piotr Nowicki438bf3b2020-03-10 12:59:10 +010034/*
35 * This function can be passed to mbedtls to receive output logs from it. In
Piotr Nowickibde7ee82020-02-21 10:59:50 +010036 * this case, it will count the instances of a log_pattern in the received
37 * logged messages.
38 */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +010039void log_analyzer(void *ctx, int level,
40 const char *file, int line,
41 const char *str)
Piotr Nowickibde7ee82020-02-21 10:59:50 +010042{
43 log_pattern *p = (log_pattern *) ctx;
44
45 (void) level;
46 (void) line;
47 (void) file;
48
Gilles Peskine1b6c09a2023-01-11 14:52:35 +010049 if (NULL != p &&
Piotr Nowickibde7ee82020-02-21 10:59:50 +010050 NULL != p->pattern &&
Gilles Peskine1b6c09a2023-01-11 14:52:35 +010051 NULL != strstr(str, p->pattern)) {
Piotr Nowickibde7ee82020-02-21 10:59:50 +010052 p->counter++;
53 }
54}
Janos Follath6264e662019-11-26 11:11:15 +000055
Paul Elliottc8570442020-04-15 17:00:50 +010056/* Invalid minor version used when not specifying a min/max version or expecting a test to fail */
57#define TEST_SSL_MINOR_VERSION_NONE -1
58
Gilles Peskine1b6c09a2023-01-11 14:52:35 +010059typedef struct handshake_test_options {
Andrzej Kurek8a6ff152020-02-26 09:10:14 -050060 const char *cipher;
Paul Elliottc8570442020-04-15 17:00:50 +010061 int client_min_version;
62 int client_max_version;
63 int server_min_version;
64 int server_max_version;
65 int expected_negotiated_version;
Andrzej Kurek8a6ff152020-02-26 09:10:14 -050066 int pk_alg;
67 data_t *psk_str;
68 int dtls;
Piotr Nowickibde7ee82020-02-21 10:59:50 +010069 int srv_auth_mode;
Andrzej Kurek8a6ff152020-02-26 09:10:14 -050070 int serialize;
71 int mfl;
72 int cli_msg_len;
73 int srv_msg_len;
74 int expected_cli_fragments;
75 int expected_srv_fragments;
76 int renegotiate;
77 int legacy_renegotiation;
Piotr Nowickibde7ee82020-02-21 10:59:50 +010078 void *srv_log_obj;
79 void *cli_log_obj;
80 void (*srv_log_fun)(void *, int, const char *, int, const char *);
81 void (*cli_log_fun)(void *, int, const char *, int, const char *);
Andrzej Kurek0afa2a12020-03-03 10:39:58 -050082 int resize_buffers;
Andrzej Kurek8a6ff152020-02-26 09:10:14 -050083} handshake_test_options;
84
Gilles Peskine1b6c09a2023-01-11 14:52:35 +010085void init_handshake_options(handshake_test_options *opts)
Andrzej Kurek8a6ff152020-02-26 09:10:14 -050086{
Gilles Peskine1b6c09a2023-01-11 14:52:35 +010087 opts->cipher = "";
88 opts->client_min_version = TEST_SSL_MINOR_VERSION_NONE;
89 opts->client_max_version = TEST_SSL_MINOR_VERSION_NONE;
90 opts->server_min_version = TEST_SSL_MINOR_VERSION_NONE;
91 opts->server_max_version = TEST_SSL_MINOR_VERSION_NONE;
92 opts->expected_negotiated_version = MBEDTLS_SSL_MINOR_VERSION_3;
93 opts->pk_alg = MBEDTLS_PK_RSA;
94 opts->psk_str = NULL;
95 opts->dtls = 0;
96 opts->srv_auth_mode = MBEDTLS_SSL_VERIFY_NONE;
97 opts->serialize = 0;
98 opts->mfl = MBEDTLS_SSL_MAX_FRAG_LEN_NONE;
99 opts->cli_msg_len = 100;
100 opts->srv_msg_len = 100;
101 opts->expected_cli_fragments = 1;
102 opts->expected_srv_fragments = 1;
103 opts->renegotiate = 0;
104 opts->legacy_renegotiation = MBEDTLS_SSL_LEGACY_NO_RENEGOTIATION;
105 opts->srv_log_obj = NULL;
106 opts->srv_log_obj = NULL;
107 opts->srv_log_fun = NULL;
108 opts->cli_log_fun = NULL;
109 opts->resize_buffers = 1;
Andrzej Kurek8a6ff152020-02-26 09:10:14 -0500110}
Janos Follath6264e662019-11-26 11:11:15 +0000111/*
112 * Buffer structure for custom I/O callbacks.
113 */
114
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100115typedef struct mbedtls_test_buffer {
Janos Follath6264e662019-11-26 11:11:15 +0000116 size_t start;
117 size_t content_length;
118 size_t capacity;
119 unsigned char *buffer;
120} mbedtls_test_buffer;
121
122/*
123 * Initialises \p buf. After calling this function it is safe to call
124 * `mbedtls_test_buffer_free()` on \p buf.
125 */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100126void mbedtls_test_buffer_init(mbedtls_test_buffer *buf)
Janos Follath6264e662019-11-26 11:11:15 +0000127{
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100128 memset(buf, 0, sizeof(*buf));
Janos Follath6264e662019-11-26 11:11:15 +0000129}
130
131/*
132 * Sets up \p buf. After calling this function it is safe to call
133 * `mbedtls_test_buffer_put()` and `mbedtls_test_buffer_get()` on \p buf.
134 */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100135int mbedtls_test_buffer_setup(mbedtls_test_buffer *buf, size_t capacity)
Janos Follath6264e662019-11-26 11:11:15 +0000136{
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100137 buf->buffer = (unsigned char *) mbedtls_calloc(capacity,
138 sizeof(unsigned char));
139 if (NULL == buf->buffer) {
Janos Follath6264e662019-11-26 11:11:15 +0000140 return MBEDTLS_ERR_SSL_ALLOC_FAILED;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100141 }
Janos Follath6264e662019-11-26 11:11:15 +0000142 buf->capacity = capacity;
143
144 return 0;
145}
146
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100147void mbedtls_test_buffer_free(mbedtls_test_buffer *buf)
Janos Follath6264e662019-11-26 11:11:15 +0000148{
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100149 if (buf->buffer != NULL) {
150 mbedtls_free(buf->buffer);
151 }
Janos Follath6264e662019-11-26 11:11:15 +0000152
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100153 memset(buf, 0, sizeof(*buf));
Janos Follath6264e662019-11-26 11:11:15 +0000154}
155
156/*
157 * Puts \p input_len bytes from the \p input buffer into the ring buffer \p buf.
158 *
159 * \p buf must have been initialized and set up by calling
160 * `mbedtls_test_buffer_init()` and `mbedtls_test_buffer_setup()`.
161 *
162 * \retval \p input_len, if the data fits.
163 * \retval 0 <= value < \p input_len, if the data does not fit.
164 * \retval -1, if \p buf is NULL, it hasn't been set up or \p input_len is not
165 * zero and \p input is NULL.
166 */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100167int mbedtls_test_buffer_put(mbedtls_test_buffer *buf,
168 const unsigned char *input, size_t input_len)
Janos Follath6264e662019-11-26 11:11:15 +0000169{
170 size_t overflow = 0;
171
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100172 if ((buf == NULL) || (buf->buffer == NULL)) {
Janos Follath6264e662019-11-26 11:11:15 +0000173 return -1;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100174 }
Janos Follath6264e662019-11-26 11:11:15 +0000175
176 /* Reduce input_len to a number that fits in the buffer. */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100177 if ((buf->content_length + input_len) > buf->capacity) {
Janos Follath6264e662019-11-26 11:11:15 +0000178 input_len = buf->capacity - buf->content_length;
179 }
180
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100181 if (input == NULL) {
182 return (input_len == 0) ? 0 : -1;
Janos Follath6264e662019-11-26 11:11:15 +0000183 }
184
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100185 /* Check if the buffer has not come full circle and free space is not in
186 * the middle */
187 if (buf->start + buf->content_length < buf->capacity) {
Piotr Nowickifb437d72020-01-13 16:59:12 +0100188
189 /* Calculate the number of bytes that need to be placed at lower memory
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100190 * address */
191 if (buf->start + buf->content_length + input_len
192 > buf->capacity) {
193 overflow = (buf->start + buf->content_length + input_len)
194 % buf->capacity;
Piotr Nowickifb437d72020-01-13 16:59:12 +0100195 }
196
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100197 memcpy(buf->buffer + buf->start + buf->content_length, input,
198 input_len - overflow);
199 memcpy(buf->buffer, input + input_len - overflow, overflow);
Piotr Nowickifb437d72020-01-13 16:59:12 +0100200
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100201 } else {
Piotr Nowickifb437d72020-01-13 16:59:12 +0100202 /* The buffer has come full circle and free space is in the middle */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100203 memcpy(buf->buffer + buf->start + buf->content_length - buf->capacity,
204 input, input_len);
Janos Follath6264e662019-11-26 11:11:15 +0000205 }
206
Janos Follath6264e662019-11-26 11:11:15 +0000207 buf->content_length += input_len;
Janos Follath6264e662019-11-26 11:11:15 +0000208 return input_len;
209}
210
211/*
Andrzej Kurekf7774142020-01-22 06:34:59 -0500212 * Gets \p output_len bytes from the ring buffer \p buf into the
213 * \p output buffer. The output buffer can be NULL, in this case a part of the
214 * ring buffer will be dropped, if the requested length is available.
Janos Follath6264e662019-11-26 11:11:15 +0000215 *
216 * \p buf must have been initialized and set up by calling
217 * `mbedtls_test_buffer_init()` and `mbedtls_test_buffer_setup()`.
218 *
219 * \retval \p output_len, if the data is available.
220 * \retval 0 <= value < \p output_len, if the data is not available.
Andrzej Kurekf7774142020-01-22 06:34:59 -0500221 * \retval -1, if \buf is NULL or it hasn't been set up.
Janos Follath6264e662019-11-26 11:11:15 +0000222 */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100223int mbedtls_test_buffer_get(mbedtls_test_buffer *buf,
224 unsigned char *output, size_t output_len)
Janos Follath6264e662019-11-26 11:11:15 +0000225{
226 size_t overflow = 0;
227
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100228 if ((buf == NULL) || (buf->buffer == NULL)) {
Janos Follath6264e662019-11-26 11:11:15 +0000229 return -1;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100230 }
Janos Follath6264e662019-11-26 11:11:15 +0000231
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100232 if (output == NULL && output_len == 0) {
Andrzej Kurekf7774142020-01-22 06:34:59 -0500233 return 0;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100234 }
Janos Follath6264e662019-11-26 11:11:15 +0000235
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100236 if (buf->content_length < output_len) {
Janos Follath6264e662019-11-26 11:11:15 +0000237 output_len = buf->content_length;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100238 }
Janos Follath6264e662019-11-26 11:11:15 +0000239
240 /* Calculate the number of bytes that need to be drawn from lower memory
241 * address */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100242 if (buf->start + output_len > buf->capacity) {
243 overflow = (buf->start + output_len) % buf->capacity;
Janos Follath6264e662019-11-26 11:11:15 +0000244 }
245
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100246 if (output != NULL) {
247 memcpy(output, buf->buffer + buf->start, output_len - overflow);
248 memcpy(output + output_len - overflow, buf->buffer, overflow);
Andrzej Kurekf7774142020-01-22 06:34:59 -0500249 }
250
Janos Follath6264e662019-11-26 11:11:15 +0000251 buf->content_length -= output_len;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100252 buf->start = (buf->start + output_len) % buf->capacity;
Janos Follath6264e662019-11-26 11:11:15 +0000253
254 return output_len;
255}
256
Hanno Beckera18d1322018-01-03 14:27:32 +0000257/*
Andrzej Kurek13719cd2020-01-22 06:36:39 -0500258 * Errors used in the message transport mock tests
259 */
260 #define MBEDTLS_TEST_ERROR_ARG_NULL -11
Andrzej Kurek13719cd2020-01-22 06:36:39 -0500261 #define MBEDTLS_TEST_ERROR_MESSAGE_TRUNCATED -44
262
263/*
264 * Context for a message metadata queue (fifo) that is on top of the ring buffer.
265 */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100266typedef struct mbedtls_test_message_queue {
Andrzej Kurek13719cd2020-01-22 06:36:39 -0500267 size_t *messages;
268 int pos;
269 int num;
270 int capacity;
271} mbedtls_test_message_queue;
272
273/*
274 * Setup and free functions for the message metadata queue.
275 *
276 * \p capacity describes the number of message metadata chunks that can be held
277 * within the queue.
278 *
279 * \retval 0, if a metadata queue of a given length can be allocated.
280 * \retval MBEDTLS_ERR_SSL_ALLOC_FAILED, if allocation failed.
281 */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100282int mbedtls_test_message_queue_setup(mbedtls_test_message_queue *queue,
283 size_t capacity)
Andrzej Kurek13719cd2020-01-22 06:36:39 -0500284{
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100285 queue->messages = (size_t *) mbedtls_calloc(capacity, sizeof(size_t));
286 if (NULL == queue->messages) {
Andrzej Kurek13719cd2020-01-22 06:36:39 -0500287 return MBEDTLS_ERR_SSL_ALLOC_FAILED;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100288 }
Andrzej Kurek13719cd2020-01-22 06:36:39 -0500289
290 queue->capacity = capacity;
291 queue->pos = 0;
292 queue->num = 0;
293
294 return 0;
295}
296
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100297void mbedtls_test_message_queue_free(mbedtls_test_message_queue *queue)
Andrzej Kurek13719cd2020-01-22 06:36:39 -0500298{
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100299 if (queue == NULL) {
Andrzej Kurek13719cd2020-01-22 06:36:39 -0500300 return;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100301 }
Andrzej Kurek13719cd2020-01-22 06:36:39 -0500302
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100303 if (queue->messages != NULL) {
304 mbedtls_free(queue->messages);
305 }
Andrzej Kurek13719cd2020-01-22 06:36:39 -0500306
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100307 memset(queue, 0, sizeof(*queue));
Andrzej Kurek13719cd2020-01-22 06:36:39 -0500308}
309
310/*
311 * Push message length information onto the message metadata queue.
312 * This will become the last element to leave it (fifo).
313 *
314 * \retval MBEDTLS_TEST_ERROR_ARG_NULL, if the queue is null.
Andrzej Kurekf46b9122020-02-07 08:19:00 -0500315 * \retval MBEDTLS_ERR_SSL_WANT_WRITE, if the queue is full.
Andrzej Kurek13719cd2020-01-22 06:36:39 -0500316 * \retval \p len, if the push was successful.
317 */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100318int mbedtls_test_message_queue_push_info(mbedtls_test_message_queue *queue,
319 size_t len)
Andrzej Kurek13719cd2020-01-22 06:36:39 -0500320{
321 int place;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100322 if (queue == NULL) {
Andrzej Kurek13719cd2020-01-22 06:36:39 -0500323 return MBEDTLS_TEST_ERROR_ARG_NULL;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100324 }
Andrzej Kurek13719cd2020-01-22 06:36:39 -0500325
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100326 if (queue->num >= queue->capacity) {
Andrzej Kurekf46b9122020-02-07 08:19:00 -0500327 return MBEDTLS_ERR_SSL_WANT_WRITE;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100328 }
Andrzej Kurek13719cd2020-01-22 06:36:39 -0500329
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100330 place = (queue->pos + queue->num) % queue->capacity;
Andrzej Kurek13719cd2020-01-22 06:36:39 -0500331 queue->messages[place] = len;
332 queue->num++;
333 return len;
334}
335
336/*
337 * Pop information about the next message length from the queue. This will be
338 * the oldest inserted message length(fifo). \p msg_len can be null, in which
339 * case the data will be popped from the queue but not copied anywhere.
340 *
341 * \retval MBEDTLS_TEST_ERROR_ARG_NULL, if the queue is null.
Andrzej Kurekf46b9122020-02-07 08:19:00 -0500342 * \retval MBEDTLS_ERR_SSL_WANT_READ, if the queue is empty.
Andrzej Kurek13719cd2020-01-22 06:36:39 -0500343 * \retval message length, if the pop was successful, up to the given
344 \p buf_len.
345 */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100346int mbedtls_test_message_queue_pop_info(mbedtls_test_message_queue *queue,
347 size_t buf_len)
Andrzej Kurek13719cd2020-01-22 06:36:39 -0500348{
349 size_t message_length;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100350 if (queue == NULL) {
Andrzej Kurek13719cd2020-01-22 06:36:39 -0500351 return MBEDTLS_TEST_ERROR_ARG_NULL;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100352 }
353 if (queue->num == 0) {
Andrzej Kurekf46b9122020-02-07 08:19:00 -0500354 return MBEDTLS_ERR_SSL_WANT_READ;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100355 }
Andrzej Kurek13719cd2020-01-22 06:36:39 -0500356
357 message_length = queue->messages[queue->pos];
358 queue->messages[queue->pos] = 0;
359 queue->num--;
360 queue->pos++;
361 queue->pos %= queue->capacity;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100362 if (queue->pos < 0) {
Andrzej Kurek13719cd2020-01-22 06:36:39 -0500363 queue->pos += queue->capacity;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100364 }
Andrzej Kurek13719cd2020-01-22 06:36:39 -0500365
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100366 return (message_length > buf_len) ? buf_len : message_length;
Andrzej Kurek13719cd2020-01-22 06:36:39 -0500367}
368
369/*
370 * Take a peek on the info about the next message length from the queue.
371 * This will be the oldest inserted message length(fifo).
372 *
373 * \retval MBEDTLS_TEST_ERROR_ARG_NULL, if the queue is null.
Andrzej Kurekf46b9122020-02-07 08:19:00 -0500374 * \retval MBEDTLS_ERR_SSL_WANT_READ, if the queue is empty.
Andrzej Kurek13719cd2020-01-22 06:36:39 -0500375 * \retval 0, if the peek was successful.
376 * \retval MBEDTLS_TEST_ERROR_MESSAGE_TRUNCATED, if the given buffer length is
377 * too small to fit the message. In this case the \p msg_len will be
378 * set to the full message length so that the
379 * caller knows what portion of the message can be dropped.
380 */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100381int mbedtls_test_message_queue_peek_info(mbedtls_test_message_queue *queue,
382 size_t buf_len, size_t *msg_len)
Andrzej Kurek13719cd2020-01-22 06:36:39 -0500383{
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100384 if (queue == NULL || msg_len == NULL) {
Andrzej Kurek13719cd2020-01-22 06:36:39 -0500385 return MBEDTLS_TEST_ERROR_ARG_NULL;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100386 }
387 if (queue->num == 0) {
Andrzej Kurekf46b9122020-02-07 08:19:00 -0500388 return MBEDTLS_ERR_SSL_WANT_READ;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100389 }
Andrzej Kurek13719cd2020-01-22 06:36:39 -0500390
391 *msg_len = queue->messages[queue->pos];
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100392 return (*msg_len > buf_len) ? MBEDTLS_TEST_ERROR_MESSAGE_TRUNCATED : 0;
Andrzej Kurek13719cd2020-01-22 06:36:39 -0500393}
394/*
Janos Follath031827f2019-11-27 11:12:14 +0000395 * Context for the I/O callbacks simulating network connection.
396 */
397
398#define MBEDTLS_MOCK_SOCKET_CONNECTED 1
399
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100400typedef struct mbedtls_mock_socket {
Janos Follath031827f2019-11-27 11:12:14 +0000401 int status;
402 mbedtls_test_buffer *input;
403 mbedtls_test_buffer *output;
404 struct mbedtls_mock_socket *peer;
405} mbedtls_mock_socket;
406
407/*
408 * Setup and teardown functions for mock sockets.
409 */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100410void mbedtls_mock_socket_init(mbedtls_mock_socket *socket)
Janos Follath031827f2019-11-27 11:12:14 +0000411{
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100412 memset(socket, 0, sizeof(*socket));
Janos Follath031827f2019-11-27 11:12:14 +0000413}
414
415/*
416 * Closes the socket \p socket.
417 *
418 * \p socket must have been previously initialized by calling
419 * mbedtls_mock_socket_init().
420 *
421 * This function frees all allocated resources and both sockets are aware of the
422 * new connection state.
423 *
424 * That is, this function does not simulate half-open TCP connections and the
425 * phenomenon that when closing a UDP connection the peer is not aware of the
426 * connection having been closed.
427 */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100428void mbedtls_mock_socket_close(mbedtls_mock_socket *socket)
Janos Follath031827f2019-11-27 11:12:14 +0000429{
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100430 if (socket == NULL) {
Janos Follath031827f2019-11-27 11:12:14 +0000431 return;
Janos Follath031827f2019-11-27 11:12:14 +0000432 }
433
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100434 if (socket->input != NULL) {
435 mbedtls_test_buffer_free(socket->input);
436 mbedtls_free(socket->input);
Janos Follath031827f2019-11-27 11:12:14 +0000437 }
438
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100439 if (socket->output != NULL) {
440 mbedtls_test_buffer_free(socket->output);
441 mbedtls_free(socket->output);
442 }
Janos Follath031827f2019-11-27 11:12:14 +0000443
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100444 if (socket->peer != NULL) {
445 memset(socket->peer, 0, sizeof(*socket->peer));
446 }
447
448 memset(socket, 0, sizeof(*socket));
Janos Follath031827f2019-11-27 11:12:14 +0000449}
450
451/*
452 * Establishes a connection between \p peer1 and \p peer2.
453 *
454 * \p peer1 and \p peer2 must have been previously initialized by calling
455 * mbedtls_mock_socket_init().
456 *
Tom Cosgrove49f99bc2022-12-04 16:44:21 +0000457 * The capacities of the internal buffers are set to \p bufsize. Setting this to
Janos Follath031827f2019-11-27 11:12:14 +0000458 * the correct value allows for simulation of MTU, sanity testing the mock
459 * implementation and mocking TCP connections with lower memory cost.
460 */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100461int mbedtls_mock_socket_connect(mbedtls_mock_socket *peer1,
462 mbedtls_mock_socket *peer2,
463 size_t bufsize)
Janos Follath031827f2019-11-27 11:12:14 +0000464{
465 int ret = -1;
466
Piotr Nowickid796e192020-01-28 12:09:47 +0100467 peer1->output =
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100468 (mbedtls_test_buffer *) mbedtls_calloc(1, sizeof(mbedtls_test_buffer));
469 if (peer1->output == NULL) {
Janos Follath031827f2019-11-27 11:12:14 +0000470 ret = MBEDTLS_ERR_SSL_ALLOC_FAILED;
471 goto exit;
472 }
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100473 mbedtls_test_buffer_init(peer1->output);
474 if (0 != (ret = mbedtls_test_buffer_setup(peer1->output, bufsize))) {
Janos Follath031827f2019-11-27 11:12:14 +0000475 goto exit;
476 }
477
Piotr Nowickid796e192020-01-28 12:09:47 +0100478 peer2->output =
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100479 (mbedtls_test_buffer *) mbedtls_calloc(1, sizeof(mbedtls_test_buffer));
480 if (peer2->output == NULL) {
Piotr Nowickid796e192020-01-28 12:09:47 +0100481 ret = MBEDTLS_ERR_SSL_ALLOC_FAILED;
482 goto exit;
483 }
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100484 mbedtls_test_buffer_init(peer2->output);
485 if (0 != (ret = mbedtls_test_buffer_setup(peer2->output, bufsize))) {
Piotr Nowickid796e192020-01-28 12:09:47 +0100486 goto exit;
487 }
488
Janos Follath031827f2019-11-27 11:12:14 +0000489 peer1->peer = peer2;
490 peer2->peer = peer1;
Piotr Nowickid796e192020-01-28 12:09:47 +0100491 peer1->input = peer2->output;
492 peer2->input = peer1->output;
Janos Follath031827f2019-11-27 11:12:14 +0000493
494 peer1->status = peer2->status = MBEDTLS_MOCK_SOCKET_CONNECTED;
495 ret = 0;
496
497exit:
498
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100499 if (ret != 0) {
500 mbedtls_mock_socket_close(peer1);
501 mbedtls_mock_socket_close(peer2);
Janos Follath031827f2019-11-27 11:12:14 +0000502 }
503
504 return ret;
505}
506
507/*
508 * Callbacks for simulating blocking I/O over connection-oriented transport.
509 */
510
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100511int mbedtls_mock_tcp_send_b(void *ctx, const unsigned char *buf, size_t len)
Janos Follath031827f2019-11-27 11:12:14 +0000512{
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100513 mbedtls_mock_socket *socket = (mbedtls_mock_socket *) ctx;
Janos Follath031827f2019-11-27 11:12:14 +0000514
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100515 if (socket == NULL || socket->status != MBEDTLS_MOCK_SOCKET_CONNECTED) {
Janos Follath031827f2019-11-27 11:12:14 +0000516 return -1;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100517 }
Janos Follath031827f2019-11-27 11:12:14 +0000518
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100519 return mbedtls_test_buffer_put(socket->output, buf, len);
Janos Follath031827f2019-11-27 11:12:14 +0000520}
521
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100522int mbedtls_mock_tcp_recv_b(void *ctx, unsigned char *buf, size_t len)
Janos Follath031827f2019-11-27 11:12:14 +0000523{
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100524 mbedtls_mock_socket *socket = (mbedtls_mock_socket *) ctx;
Janos Follath031827f2019-11-27 11:12:14 +0000525
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100526 if (socket == NULL || socket->status != MBEDTLS_MOCK_SOCKET_CONNECTED) {
Janos Follath031827f2019-11-27 11:12:14 +0000527 return -1;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100528 }
Janos Follath031827f2019-11-27 11:12:14 +0000529
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100530 return mbedtls_test_buffer_get(socket->input, buf, len);
Janos Follath031827f2019-11-27 11:12:14 +0000531}
532
533/*
Janos Follath3766ba52019-11-27 13:31:42 +0000534 * Callbacks for simulating non-blocking I/O over connection-oriented transport.
535 */
536
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100537int mbedtls_mock_tcp_send_nb(void *ctx, const unsigned char *buf, size_t len)
Janos Follath3766ba52019-11-27 13:31:42 +0000538{
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100539 mbedtls_mock_socket *socket = (mbedtls_mock_socket *) ctx;
Janos Follath3766ba52019-11-27 13:31:42 +0000540
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100541 if (socket == NULL || socket->status != MBEDTLS_MOCK_SOCKET_CONNECTED) {
Janos Follath3766ba52019-11-27 13:31:42 +0000542 return -1;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100543 }
Janos Follath3766ba52019-11-27 13:31:42 +0000544
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100545 if (socket->output->capacity == socket->output->content_length) {
Janos Follath3766ba52019-11-27 13:31:42 +0000546 return MBEDTLS_ERR_SSL_WANT_WRITE;
547 }
548
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100549 return mbedtls_test_buffer_put(socket->output, buf, len);
Janos Follath3766ba52019-11-27 13:31:42 +0000550}
551
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100552int mbedtls_mock_tcp_recv_nb(void *ctx, unsigned char *buf, size_t len)
Janos Follath3766ba52019-11-27 13:31:42 +0000553{
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100554 mbedtls_mock_socket *socket = (mbedtls_mock_socket *) ctx;
Janos Follath3766ba52019-11-27 13:31:42 +0000555
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100556 if (socket == NULL || socket->status != MBEDTLS_MOCK_SOCKET_CONNECTED) {
Janos Follath3766ba52019-11-27 13:31:42 +0000557 return -1;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100558 }
Janos Follath3766ba52019-11-27 13:31:42 +0000559
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100560 if (socket->input->content_length == 0) {
Janos Follath3766ba52019-11-27 13:31:42 +0000561 return MBEDTLS_ERR_SSL_WANT_READ;
562 }
563
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100564 return mbedtls_test_buffer_get(socket->input, buf, len);
Janos Follath3766ba52019-11-27 13:31:42 +0000565}
566
Andrzej Kurekbc483de2020-01-22 03:40:00 -0500567/* Errors used in the message socket mocks */
568
569#define MBEDTLS_TEST_ERROR_CONTEXT_ERROR -55
570#define MBEDTLS_TEST_ERROR_SEND_FAILED -66
571#define MBEDTLS_TEST_ERROR_RECV_FAILED -77
572
573/*
574 * Structure used as an addon, or a wrapper, around the mocked sockets.
575 * Contains an input queue, to which the other socket pushes metadata,
576 * and an output queue, to which this one pushes metadata. This context is
577 * considered as an owner of the input queue only, which is initialized and
578 * freed in the respective setup and free calls.
579 */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100580typedef struct mbedtls_test_message_socket_context {
581 mbedtls_test_message_queue *queue_input;
582 mbedtls_test_message_queue *queue_output;
583 mbedtls_mock_socket *socket;
Andrzej Kurekbc483de2020-01-22 03:40:00 -0500584} mbedtls_test_message_socket_context;
585
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100586void mbedtls_message_socket_init(mbedtls_test_message_socket_context *ctx)
Andrzej Kurek45916ba2020-03-05 14:46:22 -0500587{
588 ctx->queue_input = NULL;
589 ctx->queue_output = NULL;
590 ctx->socket = NULL;
591}
592
Andrzej Kurekbc483de2020-01-22 03:40:00 -0500593/*
Tom Cosgrove49f99bc2022-12-04 16:44:21 +0000594 * Setup a given message socket context including initialization of
Andrzej Kurekbc483de2020-01-22 03:40:00 -0500595 * input/output queues to a chosen capacity of messages. Also set the
596 * corresponding mock socket.
597 *
598 * \retval 0, if everything succeeds.
599 * \retval MBEDTLS_ERR_SSL_ALLOC_FAILED, if allocation of a message
600 * queue failed.
601 */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100602int mbedtls_message_socket_setup(mbedtls_test_message_queue *queue_input,
603 mbedtls_test_message_queue *queue_output,
604 size_t queue_capacity,
605 mbedtls_mock_socket *socket,
606 mbedtls_test_message_socket_context *ctx)
Andrzej Kurekbc483de2020-01-22 03:40:00 -0500607{
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100608 int ret = mbedtls_test_message_queue_setup(queue_input, queue_capacity);
609 if (ret != 0) {
Andrzej Kurekbc483de2020-01-22 03:40:00 -0500610 return ret;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100611 }
Andrzej Kurekbc483de2020-01-22 03:40:00 -0500612 ctx->queue_input = queue_input;
613 ctx->queue_output = queue_output;
614 ctx->socket = socket;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100615 mbedtls_mock_socket_init(socket);
Andrzej Kurekbc483de2020-01-22 03:40:00 -0500616
617 return 0;
618}
619
620/*
621 * Close a given message socket context, along with the socket itself. Free the
622 * memory allocated by the input queue.
623 */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100624void mbedtls_message_socket_close(mbedtls_test_message_socket_context *ctx)
Andrzej Kurekbc483de2020-01-22 03:40:00 -0500625{
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100626 if (ctx == NULL) {
Andrzej Kurekbc483de2020-01-22 03:40:00 -0500627 return;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100628 }
Andrzej Kurekbc483de2020-01-22 03:40:00 -0500629
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100630 mbedtls_test_message_queue_free(ctx->queue_input);
631 mbedtls_mock_socket_close(ctx->socket);
632 memset(ctx, 0, sizeof(*ctx));
Andrzej Kurekbc483de2020-01-22 03:40:00 -0500633}
634
635/*
636 * Send one message through a given message socket context.
637 *
638 * \retval \p len, if everything succeeds.
639 * \retval MBEDTLS_TEST_ERROR_CONTEXT_ERROR, if any of the needed context
640 * elements or the context itself is null.
641 * \retval MBEDTLS_TEST_ERROR_SEND_FAILED if mbedtls_mock_tcp_send_b failed.
Andrzej Kurekf46b9122020-02-07 08:19:00 -0500642 * \retval MBEDTLS_ERR_SSL_WANT_WRITE, if the output queue is full.
Andrzej Kurekbc483de2020-01-22 03:40:00 -0500643 *
644 * This function will also return any error from
645 * mbedtls_test_message_queue_push_info.
646 */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100647int mbedtls_mock_tcp_send_msg(void *ctx, const unsigned char *buf, size_t len)
Andrzej Kurekbc483de2020-01-22 03:40:00 -0500648{
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100649 mbedtls_test_message_queue *queue;
650 mbedtls_mock_socket *socket;
651 mbedtls_test_message_socket_context *context = (mbedtls_test_message_socket_context *) ctx;
Andrzej Kurekbc483de2020-01-22 03:40:00 -0500652
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100653 if (context == NULL || context->socket == NULL
654 || context->queue_output == NULL) {
Andrzej Kurekbc483de2020-01-22 03:40:00 -0500655 return MBEDTLS_TEST_ERROR_CONTEXT_ERROR;
656 }
657
658 queue = context->queue_output;
659 socket = context->socket;
660
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100661 if (queue->num >= queue->capacity) {
Andrzej Kurekf46b9122020-02-07 08:19:00 -0500662 return MBEDTLS_ERR_SSL_WANT_WRITE;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100663 }
Andrzej Kurekbc483de2020-01-22 03:40:00 -0500664
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100665 if (mbedtls_mock_tcp_send_b(socket, buf, len) != (int) len) {
Andrzej Kurekbc483de2020-01-22 03:40:00 -0500666 return MBEDTLS_TEST_ERROR_SEND_FAILED;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100667 }
Andrzej Kurekbc483de2020-01-22 03:40:00 -0500668
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100669 return mbedtls_test_message_queue_push_info(queue, len);
Andrzej Kurekbc483de2020-01-22 03:40:00 -0500670}
671
672/*
673 * Receive one message from a given message socket context and return message
674 * length or an error.
675 *
676 * \retval message length, if everything succeeds.
677 * \retval MBEDTLS_TEST_ERROR_CONTEXT_ERROR, if any of the needed context
678 * elements or the context itself is null.
679 * \retval MBEDTLS_TEST_ERROR_RECV_FAILED if mbedtls_mock_tcp_recv_b failed.
680 *
681 * This function will also return any error other than
682 * MBEDTLS_TEST_ERROR_MESSAGE_TRUNCATED from mbedtls_test_message_queue_peek_info.
683 */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100684int mbedtls_mock_tcp_recv_msg(void *ctx, unsigned char *buf, size_t buf_len)
Andrzej Kurekbc483de2020-01-22 03:40:00 -0500685{
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100686 mbedtls_test_message_queue *queue;
687 mbedtls_mock_socket *socket;
688 mbedtls_test_message_socket_context *context = (mbedtls_test_message_socket_context *) ctx;
Gilles Peskine19e841e2020-03-09 20:43:51 +0100689 size_t drop_len = 0;
Andrzej Kurekbc483de2020-01-22 03:40:00 -0500690 size_t msg_len;
691 int ret;
692
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100693 if (context == NULL || context->socket == NULL
694 || context->queue_input == NULL) {
Andrzej Kurekbc483de2020-01-22 03:40:00 -0500695 return MBEDTLS_TEST_ERROR_CONTEXT_ERROR;
696 }
697
698 queue = context->queue_input;
699 socket = context->socket;
700
701 /* Peek first, so that in case of a socket error the data remains in
702 * the queue. */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100703 ret = mbedtls_test_message_queue_peek_info(queue, buf_len, &msg_len);
704 if (ret == MBEDTLS_TEST_ERROR_MESSAGE_TRUNCATED) {
Andrzej Kurekbc483de2020-01-22 03:40:00 -0500705 /* Calculate how much to drop */
706 drop_len = msg_len - buf_len;
707
708 /* Set the requested message len to be buffer length */
709 msg_len = buf_len;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100710 } else if (ret != 0) {
Andrzej Kurekbc483de2020-01-22 03:40:00 -0500711 return ret;
712 }
713
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100714 if (mbedtls_mock_tcp_recv_b(socket, buf, msg_len) != (int) msg_len) {
Andrzej Kurekbc483de2020-01-22 03:40:00 -0500715 return MBEDTLS_TEST_ERROR_RECV_FAILED;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100716 }
Andrzej Kurekbc483de2020-01-22 03:40:00 -0500717
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100718 if (ret == MBEDTLS_TEST_ERROR_MESSAGE_TRUNCATED) {
Andrzej Kurekbc483de2020-01-22 03:40:00 -0500719 /* Drop the remaining part of the message */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100720 if (mbedtls_mock_tcp_recv_b(socket, NULL, drop_len) != (int) drop_len) {
721 /* Inconsistent state - part of the message was read,
722 * and a part couldn't. Not much we can do here, but it should not
723 * happen in test environment, unless forced manually. */
Andrzej Kurekbc483de2020-01-22 03:40:00 -0500724 }
725 }
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100726 mbedtls_test_message_queue_pop_info(queue, buf_len);
Andrzej Kurekbc483de2020-01-22 03:40:00 -0500727
728 return msg_len;
729}
730
Andrzej Kurek9155e7f2022-10-18 09:36:19 -0400731#if defined(MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED) && \
Gilles Peskine33d03fe2023-02-01 18:37:49 +0100732 defined(MBEDTLS_CERTS_C) && \
Manuel Pégourié-Gonnardd12402f2020-05-20 10:34:25 +0200733 defined(MBEDTLS_ENTROPY_C) && \
734 defined(MBEDTLS_CTR_DRBG_C)
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100735
736/*
737 * Structure with endpoint's certificates for SSL communication tests.
738 */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100739typedef struct mbedtls_endpoint_certificate {
740 mbedtls_x509_crt *ca_cert;
741 mbedtls_x509_crt *cert;
742 mbedtls_pk_context *pkey;
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100743} mbedtls_endpoint_certificate;
744
745/*
746 * Endpoint structure for SSL communication tests.
747 */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100748typedef struct mbedtls_endpoint {
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100749 const char *name;
750 mbedtls_ssl_context ssl;
751 mbedtls_ssl_config conf;
752 mbedtls_ctr_drbg_context ctr_drbg;
753 mbedtls_entropy_context entropy;
754 mbedtls_mock_socket socket;
755 mbedtls_endpoint_certificate cert;
756} mbedtls_endpoint;
757
758/*
Andrzej Kurek0d2982b2022-10-18 07:55:46 -0400759 * Deinitializes certificates from endpoint represented by \p ep.
760 */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100761void mbedtls_endpoint_certificate_free(mbedtls_endpoint *ep)
Andrzej Kurek0d2982b2022-10-18 07:55:46 -0400762{
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100763 mbedtls_endpoint_certificate *cert = &(ep->cert);
764 if (cert != NULL) {
765 if (cert->ca_cert != NULL) {
766 mbedtls_x509_crt_free(cert->ca_cert);
767 mbedtls_free(cert->ca_cert);
Andrzej Kurek0d2982b2022-10-18 07:55:46 -0400768 cert->ca_cert = NULL;
769 }
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100770 if (cert->cert != NULL) {
771 mbedtls_x509_crt_free(cert->cert);
772 mbedtls_free(cert->cert);
Andrzej Kurek0d2982b2022-10-18 07:55:46 -0400773 cert->cert = NULL;
774 }
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100775 if (cert->pkey != NULL) {
Andrzej Kurek0d2982b2022-10-18 07:55:46 -0400776#if defined(MBEDTLS_USE_PSA_CRYPTO)
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100777 if (mbedtls_pk_get_type(cert->pkey) == MBEDTLS_PK_OPAQUE) {
Andrzej Kurek0d2982b2022-10-18 07:55:46 -0400778 mbedtls_svc_key_id_t *key_slot = cert->pkey->pk_ctx;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100779 psa_destroy_key(*key_slot);
Andrzej Kurek0d2982b2022-10-18 07:55:46 -0400780 }
781#endif
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100782 mbedtls_pk_free(cert->pkey);
783 mbedtls_free(cert->pkey);
Andrzej Kurek0d2982b2022-10-18 07:55:46 -0400784 cert->pkey = NULL;
785 }
786 }
787}
788
789/*
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100790 * Initializes \p ep_cert structure and assigns it to endpoint
791 * represented by \p ep.
792 *
793 * \retval 0 on success, otherwise error code.
794 */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100795int mbedtls_endpoint_certificate_init(mbedtls_endpoint *ep, int pk_alg)
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100796{
797 int i = 0;
798 int ret = -1;
Andrzej Kurek0d2982b2022-10-18 07:55:46 -0400799 mbedtls_endpoint_certificate *cert = NULL;
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100800
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100801 if (ep == NULL) {
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100802 return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
803 }
804
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100805 cert = &(ep->cert);
806 ASSERT_ALLOC(cert->ca_cert, 1);
807 ASSERT_ALLOC(cert->cert, 1);
808 ASSERT_ALLOC(cert->pkey, 1);
Andrzej Kurek0d2982b2022-10-18 07:55:46 -0400809
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100810 mbedtls_x509_crt_init(cert->ca_cert);
811 mbedtls_x509_crt_init(cert->cert);
812 mbedtls_pk_init(cert->pkey);
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100813
814 /* Load the trusted CA */
815
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100816 for (i = 0; mbedtls_test_cas_der[i] != NULL; i++) {
817 ret = mbedtls_x509_crt_parse_der(cert->ca_cert,
818 (const unsigned char *) mbedtls_test_cas_der[i],
819 mbedtls_test_cas_der_len[i]);
820 TEST_ASSERT(ret == 0);
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100821 }
822
823 /* Load own certificate and private key */
824
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100825 if (ep->conf.endpoint == MBEDTLS_SSL_IS_SERVER) {
826 if (pk_alg == MBEDTLS_PK_RSA) {
827 ret = mbedtls_x509_crt_parse(cert->cert,
828 (const unsigned char *) mbedtls_test_srv_crt_rsa_sha256_der,
829 mbedtls_test_srv_crt_rsa_sha256_der_len);
830 TEST_ASSERT(ret == 0);
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100831
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100832 ret = mbedtls_pk_parse_key(cert->pkey,
833 (const unsigned char *) mbedtls_test_srv_key_rsa_der,
834 mbedtls_test_srv_key_rsa_der_len, NULL, 0);
835 TEST_ASSERT(ret == 0);
836 } else {
837 ret = mbedtls_x509_crt_parse(cert->cert,
838 (const unsigned char *) mbedtls_test_srv_crt_ec_der,
839 mbedtls_test_srv_crt_ec_der_len);
840 TEST_ASSERT(ret == 0);
841
842 ret = mbedtls_pk_parse_key(cert->pkey,
843 (const unsigned char *) mbedtls_test_srv_key_ec_der,
844 mbedtls_test_srv_key_ec_der_len, NULL, 0);
845 TEST_ASSERT(ret == 0);
Andrzej Kurekb2980742020-02-02 19:25:26 -0500846 }
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100847 } else {
848 if (pk_alg == MBEDTLS_PK_RSA) {
849 ret = mbedtls_x509_crt_parse(cert->cert,
850 (const unsigned char *) mbedtls_test_cli_crt_rsa_der,
851 mbedtls_test_cli_crt_rsa_der_len);
852 TEST_ASSERT(ret == 0);
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100853
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100854 ret = mbedtls_pk_parse_key(cert->pkey,
855 (const unsigned char *) mbedtls_test_cli_key_rsa_der,
856 mbedtls_test_cli_key_rsa_der_len, NULL, 0);
857 TEST_ASSERT(ret == 0);
858 } else {
859 ret = mbedtls_x509_crt_parse(cert->cert,
860 (const unsigned char *) mbedtls_test_cli_crt_ec_der,
861 mbedtls_test_cli_crt_ec_len);
862 TEST_ASSERT(ret == 0);
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100863
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100864 ret = mbedtls_pk_parse_key(cert->pkey,
865 (const unsigned char *) mbedtls_test_cli_key_ec_der,
866 mbedtls_test_cli_key_ec_der_len, NULL, 0);
867 TEST_ASSERT(ret == 0);
Andrzej Kurekb2980742020-02-02 19:25:26 -0500868 }
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100869 }
870
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100871 mbedtls_ssl_conf_ca_chain(&(ep->conf), cert->ca_cert, NULL);
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100872
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100873 ret = mbedtls_ssl_conf_own_cert(&(ep->conf), cert->cert,
874 cert->pkey);
875 TEST_ASSERT(ret == 0);
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100876
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100877exit:
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100878 if (ret != 0) {
879 mbedtls_endpoint_certificate_free(ep);
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100880 }
881
882 return ret;
883}
884
885/*
886 * Initializes \p ep structure. It is important to call `mbedtls_endpoint_free()`
887 * after calling this function even if it fails.
888 *
889 * \p endpoint_type must be set as MBEDTLS_SSL_IS_SERVER or
890 * MBEDTLS_SSL_IS_CLIENT.
Andrzej Kurek15daf502020-02-12 09:17:52 -0500891 * \p pk_alg the algorithm to use, currently only MBEDTLS_PK_RSA and
892 * MBEDTLS_PK_ECDSA are supported.
893 * \p dtls_context - in case of DTLS - this is the context handling metadata.
894 * \p input_queue - used only in case of DTLS.
895 * \p output_queue - used only in case of DTLS.
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100896 *
897 * \retval 0 on success, otherwise error code.
898 */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100899int mbedtls_endpoint_init(mbedtls_endpoint *ep, int endpoint_type, int pk_alg,
900 mbedtls_test_message_socket_context *dtls_context,
901 mbedtls_test_message_queue *input_queue,
902 mbedtls_test_message_queue *output_queue,
903 const mbedtls_ecp_group_id *curves)
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100904{
905 int ret = -1;
906
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100907 if (dtls_context != NULL && (input_queue == NULL || output_queue == NULL)) {
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100908 return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
Andrzej Kurek15daf502020-02-12 09:17:52 -0500909 }
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100910
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100911 if (ep == NULL) {
912 return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
913 }
914
915 memset(ep, 0, sizeof(*ep));
916
917 ep->name = (endpoint_type == MBEDTLS_SSL_IS_SERVER) ? "Server" : "Client";
918
919 mbedtls_ssl_init(&(ep->ssl));
920 mbedtls_ssl_config_init(&(ep->conf));
921 mbedtls_ctr_drbg_init(&(ep->ctr_drbg));
922 mbedtls_ssl_conf_rng(&(ep->conf),
923 mbedtls_ctr_drbg_random,
924 &(ep->ctr_drbg));
925 mbedtls_entropy_init(&(ep->entropy));
926 if (dtls_context != NULL) {
927 TEST_ASSERT(mbedtls_message_socket_setup(input_queue, output_queue,
928 100, &(ep->socket),
929 dtls_context) == 0);
930 } else {
931 mbedtls_mock_socket_init(&(ep->socket));
932 }
933
934 ret = mbedtls_ctr_drbg_seed(&(ep->ctr_drbg), mbedtls_entropy_func,
935 &(ep->entropy), (const unsigned char *) (ep->name),
936 strlen(ep->name));
937 TEST_ASSERT(ret == 0);
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100938
939 /* Non-blocking callbacks without timeout */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100940 if (dtls_context != NULL) {
941 mbedtls_ssl_set_bio(&(ep->ssl), dtls_context,
942 mbedtls_mock_tcp_send_msg,
943 mbedtls_mock_tcp_recv_msg,
944 NULL);
945 } else {
946 mbedtls_ssl_set_bio(&(ep->ssl), &(ep->socket),
947 mbedtls_mock_tcp_send_nb,
948 mbedtls_mock_tcp_recv_nb,
949 NULL);
Andrzej Kurek15daf502020-02-12 09:17:52 -0500950 }
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100951
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100952 ret = mbedtls_ssl_config_defaults(&(ep->conf), endpoint_type,
953 (dtls_context != NULL) ?
954 MBEDTLS_SSL_TRANSPORT_DATAGRAM :
955 MBEDTLS_SSL_TRANSPORT_STREAM,
956 MBEDTLS_SSL_PRESET_DEFAULT);
957 TEST_ASSERT(ret == 0);
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100958
Andrzej Kurek96bf3d12022-04-15 07:35:16 -0400959#if defined(MBEDTLS_ECP_C)
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100960 if (curves != NULL) {
961 mbedtls_ssl_conf_curves(&(ep->conf), curves);
962 }
Andrzej Kurek96bf3d12022-04-15 07:35:16 -0400963#else
964 (void) curves;
965#endif
Andrzej Kurek535cd172022-03-08 06:50:12 -0500966
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100967 ret = mbedtls_ssl_setup(&(ep->ssl), &(ep->conf));
968 TEST_ASSERT(ret == 0);
Andrzej Kurek15daf502020-02-12 09:17:52 -0500969
970#if defined(MBEDTLS_SSL_PROTO_DTLS) && defined(MBEDTLS_SSL_SRV_C)
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100971 if (endpoint_type == MBEDTLS_SSL_IS_SERVER && dtls_context != NULL) {
972 mbedtls_ssl_conf_dtls_cookies(&(ep->conf), NULL, NULL, NULL);
973 }
Andrzej Kurek15daf502020-02-12 09:17:52 -0500974#endif
975
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100976 ret = mbedtls_endpoint_certificate_init(ep, pk_alg);
977 TEST_ASSERT(ret == 0);
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100978
979exit:
980 return ret;
981}
982
983/*
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100984 * Deinitializes endpoint represented by \p ep.
985 */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100986void mbedtls_endpoint_free(mbedtls_endpoint *ep,
987 mbedtls_test_message_socket_context *context)
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100988{
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100989 mbedtls_endpoint_certificate_free(ep);
Piotr Nowicki2a1f1782020-01-13 09:42:10 +0100990
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100991 mbedtls_ssl_free(&(ep->ssl));
992 mbedtls_ssl_config_free(&(ep->conf));
993 mbedtls_ctr_drbg_free(&(ep->ctr_drbg));
994 mbedtls_entropy_free(&(ep->entropy));
Andrzej Kurek15daf502020-02-12 09:17:52 -0500995
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100996 if (context != NULL) {
997 mbedtls_message_socket_close(context);
998 } else {
999 mbedtls_mock_socket_close(&(ep->socket));
Andrzej Kurek15daf502020-02-12 09:17:52 -05001000 }
Piotr Nowicki2a1f1782020-01-13 09:42:10 +01001001}
1002
1003/*
1004 * This function moves ssl handshake from \p ssl to prescribed \p state.
1005 * /p second_ssl is used as second endpoint and their sockets have to be
1006 * connected before calling this function.
1007 *
1008 * \retval 0 on success, otherwise error code.
1009 */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001010int mbedtls_move_handshake_to_state(mbedtls_ssl_context *ssl,
1011 mbedtls_ssl_context *second_ssl,
1012 int state)
Piotr Nowicki2a1f1782020-01-13 09:42:10 +01001013{
1014 enum { BUFFSIZE = 1024 };
1015 int max_steps = 1000;
1016 int ret = 0;
1017
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001018 if (ssl == NULL || second_ssl == NULL) {
Piotr Nowicki2a1f1782020-01-13 09:42:10 +01001019 return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
1020 }
1021
1022 /* Perform communication via connected sockets */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001023 while ((ssl->state != state) && (--max_steps >= 0)) {
Piotr Nowicki2a1f1782020-01-13 09:42:10 +01001024 /* If /p second_ssl ends the handshake procedure before /p ssl then
1025 * there is no need to call the next step */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001026 if (second_ssl->state != MBEDTLS_SSL_HANDSHAKE_OVER) {
1027 ret = mbedtls_ssl_handshake_step(second_ssl);
1028 if (ret != 0 && ret != MBEDTLS_ERR_SSL_WANT_READ &&
1029 ret != MBEDTLS_ERR_SSL_WANT_WRITE) {
Piotr Nowicki2a1f1782020-01-13 09:42:10 +01001030 return ret;
1031 }
1032 }
1033
1034 /* We only care about the \p ssl state and returns, so we call it last,
1035 * to leave the iteration as soon as the state is as expected. */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001036 ret = mbedtls_ssl_handshake_step(ssl);
1037 if (ret != 0 && ret != MBEDTLS_ERR_SSL_WANT_READ &&
1038 ret != MBEDTLS_ERR_SSL_WANT_WRITE) {
Piotr Nowicki2a1f1782020-01-13 09:42:10 +01001039 return ret;
1040 }
1041 }
1042
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001043 return (max_steps >= 0) ? ret : -1;
Piotr Nowicki2a1f1782020-01-13 09:42:10 +01001044}
1045
Gilles Peskine33d03fe2023-02-01 18:37:49 +01001046#endif \
1047 /* MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED && MBEDTLS_CERTS_C && MBEDTLS_ENTROPY_C && MBEDTLS_CTR_DRBG_C */
Piotr Nowicki2a1f1782020-01-13 09:42:10 +01001048
Janos Follath3766ba52019-11-27 13:31:42 +00001049/*
Piotr Nowicki438bf3b2020-03-10 12:59:10 +01001050 * Write application data. Increase write counter if necessary.
Piotr Nowickic3fca5e2020-01-30 15:33:42 +01001051 */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001052int mbedtls_ssl_write_fragment(mbedtls_ssl_context *ssl, unsigned char *buf,
1053 int buf_len, int *written,
1054 const int expected_fragments)
Piotr Nowickic3fca5e2020-01-30 15:33:42 +01001055{
Dave Rodgmancd09d682023-02-24 15:41:55 +00001056 /* Verify that calling mbedtls_ssl_write with a NULL buffer and zero length is
1057 * a valid no-op for TLS connections. */
1058 if (ssl->conf->transport != MBEDTLS_SSL_TRANSPORT_DATAGRAM) {
1059 TEST_ASSERT(mbedtls_ssl_write(ssl, NULL, 0) == 0);
1060 }
1061
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001062 int ret = mbedtls_ssl_write(ssl, buf + *written, buf_len - *written);
1063 if (ret > 0) {
Piotr Nowicki6a7f01c2020-02-12 13:53:36 +01001064 *written += ret;
Piotr Nowickic3fca5e2020-01-30 15:33:42 +01001065 }
Piotr Nowicki6a7f01c2020-02-12 13:53:36 +01001066
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001067 if (expected_fragments == 0) {
Piotr Nowicki6a7f01c2020-02-12 13:53:36 +01001068 /* Used for DTLS and the message size larger than MFL. In that case
1069 * the message can not be fragmented and the library should return
1070 * MBEDTLS_ERR_SSL_BAD_INPUT_DATA error. This error must be returned
1071 * to prevent a dead loop inside mbedtls_exchange_data(). */
1072 return ret;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001073 } else if (expected_fragments == 1) {
Piotr Nowicki6a7f01c2020-02-12 13:53:36 +01001074 /* Used for TLS/DTLS and the message size lower than MFL */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001075 TEST_ASSERT(ret == buf_len ||
1076 ret == MBEDTLS_ERR_SSL_WANT_READ ||
1077 ret == MBEDTLS_ERR_SSL_WANT_WRITE);
1078 } else {
Piotr Nowicki6a7f01c2020-02-12 13:53:36 +01001079 /* Used for TLS and the message size larger than MFL */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001080 TEST_ASSERT(expected_fragments > 1);
1081 TEST_ASSERT((ret >= 0 && ret <= buf_len) ||
1082 ret == MBEDTLS_ERR_SSL_WANT_READ ||
1083 ret == MBEDTLS_ERR_SSL_WANT_WRITE);
Piotr Nowicki6a7f01c2020-02-12 13:53:36 +01001084 }
1085
1086 return 0;
1087
1088exit:
1089 /* Some of the tests failed */
1090 return -1;
Piotr Nowickic3fca5e2020-01-30 15:33:42 +01001091}
1092
1093/*
Piotr Nowicki438bf3b2020-03-10 12:59:10 +01001094 * Read application data and increase read counter and fragments counter if necessary.
Piotr Nowickic3fca5e2020-01-30 15:33:42 +01001095 */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001096int mbedtls_ssl_read_fragment(mbedtls_ssl_context *ssl, unsigned char *buf,
1097 int buf_len, int *read,
1098 int *fragments, const int expected_fragments)
Piotr Nowickic3fca5e2020-01-30 15:33:42 +01001099{
Dave Rodgmancd09d682023-02-24 15:41:55 +00001100 /* Verify that calling mbedtls_ssl_write with a NULL buffer and zero length is
1101 * a valid no-op for TLS connections. */
1102 if (ssl->conf->transport != MBEDTLS_SSL_TRANSPORT_DATAGRAM) {
1103 TEST_ASSERT(mbedtls_ssl_read(ssl, NULL, 0) == 0);
1104 }
1105
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001106 int ret = mbedtls_ssl_read(ssl, buf + *read, buf_len - *read);
1107 if (ret > 0) {
1108 (*fragments)++;
Piotr Nowickic3fca5e2020-01-30 15:33:42 +01001109 *read += ret;
1110 }
Piotr Nowicki6a7f01c2020-02-12 13:53:36 +01001111
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001112 if (expected_fragments == 0) {
1113 TEST_ASSERT(ret == 0);
1114 } else if (expected_fragments == 1) {
1115 TEST_ASSERT(ret == buf_len ||
1116 ret == MBEDTLS_ERR_SSL_WANT_READ ||
1117 ret == MBEDTLS_ERR_SSL_WANT_WRITE);
1118 } else {
1119 TEST_ASSERT(expected_fragments > 1);
1120 TEST_ASSERT((ret >= 0 && ret <= buf_len) ||
1121 ret == MBEDTLS_ERR_SSL_WANT_READ ||
1122 ret == MBEDTLS_ERR_SSL_WANT_WRITE);
Piotr Nowicki6a7f01c2020-02-12 13:53:36 +01001123 }
1124
1125 return 0;
1126
1127exit:
1128 /* Some of the tests failed */
1129 return -1;
Piotr Nowickic3fca5e2020-01-30 15:33:42 +01001130}
1131
1132/*
Hanno Beckera18d1322018-01-03 14:27:32 +00001133 * Helper function setting up inverse record transformations
1134 * using given cipher, hash, EtM mode, authentication tag length,
1135 * and version.
1136 */
1137
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001138#define CHK(x) \
Hanno Beckera18d1322018-01-03 14:27:32 +00001139 do \
1140 { \
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001141 if (!(x)) \
Hanno Becker81e16a32019-03-01 11:21:44 +00001142 { \
Hanno Beckera5780f12019-04-05 09:55:37 +01001143 ret = -1; \
Hanno Becker81e16a32019-03-01 11:21:44 +00001144 goto cleanup; \
1145 } \
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001146 } while (0)
Hanno Beckera18d1322018-01-03 14:27:32 +00001147
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001148void set_ciphersuite(mbedtls_ssl_config *conf, const char *cipher,
1149 int *forced_ciphersuite)
Andrzej Kurekf40daa32020-02-04 09:00:01 -05001150{
1151 const mbedtls_ssl_ciphersuite_t *ciphersuite_info;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001152 forced_ciphersuite[0] = mbedtls_ssl_get_ciphersuite_id(cipher);
Andrzej Kurekf40daa32020-02-04 09:00:01 -05001153 forced_ciphersuite[1] = 0;
1154
1155 ciphersuite_info =
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001156 mbedtls_ssl_ciphersuite_from_id(forced_ciphersuite[0]);
Andrzej Kurekf40daa32020-02-04 09:00:01 -05001157
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001158 TEST_ASSERT(ciphersuite_info != NULL);
1159 TEST_ASSERT(ciphersuite_info->min_minor_ver <= conf->max_minor_ver);
1160 TEST_ASSERT(ciphersuite_info->max_minor_ver >= conf->min_minor_ver);
Andrzej Kurekf40daa32020-02-04 09:00:01 -05001161
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001162 if (conf->max_minor_ver > ciphersuite_info->max_minor_ver) {
Andrzej Kurekf40daa32020-02-04 09:00:01 -05001163 conf->max_minor_ver = ciphersuite_info->max_minor_ver;
1164 }
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001165 if (conf->min_minor_ver < ciphersuite_info->min_minor_ver) {
Andrzej Kurekf40daa32020-02-04 09:00:01 -05001166 conf->min_minor_ver = ciphersuite_info->min_minor_ver;
1167 }
1168
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001169 mbedtls_ssl_conf_ciphersuites(conf, forced_ciphersuite);
Andrzej Kurekf40daa32020-02-04 09:00:01 -05001170
1171exit:
1172 return;
1173}
1174
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001175int psk_dummy_callback(void *p_info, mbedtls_ssl_context *ssl,
1176 const unsigned char *name, size_t name_len)
Andrzej Kurekcc5169c2020-02-04 09:04:56 -05001177{
1178 (void) p_info;
1179 (void) ssl;
1180 (void) name;
1181 (void) name_len;
1182
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001183 return 0;
Andrzej Kurekcc5169c2020-02-04 09:04:56 -05001184}
1185
Hanno Beckerd856c822019-04-29 17:30:59 +01001186#if MBEDTLS_SSL_CID_OUT_LEN_MAX > MBEDTLS_SSL_CID_IN_LEN_MAX
1187#define SSL_CID_LEN_MIN MBEDTLS_SSL_CID_IN_LEN_MAX
1188#else
1189#define SSL_CID_LEN_MIN MBEDTLS_SSL_CID_OUT_LEN_MAX
1190#endif
Hanno Beckera18d1322018-01-03 14:27:32 +00001191
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001192static int build_transforms(mbedtls_ssl_transform *t_in,
1193 mbedtls_ssl_transform *t_out,
1194 int cipher_type, int hash_id,
1195 int etm, int tag_mode, int ver,
1196 size_t cid0_len,
1197 size_t cid1_len)
Hanno Beckera18d1322018-01-03 14:27:32 +00001198{
1199 mbedtls_cipher_info_t const *cipher_info;
Hanno Beckera5780f12019-04-05 09:55:37 +01001200 int ret = 0;
Hanno Beckera18d1322018-01-03 14:27:32 +00001201
1202 size_t keylen, maclen, ivlen;
Hanno Becker81e16a32019-03-01 11:21:44 +00001203 unsigned char *key0 = NULL, *key1 = NULL;
Paul Elliott6f1eda72020-06-11 20:22:00 +01001204 unsigned char *md0 = NULL, *md1 = NULL;
Hanno Beckera18d1322018-01-03 14:27:32 +00001205 unsigned char iv_enc[16], iv_dec[16];
1206
Hanno Beckera0e20d02019-05-15 14:03:01 +01001207#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001208 unsigned char cid0[SSL_CID_LEN_MIN];
1209 unsigned char cid1[SSL_CID_LEN_MIN];
Hanno Beckerd856c822019-04-29 17:30:59 +01001210
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001211 mbedtls_test_rnd_std_rand(NULL, cid0, sizeof(cid0));
1212 mbedtls_test_rnd_std_rand(NULL, cid1, sizeof(cid1));
Hanno Becker43c24b82019-05-01 09:45:57 +01001213#else
1214 ((void) cid0_len);
1215 ((void) cid1_len);
Hanno Beckera0e20d02019-05-15 14:03:01 +01001216#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
Hanno Beckerd856c822019-04-29 17:30:59 +01001217
Hanno Beckera18d1322018-01-03 14:27:32 +00001218 maclen = 0;
1219
1220 /* Pick cipher */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001221 cipher_info = mbedtls_cipher_info_from_type(cipher_type);
1222 CHK(cipher_info != NULL);
1223 CHK(cipher_info->iv_size <= 16);
1224 CHK(cipher_info->key_bitlen % 8 == 0);
Hanno Beckera18d1322018-01-03 14:27:32 +00001225
1226 /* Pick keys */
1227 keylen = cipher_info->key_bitlen / 8;
Hanno Becker78d1f702019-04-05 09:56:10 +01001228 /* Allocate `keylen + 1` bytes to ensure that we get
1229 * a non-NULL pointers from `mbedtls_calloc` even if
1230 * `keylen == 0` in the case of the NULL cipher. */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001231 CHK((key0 = mbedtls_calloc(1, keylen + 1)) != NULL);
1232 CHK((key1 = mbedtls_calloc(1, keylen + 1)) != NULL);
1233 memset(key0, 0x1, keylen);
1234 memset(key1, 0x2, keylen);
Hanno Beckera18d1322018-01-03 14:27:32 +00001235
1236 /* Setup cipher contexts */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001237 CHK(mbedtls_cipher_setup(&t_in->cipher_ctx_enc, cipher_info) == 0);
1238 CHK(mbedtls_cipher_setup(&t_in->cipher_ctx_dec, cipher_info) == 0);
1239 CHK(mbedtls_cipher_setup(&t_out->cipher_ctx_enc, cipher_info) == 0);
1240 CHK(mbedtls_cipher_setup(&t_out->cipher_ctx_dec, cipher_info) == 0);
Hanno Beckera18d1322018-01-03 14:27:32 +00001241
1242#if defined(MBEDTLS_CIPHER_MODE_CBC)
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001243 if (cipher_info->mode == MBEDTLS_MODE_CBC) {
1244 CHK(mbedtls_cipher_set_padding_mode(&t_in->cipher_ctx_enc,
1245 MBEDTLS_PADDING_NONE) == 0);
1246 CHK(mbedtls_cipher_set_padding_mode(&t_in->cipher_ctx_dec,
1247 MBEDTLS_PADDING_NONE) == 0);
1248 CHK(mbedtls_cipher_set_padding_mode(&t_out->cipher_ctx_enc,
1249 MBEDTLS_PADDING_NONE) == 0);
1250 CHK(mbedtls_cipher_set_padding_mode(&t_out->cipher_ctx_dec,
1251 MBEDTLS_PADDING_NONE) == 0);
Hanno Beckera18d1322018-01-03 14:27:32 +00001252 }
1253#endif /* MBEDTLS_CIPHER_MODE_CBC */
1254
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001255 CHK(mbedtls_cipher_setkey(&t_in->cipher_ctx_enc, key0,
1256 keylen << 3, MBEDTLS_ENCRYPT) == 0);
1257 CHK(mbedtls_cipher_setkey(&t_in->cipher_ctx_dec, key1,
1258 keylen << 3, MBEDTLS_DECRYPT) == 0);
1259 CHK(mbedtls_cipher_setkey(&t_out->cipher_ctx_enc, key1,
1260 keylen << 3, MBEDTLS_ENCRYPT) == 0);
1261 CHK(mbedtls_cipher_setkey(&t_out->cipher_ctx_dec, key0,
1262 keylen << 3, MBEDTLS_DECRYPT) == 0);
Hanno Beckera18d1322018-01-03 14:27:32 +00001263
1264 /* Setup MAC contexts */
1265#if defined(MBEDTLS_SSL_SOME_MODES_USE_MAC)
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001266 if (cipher_info->mode == MBEDTLS_MODE_CBC ||
1267 cipher_info->mode == MBEDTLS_MODE_STREAM) {
Hanno Beckera18d1322018-01-03 14:27:32 +00001268 mbedtls_md_info_t const *md_info;
Hanno Beckera18d1322018-01-03 14:27:32 +00001269
1270 /* Pick hash */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001271 md_info = mbedtls_md_info_from_type(hash_id);
1272 CHK(md_info != NULL);
Hanno Beckera18d1322018-01-03 14:27:32 +00001273
1274 /* Pick hash keys */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001275 maclen = mbedtls_md_get_size(md_info);
1276 CHK((md0 = mbedtls_calloc(1, maclen)) != NULL);
1277 CHK((md1 = mbedtls_calloc(1, maclen)) != NULL);
1278 memset(md0, 0x5, maclen);
1279 memset(md1, 0x6, maclen);
Hanno Beckera18d1322018-01-03 14:27:32 +00001280
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001281 CHK(mbedtls_md_setup(&t_out->md_ctx_enc, md_info, 1) == 0);
1282 CHK(mbedtls_md_setup(&t_out->md_ctx_dec, md_info, 1) == 0);
1283 CHK(mbedtls_md_setup(&t_in->md_ctx_enc, md_info, 1) == 0);
1284 CHK(mbedtls_md_setup(&t_in->md_ctx_dec, md_info, 1) == 0);
Hanno Beckera18d1322018-01-03 14:27:32 +00001285
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001286 if (ver > MBEDTLS_SSL_MINOR_VERSION_0) {
1287 CHK(mbedtls_md_hmac_starts(&t_in->md_ctx_enc,
1288 md0, maclen) == 0);
1289 CHK(mbedtls_md_hmac_starts(&t_in->md_ctx_dec,
1290 md1, maclen) == 0);
1291 CHK(mbedtls_md_hmac_starts(&t_out->md_ctx_enc,
1292 md1, maclen) == 0);
1293 CHK(mbedtls_md_hmac_starts(&t_out->md_ctx_dec,
1294 md0, maclen) == 0);
Hanno Beckera18d1322018-01-03 14:27:32 +00001295 }
1296#if defined(MBEDTLS_SSL_PROTO_SSL3)
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001297 else {
1298 memcpy(&t_in->mac_enc, md0, maclen);
1299 memcpy(&t_in->mac_dec, md1, maclen);
1300 memcpy(&t_out->mac_enc, md1, maclen);
1301 memcpy(&t_out->mac_dec, md0, maclen);
Hanno Beckera18d1322018-01-03 14:27:32 +00001302 }
1303#endif
Hanno Beckera18d1322018-01-03 14:27:32 +00001304 }
1305#else
1306 ((void) hash_id);
1307#endif /* MBEDTLS_SSL_SOME_MODES_USE_MAC */
1308
1309
1310 /* Pick IV's (regardless of whether they
1311 * are being used by the transform). */
1312 ivlen = cipher_info->iv_size;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001313 memset(iv_enc, 0x3, sizeof(iv_enc));
1314 memset(iv_dec, 0x4, sizeof(iv_dec));
Hanno Beckera18d1322018-01-03 14:27:32 +00001315
1316 /*
1317 * Setup transforms
1318 */
1319
Jaeden Amero2de07f12019-06-05 13:32:08 +01001320#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC) && \
1321 defined(MBEDTLS_SSL_SOME_MODES_USE_MAC)
Hanno Beckera18d1322018-01-03 14:27:32 +00001322 t_out->encrypt_then_mac = etm;
1323 t_in->encrypt_then_mac = etm;
1324#else
1325 ((void) etm);
1326#endif
1327
1328 t_out->minor_ver = ver;
1329 t_in->minor_ver = ver;
1330 t_out->ivlen = ivlen;
1331 t_in->ivlen = ivlen;
1332
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001333 switch (cipher_info->mode) {
Hanno Beckera18d1322018-01-03 14:27:32 +00001334 case MBEDTLS_MODE_GCM:
1335 case MBEDTLS_MODE_CCM:
Hanno Beckere6832872020-05-28 08:29:58 +01001336#if defined(MBEDTLS_SSL_PROTO_TLS1_3_EXPERIMENTAL)
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001337 if (ver == MBEDTLS_SSL_MINOR_VERSION_4) {
Hanno Beckere6832872020-05-28 08:29:58 +01001338 t_out->fixed_ivlen = 12;
1339 t_in->fixed_ivlen = 12;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001340 } else
Hanno Beckere6832872020-05-28 08:29:58 +01001341#endif /* MBEDTLS_SSL_PROTO_TLS1_3_EXPERIMENTAL */
1342 {
1343 t_out->fixed_ivlen = 4;
1344 t_in->fixed_ivlen = 4;
1345 }
Hanno Beckera18d1322018-01-03 14:27:32 +00001346 t_out->maclen = 0;
1347 t_in->maclen = 0;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001348 switch (tag_mode) {
Hanno Beckera18d1322018-01-03 14:27:32 +00001349 case 0: /* Full tag */
1350 t_out->taglen = 16;
1351 t_in->taglen = 16;
1352 break;
1353 case 1: /* Partial tag */
1354 t_out->taglen = 8;
1355 t_in->taglen = 8;
1356 break;
1357 default:
Paul Elliottc7b53742021-02-03 13:18:33 +00001358 ret = 1;
1359 goto cleanup;
Hanno Beckera18d1322018-01-03 14:27:32 +00001360 }
1361 break;
1362
1363 case MBEDTLS_MODE_CHACHAPOLY:
1364 t_out->fixed_ivlen = 12;
1365 t_in->fixed_ivlen = 12;
1366 t_out->maclen = 0;
1367 t_in->maclen = 0;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001368 switch (tag_mode) {
Hanno Beckera18d1322018-01-03 14:27:32 +00001369 case 0: /* Full tag */
1370 t_out->taglen = 16;
1371 t_in->taglen = 16;
1372 break;
1373 case 1: /* Partial tag */
1374 t_out->taglen = 8;
1375 t_in->taglen = 8;
1376 break;
1377 default:
Paul Elliottc7b53742021-02-03 13:18:33 +00001378 ret = 1;
1379 goto cleanup;
Hanno Beckera18d1322018-01-03 14:27:32 +00001380 }
1381 break;
1382
1383 case MBEDTLS_MODE_STREAM:
1384 case MBEDTLS_MODE_CBC:
1385 t_out->fixed_ivlen = 0; /* redundant, must be 0 */
1386 t_in->fixed_ivlen = 0; /* redundant, must be 0 */
1387 t_out->taglen = 0;
1388 t_in->taglen = 0;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001389 switch (tag_mode) {
Hanno Beckera18d1322018-01-03 14:27:32 +00001390 case 0: /* Full tag */
1391 t_out->maclen = maclen;
1392 t_in->maclen = maclen;
1393 break;
1394 case 1: /* Partial tag */
1395 t_out->maclen = 10;
1396 t_in->maclen = 10;
1397 break;
1398 default:
Paul Elliottc7b53742021-02-03 13:18:33 +00001399 ret = 1;
1400 goto cleanup;
Hanno Beckera18d1322018-01-03 14:27:32 +00001401 }
1402 break;
1403 default:
Paul Elliottc7b53742021-02-03 13:18:33 +00001404 ret = 1;
1405 goto cleanup;
Hanno Beckera18d1322018-01-03 14:27:32 +00001406 break;
1407 }
1408
1409 /* Setup IV's */
1410
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001411 memcpy(&t_in->iv_dec, iv_dec, sizeof(iv_dec));
1412 memcpy(&t_in->iv_enc, iv_enc, sizeof(iv_enc));
1413 memcpy(&t_out->iv_dec, iv_enc, sizeof(iv_enc));
1414 memcpy(&t_out->iv_enc, iv_dec, sizeof(iv_dec));
Hanno Beckera18d1322018-01-03 14:27:32 +00001415
Hanno Beckera0e20d02019-05-15 14:03:01 +01001416#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
Hanno Beckerd856c822019-04-29 17:30:59 +01001417 /* Add CID */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001418 memcpy(&t_in->in_cid, cid0, cid0_len);
1419 memcpy(&t_in->out_cid, cid1, cid1_len);
Hanno Beckerd856c822019-04-29 17:30:59 +01001420 t_in->in_cid_len = cid0_len;
1421 t_in->out_cid_len = cid1_len;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001422 memcpy(&t_out->in_cid, cid1, cid1_len);
1423 memcpy(&t_out->out_cid, cid0, cid0_len);
Hanno Beckerd856c822019-04-29 17:30:59 +01001424 t_out->in_cid_len = cid1_len;
1425 t_out->out_cid_len = cid0_len;
Hanno Beckera0e20d02019-05-15 14:03:01 +01001426#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
Hanno Beckerd856c822019-04-29 17:30:59 +01001427
Hanno Becker81e16a32019-03-01 11:21:44 +00001428cleanup:
1429
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001430 mbedtls_free(key0);
1431 mbedtls_free(key1);
Hanno Becker81e16a32019-03-01 11:21:44 +00001432
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001433 mbedtls_free(md0);
1434 mbedtls_free(md1);
Paul Elliott6f1eda72020-06-11 20:22:00 +01001435
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001436 return ret;
Hanno Beckera18d1322018-01-03 14:27:32 +00001437}
1438
Manuel Pégourié-Gonnard3caa6ca2019-05-23 10:06:14 +02001439/*
Manuel Pégourié-Gonnard686adb42019-06-03 09:55:16 +02001440 * Populate a session structure for serialization tests.
Manuel Pégourié-Gonnard3caa6ca2019-05-23 10:06:14 +02001441 * Choose dummy values, mostly non-0 to distinguish from the init default.
1442 */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001443static int ssl_populate_session(mbedtls_ssl_session *session,
1444 int ticket_len,
1445 const char *crt_file)
Manuel Pégourié-Gonnard3caa6ca2019-05-23 10:06:14 +02001446{
1447#if defined(MBEDTLS_HAVE_TIME)
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001448 session->start = mbedtls_time(NULL) - 42;
Manuel Pégourié-Gonnard3caa6ca2019-05-23 10:06:14 +02001449#endif
1450 session->ciphersuite = 0xabcd;
1451 session->compression = 1;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001452 session->id_len = sizeof(session->id);
1453 memset(session->id, 66, session->id_len);
1454 memset(session->master, 17, sizeof(session->master));
Manuel Pégourié-Gonnard3caa6ca2019-05-23 10:06:14 +02001455
Gilles Peskine33d03fe2023-02-01 18:37:49 +01001456#if defined(MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED) && \
1457 defined(MBEDTLS_CERTS_C) && \
1458 defined(MBEDTLS_FS_IO)
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001459 if (strlen(crt_file) != 0) {
Manuel Pégourié-Gonnardee13a732019-07-29 13:00:39 +02001460 mbedtls_x509_crt tmp_crt;
Manuel Pégourié-Gonnard3caa6ca2019-05-23 10:06:14 +02001461 int ret;
Manuel Pégourié-Gonnard6b840702019-05-24 09:40:17 +02001462
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001463 mbedtls_x509_crt_init(&tmp_crt);
1464 ret = mbedtls_x509_crt_parse_file(&tmp_crt, crt_file);
1465 if (ret != 0) {
1466 return ret;
1467 }
Manuel Pégourié-Gonnardee13a732019-07-29 13:00:39 +02001468
1469#if defined(MBEDTLS_SSL_KEEP_PEER_CERTIFICATE)
1470 /* Move temporary CRT. */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001471 session->peer_cert = mbedtls_calloc(1, sizeof(*session->peer_cert));
1472 if (session->peer_cert == NULL) {
1473 return -1;
1474 }
Manuel Pégourié-Gonnardee13a732019-07-29 13:00:39 +02001475 *session->peer_cert = tmp_crt;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001476 memset(&tmp_crt, 0, sizeof(tmp_crt));
Manuel Pégourié-Gonnardee13a732019-07-29 13:00:39 +02001477#else /* MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
1478 /* Calculate digest of temporary CRT. */
1479 session->peer_cert_digest =
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001480 mbedtls_calloc(1, MBEDTLS_SSL_PEER_CERT_DIGEST_DFL_LEN);
1481 if (session->peer_cert_digest == NULL) {
1482 return -1;
1483 }
1484 ret = mbedtls_md(mbedtls_md_info_from_type(
1485 MBEDTLS_SSL_PEER_CERT_DIGEST_DFL_TYPE),
1486 tmp_crt.raw.p, tmp_crt.raw.len,
1487 session->peer_cert_digest);
1488 if (ret != 0) {
1489 return ret;
1490 }
Manuel Pégourié-Gonnardee13a732019-07-29 13:00:39 +02001491 session->peer_cert_digest_type =
1492 MBEDTLS_SSL_PEER_CERT_DIGEST_DFL_TYPE;
1493 session->peer_cert_digest_len =
1494 MBEDTLS_SSL_PEER_CERT_DIGEST_DFL_LEN;
1495#endif /* MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
1496
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001497 mbedtls_x509_crt_free(&tmp_crt);
Manuel Pégourié-Gonnard3caa6ca2019-05-23 10:06:14 +02001498 }
Gilles Peskine33d03fe2023-02-01 18:37:49 +01001499#else /* MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED && MBEDTLS_CERTS_C && MBEDTLS_FS_IO */
Manuel Pégourié-Gonnard3caa6ca2019-05-23 10:06:14 +02001500 (void) crt_file;
Gilles Peskine33d03fe2023-02-01 18:37:49 +01001501#endif /* MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED && MBEDTLS_CERTS_C && MBEDTLS_FS_IO */
Manuel Pégourié-Gonnard3caa6ca2019-05-23 10:06:14 +02001502 session->verify_result = 0xdeadbeef;
1503
1504#if defined(MBEDTLS_SSL_SESSION_TICKETS) && defined(MBEDTLS_SSL_CLI_C)
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001505 if (ticket_len != 0) {
1506 session->ticket = mbedtls_calloc(1, ticket_len);
1507 if (session->ticket == NULL) {
1508 return -1;
1509 }
1510 memset(session->ticket, 33, ticket_len);
Manuel Pégourié-Gonnard3caa6ca2019-05-23 10:06:14 +02001511 }
1512 session->ticket_len = ticket_len;
1513 session->ticket_lifetime = 86401;
1514#else
1515 (void) ticket_len;
1516#endif
1517
1518#if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
1519 session->mfl_code = 1;
1520#endif
1521#if defined(MBEDTLS_SSL_TRUNCATED_HMAC)
1522 session->trunc_hmac = 1;
1523#endif
1524#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
1525 session->encrypt_then_mac = 1;
1526#endif
1527
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001528 return 0;
Manuel Pégourié-Gonnard3caa6ca2019-05-23 10:06:14 +02001529}
1530
Piotr Nowicki6a7f01c2020-02-12 13:53:36 +01001531/*
1532 * Perform data exchanging between \p ssl_1 and \p ssl_2 and check if the
1533 * message was sent in the correct number of fragments.
1534 *
1535 * /p ssl_1 and /p ssl_2 Endpoints represented by mbedtls_ssl_context. Both
1536 * of them must be initialized and connected beforehand.
1537 * /p msg_len_1 and /p msg_len_2 specify the size of the message to send.
1538 * /p expected_fragments_1 and /p expected_fragments_2 determine in how many
1539 * fragments the message should be sent.
1540 * expected_fragments is 0: can be used for DTLS testing while the message
1541 * size is larger than MFL. In that case the message
1542 * cannot be fragmented and sent to the second endpoint.
1543 * This value can be used for negative tests.
1544 * expected_fragments is 1: can be used for TLS/DTLS testing while the
1545 * message size is below MFL
1546 * expected_fragments > 1: can be used for TLS testing while the message
1547 * size is larger than MFL
1548 *
1549 * \retval 0 on success, otherwise error code.
1550 */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001551int mbedtls_exchange_data(mbedtls_ssl_context *ssl_1,
1552 int msg_len_1, const int expected_fragments_1,
1553 mbedtls_ssl_context *ssl_2,
1554 int msg_len_2, const int expected_fragments_2)
Piotr Nowicki6a7f01c2020-02-12 13:53:36 +01001555{
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001556 unsigned char *msg_buf_1 = malloc(msg_len_1);
1557 unsigned char *msg_buf_2 = malloc(msg_len_2);
1558 unsigned char *in_buf_1 = malloc(msg_len_2);
1559 unsigned char *in_buf_2 = malloc(msg_len_1);
Piotr Nowicki6a7f01c2020-02-12 13:53:36 +01001560 int msg_type, ret = -1;
1561
1562 /* Perform this test with two message types. At first use a message
1563 * consisting of only 0x00 for the client and only 0xFF for the server.
1564 * At the second time use message with generated data */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001565 for (msg_type = 0; msg_type < 2; msg_type++) {
Piotr Nowicki6a7f01c2020-02-12 13:53:36 +01001566 int written_1 = 0;
1567 int written_2 = 0;
1568 int read_1 = 0;
1569 int read_2 = 0;
1570 int fragments_1 = 0;
1571 int fragments_2 = 0;
1572
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001573 if (msg_type == 0) {
1574 memset(msg_buf_1, 0x00, msg_len_1);
1575 memset(msg_buf_2, 0xff, msg_len_2);
1576 } else {
Piotr Nowicki6a7f01c2020-02-12 13:53:36 +01001577 int i, j = 0;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001578 for (i = 0; i < msg_len_1; i++) {
Piotr Nowicki6a7f01c2020-02-12 13:53:36 +01001579 msg_buf_1[i] = j++ & 0xFF;
1580 }
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001581 for (i = 0; i < msg_len_2; i++) {
1582 msg_buf_2[i] = (j -= 5) & 0xFF;
Piotr Nowicki6a7f01c2020-02-12 13:53:36 +01001583 }
1584 }
1585
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001586 while (read_1 < msg_len_2 || read_2 < msg_len_1) {
Piotr Nowicki6a7f01c2020-02-12 13:53:36 +01001587 /* ssl_1 sending */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001588 if (msg_len_1 > written_1) {
1589 ret = mbedtls_ssl_write_fragment(ssl_1, msg_buf_1,
1590 msg_len_1, &written_1,
1591 expected_fragments_1);
1592 if (expected_fragments_1 == 0) {
Piotr Nowicki6a7f01c2020-02-12 13:53:36 +01001593 /* This error is expected when the message is too large and
1594 * cannot be fragmented */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001595 TEST_ASSERT(ret == MBEDTLS_ERR_SSL_BAD_INPUT_DATA);
Piotr Nowicki6a7f01c2020-02-12 13:53:36 +01001596 msg_len_1 = 0;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001597 } else {
1598 TEST_ASSERT(ret == 0);
Piotr Nowicki6a7f01c2020-02-12 13:53:36 +01001599 }
1600 }
1601
1602 /* ssl_2 sending */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001603 if (msg_len_2 > written_2) {
1604 ret = mbedtls_ssl_write_fragment(ssl_2, msg_buf_2,
1605 msg_len_2, &written_2,
1606 expected_fragments_2);
1607 if (expected_fragments_2 == 0) {
Piotr Nowicki6a7f01c2020-02-12 13:53:36 +01001608 /* This error is expected when the message is too large and
1609 * cannot be fragmented */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001610 TEST_ASSERT(ret == MBEDTLS_ERR_SSL_BAD_INPUT_DATA);
Piotr Nowicki6a7f01c2020-02-12 13:53:36 +01001611 msg_len_2 = 0;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001612 } else {
1613 TEST_ASSERT(ret == 0);
Piotr Nowicki6a7f01c2020-02-12 13:53:36 +01001614 }
1615 }
1616
1617 /* ssl_1 reading */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001618 if (read_1 < msg_len_2) {
1619 ret = mbedtls_ssl_read_fragment(ssl_1, in_buf_1,
1620 msg_len_2, &read_1,
1621 &fragments_2,
1622 expected_fragments_2);
1623 TEST_ASSERT(ret == 0);
Piotr Nowicki6a7f01c2020-02-12 13:53:36 +01001624 }
1625
1626 /* ssl_2 reading */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001627 if (read_2 < msg_len_1) {
1628 ret = mbedtls_ssl_read_fragment(ssl_2, in_buf_2,
1629 msg_len_1, &read_2,
1630 &fragments_1,
1631 expected_fragments_1);
1632 TEST_ASSERT(ret == 0);
Piotr Nowicki6a7f01c2020-02-12 13:53:36 +01001633 }
1634 }
1635
1636 ret = -1;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001637 TEST_ASSERT(0 == memcmp(msg_buf_1, in_buf_2, msg_len_1));
1638 TEST_ASSERT(0 == memcmp(msg_buf_2, in_buf_1, msg_len_2));
1639 TEST_ASSERT(fragments_1 == expected_fragments_1);
1640 TEST_ASSERT(fragments_2 == expected_fragments_2);
Piotr Nowicki6a7f01c2020-02-12 13:53:36 +01001641 }
1642
1643 ret = 0;
1644
1645exit:
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001646 free(msg_buf_1);
1647 free(in_buf_1);
1648 free(msg_buf_2);
1649 free(in_buf_2);
Piotr Nowicki6a7f01c2020-02-12 13:53:36 +01001650
1651 return ret;
1652}
1653
Piotr Nowicki95e9eb82020-02-14 11:33:34 +01001654/*
1655 * Perform data exchanging between \p ssl_1 and \p ssl_2. Both of endpoints
1656 * must be initialized and connected beforehand.
1657 *
1658 * \retval 0 on success, otherwise error code.
1659 */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001660int exchange_data(mbedtls_ssl_context *ssl_1,
1661 mbedtls_ssl_context *ssl_2)
Piotr Nowicki95e9eb82020-02-14 11:33:34 +01001662{
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001663 return mbedtls_exchange_data(ssl_1, 256, 1,
1664 ssl_2, 256, 1);
Piotr Nowicki95e9eb82020-02-14 11:33:34 +01001665}
1666
Andrzej Kurek9155e7f2022-10-18 09:36:19 -04001667#if defined(MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED) && \
Gilles Peskine33d03fe2023-02-01 18:37:49 +01001668 defined(MBEDTLS_CERTS_C) && \
Manuel Pégourié-Gonnardd12402f2020-05-20 10:34:25 +02001669 defined(MBEDTLS_ENTROPY_C) && \
1670 defined(MBEDTLS_CTR_DRBG_C)
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001671void perform_handshake(handshake_test_options *options)
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001672{
1673 /* forced_ciphersuite needs to last until the end of the handshake */
1674 int forced_ciphersuite[2];
1675 enum { BUFFSIZE = 17000 };
1676 mbedtls_endpoint client, server;
Gilles Peskineeccd8882020-03-10 12:19:08 +01001677#if defined(MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED)
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001678 const char *psk_identity = "foo";
1679#endif
1680#if defined(MBEDTLS_TIMING_C)
1681 mbedtls_timing_delay_context timer_client, timer_server;
1682#endif
1683#if defined(MBEDTLS_SSL_CONTEXT_SERIALIZATION)
1684 unsigned char *context_buf = NULL;
1685 size_t context_buf_len;
1686#endif
1687#if defined(MBEDTLS_SSL_RENEGOTIATION)
1688 int ret = -1;
1689#endif
Paul Elliottc8570442020-04-15 17:00:50 +01001690 int expected_handshake_result = 0;
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001691
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001692 USE_PSA_INIT();
1693 mbedtls_platform_zeroize(&client, sizeof(client));
1694 mbedtls_platform_zeroize(&server, sizeof(server));
Andrzej Kurek0d2982b2022-10-18 07:55:46 -04001695
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001696 mbedtls_test_message_queue server_queue, client_queue;
1697 mbedtls_test_message_socket_context server_context, client_context;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001698 mbedtls_message_socket_init(&server_context);
1699 mbedtls_message_socket_init(&client_context);
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001700
1701 /* Client side */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001702 if (options->dtls != 0) {
1703 TEST_ASSERT(mbedtls_endpoint_init(&client, MBEDTLS_SSL_IS_CLIENT,
1704 options->pk_alg, &client_context,
1705 &client_queue,
1706 &server_queue, NULL) == 0);
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001707#if defined(MBEDTLS_TIMING_C)
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001708 mbedtls_ssl_set_timer_cb(&client.ssl, &timer_client,
1709 mbedtls_timing_set_delay,
1710 mbedtls_timing_get_delay);
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001711#endif
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001712 } else {
1713 TEST_ASSERT(mbedtls_endpoint_init(&client, MBEDTLS_SSL_IS_CLIENT,
1714 options->pk_alg, NULL, NULL,
1715 NULL, NULL) == 0);
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001716 }
Paul Elliottc8570442020-04-15 17:00:50 +01001717
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001718 if (options->client_min_version != TEST_SSL_MINOR_VERSION_NONE) {
1719 mbedtls_ssl_conf_min_version(&client.conf, MBEDTLS_SSL_MAJOR_VERSION_3,
1720 options->client_min_version);
Paul Elliottc8570442020-04-15 17:00:50 +01001721 }
1722
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001723 if (options->client_max_version != TEST_SSL_MINOR_VERSION_NONE) {
1724 mbedtls_ssl_conf_max_version(&client.conf, MBEDTLS_SSL_MAJOR_VERSION_3,
1725 options->client_max_version);
Paul Elliottc8570442020-04-15 17:00:50 +01001726 }
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001727
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001728 if (strlen(options->cipher) > 0) {
1729 set_ciphersuite(&client.conf, options->cipher, forced_ciphersuite);
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001730 }
Piotr Nowickibde7ee82020-02-21 10:59:50 +01001731
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001732#if defined(MBEDTLS_DEBUG_C)
1733 if (options->cli_log_fun) {
1734 mbedtls_debug_set_threshold(4);
1735 mbedtls_ssl_conf_dbg(&client.conf, options->cli_log_fun,
1736 options->cli_log_obj);
Piotr Nowickibde7ee82020-02-21 10:59:50 +01001737 }
1738#endif
1739
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001740 /* Server side */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001741 if (options->dtls != 0) {
1742 TEST_ASSERT(mbedtls_endpoint_init(&server, MBEDTLS_SSL_IS_SERVER,
1743 options->pk_alg, &server_context,
1744 &server_queue,
1745 &client_queue, NULL) == 0);
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001746#if defined(MBEDTLS_TIMING_C)
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001747 mbedtls_ssl_set_timer_cb(&server.ssl, &timer_server,
1748 mbedtls_timing_set_delay,
1749 mbedtls_timing_get_delay);
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001750#endif
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001751 } else {
1752 TEST_ASSERT(mbedtls_endpoint_init(&server, MBEDTLS_SSL_IS_SERVER,
1753 options->pk_alg, NULL, NULL,
1754 NULL, NULL) == 0);
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001755 }
Piotr Nowickibde7ee82020-02-21 10:59:50 +01001756
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001757 mbedtls_ssl_conf_authmode(&server.conf, options->srv_auth_mode);
Piotr Nowickibde7ee82020-02-21 10:59:50 +01001758
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001759 if (options->server_min_version != TEST_SSL_MINOR_VERSION_NONE) {
1760 mbedtls_ssl_conf_min_version(&server.conf, MBEDTLS_SSL_MAJOR_VERSION_3,
1761 options->server_min_version);
Paul Elliottc8570442020-04-15 17:00:50 +01001762 }
1763
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001764 if (options->server_max_version != TEST_SSL_MINOR_VERSION_NONE) {
1765 mbedtls_ssl_conf_max_version(&server.conf, MBEDTLS_SSL_MAJOR_VERSION_3,
1766 options->server_max_version);
Paul Elliottc8570442020-04-15 17:00:50 +01001767 }
1768
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001769#if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001770 TEST_ASSERT(mbedtls_ssl_conf_max_frag_len(&(server.conf),
1771 (unsigned char) options->mfl) == 0);
1772 TEST_ASSERT(mbedtls_ssl_conf_max_frag_len(&(client.conf),
1773 (unsigned char) options->mfl) == 0);
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001774#else
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001775 TEST_ASSERT(MBEDTLS_SSL_MAX_FRAG_LEN_NONE == options->mfl);
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001776#endif /* MBEDTLS_SSL_MAX_FRAGMENT_LENGTH */
1777
Gilles Peskineeccd8882020-03-10 12:19:08 +01001778#if defined(MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED)
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001779 if (options->psk_str != NULL && options->psk_str->len > 0) {
1780 TEST_ASSERT(mbedtls_ssl_conf_psk(&client.conf, options->psk_str->x,
1781 options->psk_str->len,
1782 (const unsigned char *) psk_identity,
1783 strlen(psk_identity)) == 0);
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001784
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001785 TEST_ASSERT(mbedtls_ssl_conf_psk(&server.conf, options->psk_str->x,
1786 options->psk_str->len,
1787 (const unsigned char *) psk_identity,
1788 strlen(psk_identity)) == 0);
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001789
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001790 mbedtls_ssl_conf_psk_cb(&server.conf, psk_dummy_callback, NULL);
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001791 }
1792#endif
1793#if defined(MBEDTLS_SSL_RENEGOTIATION)
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001794 if (options->renegotiate) {
1795 mbedtls_ssl_conf_renegotiation(&(server.conf),
1796 MBEDTLS_SSL_RENEGOTIATION_ENABLED);
1797 mbedtls_ssl_conf_renegotiation(&(client.conf),
1798 MBEDTLS_SSL_RENEGOTIATION_ENABLED);
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001799
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001800 mbedtls_ssl_conf_legacy_renegotiation(&(server.conf),
1801 options->legacy_renegotiation);
1802 mbedtls_ssl_conf_legacy_renegotiation(&(client.conf),
1803 options->legacy_renegotiation);
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001804 }
1805#endif /* MBEDTLS_SSL_RENEGOTIATION */
1806
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001807#if defined(MBEDTLS_DEBUG_C)
1808 if (options->srv_log_fun) {
1809 mbedtls_debug_set_threshold(4);
1810 mbedtls_ssl_conf_dbg(&server.conf, options->srv_log_fun,
1811 options->srv_log_obj);
Piotr Nowickibde7ee82020-02-21 10:59:50 +01001812 }
1813#endif
1814
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001815 TEST_ASSERT(mbedtls_mock_socket_connect(&(client.socket),
1816 &(server.socket),
1817 BUFFSIZE) == 0);
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001818
Andrzej Kurek0afa2a12020-03-03 10:39:58 -05001819#if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001820 if (options->resize_buffers != 0) {
Andrzej Kurek0afa2a12020-03-03 10:39:58 -05001821 /* Ensure that the buffer sizes are appropriate before resizes */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001822 TEST_ASSERT(client.ssl.out_buf_len == MBEDTLS_SSL_OUT_BUFFER_LEN);
1823 TEST_ASSERT(client.ssl.in_buf_len == MBEDTLS_SSL_IN_BUFFER_LEN);
1824 TEST_ASSERT(server.ssl.out_buf_len == MBEDTLS_SSL_OUT_BUFFER_LEN);
1825 TEST_ASSERT(server.ssl.in_buf_len == MBEDTLS_SSL_IN_BUFFER_LEN);
Andrzej Kurek0afa2a12020-03-03 10:39:58 -05001826 }
1827#endif
1828
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001829 if (options->expected_negotiated_version == TEST_SSL_MINOR_VERSION_NONE) {
Paul Elliottc8570442020-04-15 17:00:50 +01001830 expected_handshake_result = MBEDTLS_ERR_SSL_BAD_HS_PROTOCOL_VERSION;
1831 }
1832
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001833 TEST_ASSERT(mbedtls_move_handshake_to_state(&(client.ssl),
1834 &(server.ssl),
1835 MBEDTLS_SSL_HANDSHAKE_OVER)
1836 == expected_handshake_result);
Paul Elliottc8570442020-04-15 17:00:50 +01001837
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001838 if (expected_handshake_result != 0) {
Paul Elliottc8570442020-04-15 17:00:50 +01001839 /* Connection will have failed by this point, skip to cleanup */
1840 goto exit;
1841 }
1842
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001843 TEST_ASSERT(client.ssl.state == MBEDTLS_SSL_HANDSHAKE_OVER);
1844 TEST_ASSERT(server.ssl.state == MBEDTLS_SSL_HANDSHAKE_OVER);
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001845
Paul Elliottc8570442020-04-15 17:00:50 +01001846 /* Check that we agree on the version... */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001847 TEST_ASSERT(client.ssl.minor_ver == server.ssl.minor_ver);
Paul Elliottc8570442020-04-15 17:00:50 +01001848
1849 /* And check that the version negotiated is the expected one. */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001850 TEST_EQUAL(client.ssl.minor_ver, options->expected_negotiated_version);
Paul Elliottc8570442020-04-15 17:00:50 +01001851
Andrzej Kurek0afa2a12020-03-03 10:39:58 -05001852#if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001853 if (options->resize_buffers != 0) {
1854 if (options->expected_negotiated_version != MBEDTLS_SSL_MINOR_VERSION_0 &&
1855 options->expected_negotiated_version != MBEDTLS_SSL_MINOR_VERSION_1) {
Andrzej Kurek0afa2a12020-03-03 10:39:58 -05001856 /* A server, when using DTLS, might delay a buffer resize to happen
1857 * after it receives a message, so we force it. */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001858 TEST_ASSERT(exchange_data(&(client.ssl), &(server.ssl)) == 0);
Andrzej Kurek0afa2a12020-03-03 10:39:58 -05001859
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001860 TEST_ASSERT(client.ssl.out_buf_len ==
1861 mbedtls_ssl_get_output_buflen(&client.ssl));
1862 TEST_ASSERT(client.ssl.in_buf_len ==
1863 mbedtls_ssl_get_input_buflen(&client.ssl));
1864 TEST_ASSERT(server.ssl.out_buf_len ==
1865 mbedtls_ssl_get_output_buflen(&server.ssl));
1866 TEST_ASSERT(server.ssl.in_buf_len ==
1867 mbedtls_ssl_get_input_buflen(&server.ssl));
Andrzej Kurek0afa2a12020-03-03 10:39:58 -05001868 }
1869 }
1870#endif
1871
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001872 if (options->cli_msg_len != 0 || options->srv_msg_len != 0) {
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001873 /* Start data exchanging test */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001874 TEST_ASSERT(mbedtls_exchange_data(&(client.ssl), options->cli_msg_len,
1875 options->expected_cli_fragments,
1876 &(server.ssl), options->srv_msg_len,
1877 options->expected_srv_fragments)
1878 == 0);
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001879 }
1880#if defined(MBEDTLS_SSL_CONTEXT_SERIALIZATION)
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001881 if (options->serialize == 1) {
1882 TEST_ASSERT(options->dtls == 1);
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001883
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001884 TEST_ASSERT(mbedtls_ssl_context_save(&(server.ssl), NULL,
1885 0, &context_buf_len)
1886 == MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL);
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001887
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001888 context_buf = mbedtls_calloc(1, context_buf_len);
1889 TEST_ASSERT(context_buf != NULL);
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001890
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001891 TEST_ASSERT(mbedtls_ssl_context_save(&(server.ssl), context_buf,
1892 context_buf_len,
1893 &context_buf_len) == 0);
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001894
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001895 mbedtls_ssl_free(&(server.ssl));
1896 mbedtls_ssl_init(&(server.ssl));
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001897
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001898 TEST_ASSERT(mbedtls_ssl_setup(&(server.ssl), &(server.conf)) == 0);
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001899
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001900 mbedtls_ssl_set_bio(&(server.ssl), &server_context,
1901 mbedtls_mock_tcp_send_msg,
1902 mbedtls_mock_tcp_recv_msg,
1903 NULL);
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001904
1905#if defined(MBEDTLS_TIMING_C)
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001906 mbedtls_ssl_set_timer_cb(&server.ssl, &timer_server,
1907 mbedtls_timing_set_delay,
1908 mbedtls_timing_get_delay);
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001909#endif
Andrzej Kurek0afa2a12020-03-03 10:39:58 -05001910#if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001911 if (options->resize_buffers != 0) {
Andrzej Kurek0afa2a12020-03-03 10:39:58 -05001912 /* Ensure that the buffer sizes are appropriate before resizes */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001913 TEST_ASSERT(server.ssl.out_buf_len == MBEDTLS_SSL_OUT_BUFFER_LEN);
1914 TEST_ASSERT(server.ssl.in_buf_len == MBEDTLS_SSL_IN_BUFFER_LEN);
Andrzej Kurek0afa2a12020-03-03 10:39:58 -05001915 }
1916#endif
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001917 TEST_ASSERT(mbedtls_ssl_context_load(&(server.ssl), context_buf,
1918 context_buf_len) == 0);
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001919
Andrzej Kurek0afa2a12020-03-03 10:39:58 -05001920#if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
1921 /* Validate buffer sizes after context deserialization */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001922 if (options->resize_buffers != 0) {
1923 TEST_ASSERT(server.ssl.out_buf_len ==
1924 mbedtls_ssl_get_output_buflen(&server.ssl));
1925 TEST_ASSERT(server.ssl.in_buf_len ==
1926 mbedtls_ssl_get_input_buflen(&server.ssl));
Andrzej Kurek0afa2a12020-03-03 10:39:58 -05001927 }
1928#endif
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001929 /* Retest writing/reading */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001930 if (options->cli_msg_len != 0 || options->srv_msg_len != 0) {
1931 TEST_ASSERT(mbedtls_exchange_data(&(client.ssl),
1932 options->cli_msg_len,
1933 options->expected_cli_fragments,
1934 &(server.ssl),
1935 options->srv_msg_len,
1936 options->expected_srv_fragments)
1937 == 0);
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001938 }
1939 }
1940#endif /* MBEDTLS_SSL_CONTEXT_SERIALIZATION */
Andrzej Kurek0afa2a12020-03-03 10:39:58 -05001941
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001942#if defined(MBEDTLS_SSL_RENEGOTIATION)
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001943 if (options->renegotiate) {
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001944 /* Start test with renegotiation */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001945 TEST_ASSERT(server.ssl.renego_status ==
1946 MBEDTLS_SSL_INITIAL_HANDSHAKE);
1947 TEST_ASSERT(client.ssl.renego_status ==
1948 MBEDTLS_SSL_INITIAL_HANDSHAKE);
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001949
1950 /* After calling this function for the server, it only sends a handshake
1951 * request. All renegotiation should happen during data exchanging */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001952 TEST_ASSERT(mbedtls_ssl_renegotiate(&(server.ssl)) == 0);
1953 TEST_ASSERT(server.ssl.renego_status ==
1954 MBEDTLS_SSL_RENEGOTIATION_PENDING);
1955 TEST_ASSERT(client.ssl.renego_status ==
1956 MBEDTLS_SSL_INITIAL_HANDSHAKE);
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001957
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001958 TEST_ASSERT(exchange_data(&(client.ssl), &(server.ssl)) == 0);
1959 TEST_ASSERT(server.ssl.renego_status ==
1960 MBEDTLS_SSL_RENEGOTIATION_DONE);
1961 TEST_ASSERT(client.ssl.renego_status ==
1962 MBEDTLS_SSL_RENEGOTIATION_DONE);
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001963
1964 /* After calling mbedtls_ssl_renegotiate for the client all renegotiation
1965 * should happen inside this function. However in this test, we cannot
Shaun Case0e7791f2021-12-20 21:14:10 -08001966 * perform simultaneous communication between client and server so this
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001967 * function will return waiting error on the socket. All rest of
1968 * renegotiation should happen during data exchanging */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001969 ret = mbedtls_ssl_renegotiate(&(client.ssl));
Andrzej Kurek0afa2a12020-03-03 10:39:58 -05001970#if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001971 if (options->resize_buffers != 0) {
Andrzej Kurek0afa2a12020-03-03 10:39:58 -05001972 /* Ensure that the buffer sizes are appropriate before resizes */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001973 TEST_ASSERT(client.ssl.out_buf_len == MBEDTLS_SSL_OUT_BUFFER_LEN);
1974 TEST_ASSERT(client.ssl.in_buf_len == MBEDTLS_SSL_IN_BUFFER_LEN);
Andrzej Kurek0afa2a12020-03-03 10:39:58 -05001975 }
1976#endif
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001977 TEST_ASSERT(ret == 0 ||
1978 ret == MBEDTLS_ERR_SSL_WANT_READ ||
1979 ret == MBEDTLS_ERR_SSL_WANT_WRITE);
1980 TEST_ASSERT(server.ssl.renego_status ==
1981 MBEDTLS_SSL_RENEGOTIATION_DONE);
1982 TEST_ASSERT(client.ssl.renego_status ==
1983 MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS);
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05001984
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001985 TEST_ASSERT(exchange_data(&(client.ssl), &(server.ssl)) == 0);
1986 TEST_ASSERT(server.ssl.renego_status ==
1987 MBEDTLS_SSL_RENEGOTIATION_DONE);
1988 TEST_ASSERT(client.ssl.renego_status ==
1989 MBEDTLS_SSL_RENEGOTIATION_DONE);
Andrzej Kurek0afa2a12020-03-03 10:39:58 -05001990#if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
1991 /* Validate buffer sizes after renegotiation */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01001992 if (options->resize_buffers != 0) {
1993 TEST_ASSERT(client.ssl.out_buf_len ==
1994 mbedtls_ssl_get_output_buflen(&client.ssl));
1995 TEST_ASSERT(client.ssl.in_buf_len ==
1996 mbedtls_ssl_get_input_buflen(&client.ssl));
1997 TEST_ASSERT(server.ssl.out_buf_len ==
1998 mbedtls_ssl_get_output_buflen(&server.ssl));
1999 TEST_ASSERT(server.ssl.in_buf_len ==
2000 mbedtls_ssl_get_input_buflen(&server.ssl));
Andrzej Kurek0afa2a12020-03-03 10:39:58 -05002001 }
2002#endif /* MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH */
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05002003 }
2004#endif /* MBEDTLS_SSL_RENEGOTIATION */
2005
2006exit:
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002007 mbedtls_endpoint_free(&client, options->dtls != 0 ? &client_context : NULL);
2008 mbedtls_endpoint_free(&server, options->dtls != 0 ? &server_context : NULL);
2009#if defined(MBEDTLS_DEBUG_C)
2010 if (options->cli_log_fun || options->srv_log_fun) {
2011 mbedtls_debug_set_threshold(0);
Piotr Nowickibde7ee82020-02-21 10:59:50 +01002012 }
2013#endif
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05002014#if defined(MBEDTLS_SSL_CONTEXT_SERIALIZATION)
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002015 if (context_buf != NULL) {
2016 mbedtls_free(context_buf);
2017 }
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05002018#endif
2019}
Gilles Peskine33d03fe2023-02-01 18:37:49 +01002020#endif \
2021 /* MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED && MBEDTLS_CERTS_C && MBEDTLS_ENTROPY_C && MBEDTLS_CTR_DRBG_C */
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05002022
Manuel Pégourié-Gonnard4956fd72014-09-24 11:13:44 +02002023/* END_HEADER */
2024
2025/* BEGIN_DEPENDENCIES
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002026 * depends_on:MBEDTLS_SSL_TLS_C
Manuel Pégourié-Gonnard4956fd72014-09-24 11:13:44 +02002027 * END_DEPENDENCIES
2028 */
2029
Janos Follath6264e662019-11-26 11:11:15 +00002030/* BEGIN_CASE */
2031void test_callback_buffer_sanity()
2032{
2033 enum { MSGLEN = 10 };
2034 mbedtls_test_buffer buf;
2035 unsigned char input[MSGLEN];
2036 unsigned char output[MSGLEN];
2037
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002038 memset(input, 0, sizeof(input));
Janos Follath6264e662019-11-26 11:11:15 +00002039
2040 /* Make sure calling put and get on NULL buffer results in error. */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002041 TEST_ASSERT(mbedtls_test_buffer_put(NULL, input, sizeof(input))
2042 == -1);
2043 TEST_ASSERT(mbedtls_test_buffer_get(NULL, output, sizeof(output))
2044 == -1);
2045 TEST_ASSERT(mbedtls_test_buffer_put(NULL, NULL, sizeof(input)) == -1);
Andrzej Kurekf7774142020-01-22 06:34:59 -05002046
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002047 TEST_ASSERT(mbedtls_test_buffer_put(NULL, NULL, 0) == -1);
2048 TEST_ASSERT(mbedtls_test_buffer_get(NULL, NULL, 0) == -1);
Janos Follath6264e662019-11-26 11:11:15 +00002049
2050 /* Make sure calling put and get on a buffer that hasn't been set up results
Shaun Case0e7791f2021-12-20 21:14:10 -08002051 * in error. */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002052 mbedtls_test_buffer_init(&buf);
Janos Follath6264e662019-11-26 11:11:15 +00002053
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002054 TEST_ASSERT(mbedtls_test_buffer_put(&buf, input, sizeof(input)) == -1);
2055 TEST_ASSERT(mbedtls_test_buffer_get(&buf, output, sizeof(output))
2056 == -1);
2057 TEST_ASSERT(mbedtls_test_buffer_put(&buf, NULL, sizeof(input)) == -1);
Andrzej Kurekf7774142020-01-22 06:34:59 -05002058
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002059 TEST_ASSERT(mbedtls_test_buffer_put(&buf, NULL, 0) == -1);
2060 TEST_ASSERT(mbedtls_test_buffer_get(&buf, NULL, 0) == -1);
Janos Follath6264e662019-11-26 11:11:15 +00002061
Andrzej Kurekf7774142020-01-22 06:34:59 -05002062 /* Make sure calling put and get on NULL input only results in
2063 * error if the length is not zero, and that a NULL output is valid for data
2064 * dropping.
2065 */
Janos Follath6264e662019-11-26 11:11:15 +00002066
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002067 TEST_ASSERT(mbedtls_test_buffer_setup(&buf, sizeof(input)) == 0);
Janos Follath6264e662019-11-26 11:11:15 +00002068
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002069 TEST_ASSERT(mbedtls_test_buffer_put(&buf, NULL, sizeof(input)) == -1);
2070 TEST_ASSERT(mbedtls_test_buffer_get(&buf, NULL, sizeof(output))
2071 == 0);
2072 TEST_ASSERT(mbedtls_test_buffer_put(&buf, NULL, 0) == 0);
2073 TEST_ASSERT(mbedtls_test_buffer_get(&buf, NULL, 0) == 0);
Janos Follath6264e662019-11-26 11:11:15 +00002074
Piotr Nowickifb437d72020-01-13 16:59:12 +01002075 /* Make sure calling put several times in the row is safe */
2076
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002077 TEST_ASSERT(mbedtls_test_buffer_put(&buf, input, sizeof(input))
2078 == sizeof(input));
2079 TEST_ASSERT(mbedtls_test_buffer_get(&buf, output, 2) == 2);
2080 TEST_ASSERT(mbedtls_test_buffer_put(&buf, input, 1) == 1);
2081 TEST_ASSERT(mbedtls_test_buffer_put(&buf, input, 2) == 1);
2082 TEST_ASSERT(mbedtls_test_buffer_put(&buf, input, 2) == 0);
Piotr Nowickifb437d72020-01-13 16:59:12 +01002083
2084
Janos Follath6264e662019-11-26 11:11:15 +00002085exit:
2086
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002087 mbedtls_test_buffer_free(&buf);
Janos Follath6264e662019-11-26 11:11:15 +00002088}
2089/* END_CASE */
2090
2091/*
2092 * Test if the implementation of `mbedtls_test_buffer` related functions is
2093 * correct and works as expected.
2094 *
2095 * That is
2096 * - If we try to put in \p put1 bytes then we can put in \p put1_ret bytes.
2097 * - Afterwards if we try to get \p get1 bytes then we can get \get1_ret bytes.
2098 * - Next, if we try to put in \p put1 bytes then we can put in \p put1_ret
2099 * bytes.
2100 * - Afterwards if we try to get \p get1 bytes then we can get \get1_ret bytes.
2101 * - All of the bytes we got match the bytes we put in in a FIFO manner.
2102 */
2103
2104/* BEGIN_CASE */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002105void test_callback_buffer(int size, int put1, int put1_ret,
2106 int get1, int get1_ret, int put2, int put2_ret,
2107 int get2, int get2_ret)
Janos Follath6264e662019-11-26 11:11:15 +00002108{
2109 enum { ROUNDS = 2 };
2110 size_t put[ROUNDS];
2111 int put_ret[ROUNDS];
2112 size_t get[ROUNDS];
2113 int get_ret[ROUNDS];
2114 mbedtls_test_buffer buf;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002115 unsigned char *input = NULL;
Janos Follath6264e662019-11-26 11:11:15 +00002116 size_t input_len;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002117 unsigned char *output = NULL;
Janos Follath6264e662019-11-26 11:11:15 +00002118 size_t output_len;
Janos Follath031827f2019-11-27 11:12:14 +00002119 size_t i, j, written, read;
Janos Follath6264e662019-11-26 11:11:15 +00002120
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002121 mbedtls_test_buffer_init(&buf);
2122 TEST_ASSERT(mbedtls_test_buffer_setup(&buf, size) == 0);
Janos Follath6264e662019-11-26 11:11:15 +00002123
2124 /* Check the sanity of input parameters and initialise local variables. That
2125 * is, ensure that the amount of data is not negative and that we are not
2126 * expecting more to put or get than we actually asked for. */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002127 TEST_ASSERT(put1 >= 0);
Janos Follath6264e662019-11-26 11:11:15 +00002128 put[0] = put1;
2129 put_ret[0] = put1_ret;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002130 TEST_ASSERT(put1_ret <= put1);
2131 TEST_ASSERT(put2 >= 0);
Janos Follath6264e662019-11-26 11:11:15 +00002132 put[1] = put2;
2133 put_ret[1] = put2_ret;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002134 TEST_ASSERT(put2_ret <= put2);
Janos Follath6264e662019-11-26 11:11:15 +00002135
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002136 TEST_ASSERT(get1 >= 0);
Janos Follath6264e662019-11-26 11:11:15 +00002137 get[0] = get1;
2138 get_ret[0] = get1_ret;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002139 TEST_ASSERT(get1_ret <= get1);
2140 TEST_ASSERT(get2 >= 0);
Janos Follath6264e662019-11-26 11:11:15 +00002141 get[1] = get2;
2142 get_ret[1] = get2_ret;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002143 TEST_ASSERT(get2_ret <= get2);
Janos Follath6264e662019-11-26 11:11:15 +00002144
2145 input_len = 0;
2146 /* Calculate actual input and output lengths */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002147 for (j = 0; j < ROUNDS; j++) {
2148 if (put_ret[j] > 0) {
Janos Follath6264e662019-11-26 11:11:15 +00002149 input_len += put_ret[j];
2150 }
2151 }
2152 /* In order to always have a valid pointer we always allocate at least 1
2153 * byte. */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002154 if (input_len == 0) {
Janos Follath6264e662019-11-26 11:11:15 +00002155 input_len = 1;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002156 }
2157 ASSERT_ALLOC(input, input_len);
Janos Follath6264e662019-11-26 11:11:15 +00002158
2159 output_len = 0;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002160 for (j = 0; j < ROUNDS; j++) {
2161 if (get_ret[j] > 0) {
Janos Follath6264e662019-11-26 11:11:15 +00002162 output_len += get_ret[j];
2163 }
2164 }
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002165 TEST_ASSERT(output_len <= input_len);
Janos Follath6264e662019-11-26 11:11:15 +00002166 /* In order to always have a valid pointer we always allocate at least 1
2167 * byte. */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002168 if (output_len == 0) {
Janos Follath6264e662019-11-26 11:11:15 +00002169 output_len = 1;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002170 }
2171 ASSERT_ALLOC(output, output_len);
Janos Follath6264e662019-11-26 11:11:15 +00002172
2173 /* Fill up the buffer with structured data so that unwanted changes
2174 * can be detected */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002175 for (i = 0; i < input_len; i++) {
Janos Follath6264e662019-11-26 11:11:15 +00002176 input[i] = i & 0xFF;
2177 }
2178
2179 written = read = 0;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002180 for (j = 0; j < ROUNDS; j++) {
2181 TEST_ASSERT(put_ret[j] == mbedtls_test_buffer_put(&buf,
2182 input + written, put[j]));
Janos Follath6264e662019-11-26 11:11:15 +00002183 written += put_ret[j];
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002184 TEST_ASSERT(get_ret[j] == mbedtls_test_buffer_get(&buf,
2185 output + read, get[j]));
Janos Follath6264e662019-11-26 11:11:15 +00002186 read += get_ret[j];
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002187 TEST_ASSERT(read <= written);
2188 if (get_ret[j] > 0) {
2189 TEST_ASSERT(memcmp(output + read - get_ret[j],
2190 input + read - get_ret[j], get_ret[j])
2191 == 0);
Janos Follath6264e662019-11-26 11:11:15 +00002192 }
2193 }
2194
2195exit:
2196
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002197 mbedtls_free(input);
2198 mbedtls_free(output);
2199 mbedtls_test_buffer_free(&buf);
Janos Follath6264e662019-11-26 11:11:15 +00002200}
2201/* END_CASE */
2202
Janos Follath031827f2019-11-27 11:12:14 +00002203/*
Janos Follathc673c2c2019-12-02 15:47:26 +00002204 * Test if the implementation of `mbedtls_mock_socket` related I/O functions is
2205 * correct and works as expected on unconnected sockets.
2206 */
2207
2208/* BEGIN_CASE */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002209void ssl_mock_sanity()
Janos Follathc673c2c2019-12-02 15:47:26 +00002210{
2211 enum { MSGLEN = 105 };
Paul Elliott95457862021-11-24 16:54:26 +00002212 unsigned char message[MSGLEN] = { 0 };
2213 unsigned char received[MSGLEN] = { 0 };
Janos Follathc673c2c2019-12-02 15:47:26 +00002214 mbedtls_mock_socket socket;
2215
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002216 mbedtls_mock_socket_init(&socket);
2217 TEST_ASSERT(mbedtls_mock_tcp_send_b(&socket, message, MSGLEN) < 0);
2218 mbedtls_mock_socket_close(&socket);
2219 mbedtls_mock_socket_init(&socket);
2220 TEST_ASSERT(mbedtls_mock_tcp_recv_b(&socket, received, MSGLEN) < 0);
2221 mbedtls_mock_socket_close(&socket);
Janos Follathc673c2c2019-12-02 15:47:26 +00002222
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002223 mbedtls_mock_socket_init(&socket);
2224 TEST_ASSERT(mbedtls_mock_tcp_send_nb(&socket, message, MSGLEN) < 0);
2225 mbedtls_mock_socket_close(&socket);
2226 mbedtls_mock_socket_init(&socket);
2227 TEST_ASSERT(mbedtls_mock_tcp_recv_nb(&socket, received, MSGLEN) < 0);
2228 mbedtls_mock_socket_close(&socket);
Janos Follathc673c2c2019-12-02 15:47:26 +00002229
2230exit:
2231
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002232 mbedtls_mock_socket_close(&socket);
Janos Follathc673c2c2019-12-02 15:47:26 +00002233}
2234/* END_CASE */
2235
2236/*
2237 * Test if the implementation of `mbedtls_mock_socket` related functions can
2238 * send a single message from the client to the server.
Janos Follath031827f2019-11-27 11:12:14 +00002239 */
2240
2241/* BEGIN_CASE */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002242void ssl_mock_tcp(int blocking)
Janos Follath031827f2019-11-27 11:12:14 +00002243{
Janos Follathc673c2c2019-12-02 15:47:26 +00002244 enum { MSGLEN = 105 };
Piotr Nowicki890b5ca2020-01-15 16:19:07 +01002245 enum { BUFLEN = MSGLEN / 5 };
Janos Follathc673c2c2019-12-02 15:47:26 +00002246 unsigned char message[MSGLEN];
2247 unsigned char received[MSGLEN];
2248 mbedtls_mock_socket client;
2249 mbedtls_mock_socket server;
2250 size_t written, read;
2251 int send_ret, recv_ret;
2252 mbedtls_ssl_send_t *send;
2253 mbedtls_ssl_recv_t *recv;
Janos Follathc673c2c2019-12-02 15:47:26 +00002254 unsigned i;
2255
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002256 if (blocking == 0) {
Janos Follathc673c2c2019-12-02 15:47:26 +00002257 send = mbedtls_mock_tcp_send_nb;
2258 recv = mbedtls_mock_tcp_recv_nb;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002259 } else {
Janos Follathc673c2c2019-12-02 15:47:26 +00002260 send = mbedtls_mock_tcp_send_b;
2261 recv = mbedtls_mock_tcp_recv_b;
2262 }
2263
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002264 mbedtls_mock_socket_init(&client);
2265 mbedtls_mock_socket_init(&server);
Janos Follathc673c2c2019-12-02 15:47:26 +00002266
2267 /* Fill up the buffer with structured data so that unwanted changes
2268 * can be detected */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002269 for (i = 0; i < MSGLEN; i++) {
Janos Follathc673c2c2019-12-02 15:47:26 +00002270 message[i] = i & 0xFF;
2271 }
2272
2273 /* Make sure that sending a message takes a few iterations. */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002274 TEST_ASSERT(0 == mbedtls_mock_socket_connect(&client, &server, BUFLEN));
Janos Follathc673c2c2019-12-02 15:47:26 +00002275
2276 /* Send the message to the server */
2277 send_ret = recv_ret = 1;
2278 written = read = 0;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002279 while (send_ret != 0 || recv_ret != 0) {
2280 send_ret = send(&client, message + written, MSGLEN - written);
Janos Follathc673c2c2019-12-02 15:47:26 +00002281
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002282 TEST_ASSERT(send_ret >= 0);
2283 TEST_ASSERT(send_ret <= BUFLEN);
Piotr Nowicki890b5ca2020-01-15 16:19:07 +01002284 written += send_ret;
2285
2286 /* If the buffer is full we can test blocking and non-blocking send */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002287 if (send_ret == BUFLEN) {
2288 int blocking_ret = send(&client, message, 1);
2289 if (blocking) {
2290 TEST_ASSERT(blocking_ret == 0);
2291 } else {
2292 TEST_ASSERT(blocking_ret == MBEDTLS_ERR_SSL_WANT_WRITE);
Piotr Nowicki890b5ca2020-01-15 16:19:07 +01002293 }
Janos Follathc673c2c2019-12-02 15:47:26 +00002294 }
Janos Follathc673c2c2019-12-02 15:47:26 +00002295
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002296 recv_ret = recv(&server, received + read, MSGLEN - read);
Piotr Nowicki890b5ca2020-01-15 16:19:07 +01002297
2298 /* The result depends on whether any data was sent */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002299 if (send_ret > 0) {
2300 TEST_ASSERT(recv_ret > 0);
2301 TEST_ASSERT(recv_ret <= BUFLEN);
Piotr Nowicki890b5ca2020-01-15 16:19:07 +01002302 read += recv_ret;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002303 } else if (blocking) {
2304 TEST_ASSERT(recv_ret == 0);
2305 } else {
2306 TEST_ASSERT(recv_ret == MBEDTLS_ERR_SSL_WANT_READ);
Piotr Nowicki890b5ca2020-01-15 16:19:07 +01002307 recv_ret = 0;
Janos Follathc673c2c2019-12-02 15:47:26 +00002308 }
Piotr Nowicki890b5ca2020-01-15 16:19:07 +01002309
2310 /* If the buffer is empty we can test blocking and non-blocking read */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002311 if (recv_ret == BUFLEN) {
2312 int blocking_ret = recv(&server, received, 1);
2313 if (blocking) {
2314 TEST_ASSERT(blocking_ret == 0);
2315 } else {
2316 TEST_ASSERT(blocking_ret == MBEDTLS_ERR_SSL_WANT_READ);
Piotr Nowicki890b5ca2020-01-15 16:19:07 +01002317 }
2318 }
Janos Follathc673c2c2019-12-02 15:47:26 +00002319 }
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002320 TEST_ASSERT(memcmp(message, received, MSGLEN) == 0);
Janos Follathc673c2c2019-12-02 15:47:26 +00002321
2322exit:
2323
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002324 mbedtls_mock_socket_close(&client);
2325 mbedtls_mock_socket_close(&server);
Janos Follathc673c2c2019-12-02 15:47:26 +00002326}
2327/* END_CASE */
2328
2329/*
2330 * Test if the implementation of `mbedtls_mock_socket` related functions can
2331 * send messages in both direction at the same time (with the I/O calls
2332 * interleaving).
2333 */
2334
2335/* BEGIN_CASE */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002336void ssl_mock_tcp_interleaving(int blocking)
Janos Follathc673c2c2019-12-02 15:47:26 +00002337{
Janos Follath031827f2019-11-27 11:12:14 +00002338 enum { ROUNDS = 2 };
2339 enum { MSGLEN = 105 };
Piotr Nowicki890b5ca2020-01-15 16:19:07 +01002340 enum { BUFLEN = MSGLEN / 5 };
Janos Follath031827f2019-11-27 11:12:14 +00002341 unsigned char message[ROUNDS][MSGLEN];
2342 unsigned char received[ROUNDS][MSGLEN];
2343 mbedtls_mock_socket client;
2344 mbedtls_mock_socket server;
2345 size_t written[ROUNDS];
2346 size_t read[ROUNDS];
2347 int send_ret[ROUNDS];
2348 int recv_ret[ROUNDS];
2349 unsigned i, j, progress;
Janos Follath3766ba52019-11-27 13:31:42 +00002350 mbedtls_ssl_send_t *send;
2351 mbedtls_ssl_recv_t *recv;
Janos Follath3766ba52019-11-27 13:31:42 +00002352
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002353 if (blocking == 0) {
Janos Follath3766ba52019-11-27 13:31:42 +00002354 send = mbedtls_mock_tcp_send_nb;
2355 recv = mbedtls_mock_tcp_recv_nb;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002356 } else {
Janos Follath3766ba52019-11-27 13:31:42 +00002357 send = mbedtls_mock_tcp_send_b;
2358 recv = mbedtls_mock_tcp_recv_b;
2359 }
Janos Follath031827f2019-11-27 11:12:14 +00002360
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002361 mbedtls_mock_socket_init(&client);
2362 mbedtls_mock_socket_init(&server);
Janos Follath031827f2019-11-27 11:12:14 +00002363
2364 /* Fill up the buffers with structured data so that unwanted changes
2365 * can be detected */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002366 for (i = 0; i < ROUNDS; i++) {
2367 for (j = 0; j < MSGLEN; j++) {
2368 message[i][j] = (i * MSGLEN + j) & 0xFF;
Janos Follath031827f2019-11-27 11:12:14 +00002369 }
2370 }
2371
Janos Follath031827f2019-11-27 11:12:14 +00002372 /* Make sure that sending a message takes a few iterations. */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002373 TEST_ASSERT(0 == mbedtls_mock_socket_connect(&client, &server, BUFLEN));
Janos Follath031827f2019-11-27 11:12:14 +00002374
Janos Follath031827f2019-11-27 11:12:14 +00002375 /* Send the message from both sides, interleaving. */
2376 progress = 1;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002377 for (i = 0; i < ROUNDS; i++) {
Janos Follath031827f2019-11-27 11:12:14 +00002378 written[i] = 0;
2379 read[i] = 0;
2380 }
2381 /* This loop does not stop as long as there was a successful write or read
2382 * of at least one byte on either side. */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002383 while (progress != 0) {
Piotr Nowicki890b5ca2020-01-15 16:19:07 +01002384 mbedtls_mock_socket *socket;
Janos Follath031827f2019-11-27 11:12:14 +00002385
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002386 for (i = 0; i < ROUNDS; i++) {
Piotr Nowicki890b5ca2020-01-15 16:19:07 +01002387 /* First sending is from the client */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002388 socket = (i % 2 == 0) ? (&client) : (&server);
Janos Follath031827f2019-11-27 11:12:14 +00002389
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002390 send_ret[i] = send(socket, message[i] + written[i],
2391 MSGLEN - written[i]);
2392 TEST_ASSERT(send_ret[i] >= 0);
2393 TEST_ASSERT(send_ret[i] <= BUFLEN);
Piotr Nowicki890b5ca2020-01-15 16:19:07 +01002394 written[i] += send_ret[i];
Janos Follath031827f2019-11-27 11:12:14 +00002395
Piotr Nowicki890b5ca2020-01-15 16:19:07 +01002396 /* If the buffer is full we can test blocking and non-blocking
2397 * send */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002398 if (send_ret[i] == BUFLEN) {
2399 int blocking_ret = send(socket, message[i], 1);
2400 if (blocking) {
2401 TEST_ASSERT(blocking_ret == 0);
2402 } else {
2403 TEST_ASSERT(blocking_ret == MBEDTLS_ERR_SSL_WANT_WRITE);
Piotr Nowicki890b5ca2020-01-15 16:19:07 +01002404 }
2405 }
Janos Follath3766ba52019-11-27 13:31:42 +00002406 }
Piotr Nowicki890b5ca2020-01-15 16:19:07 +01002407
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002408 for (i = 0; i < ROUNDS; i++) {
Piotr Nowicki890b5ca2020-01-15 16:19:07 +01002409 /* First receiving is from the server */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002410 socket = (i % 2 == 0) ? (&server) : (&client);
Piotr Nowicki890b5ca2020-01-15 16:19:07 +01002411
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002412 recv_ret[i] = recv(socket, received[i] + read[i],
2413 MSGLEN - read[i]);
Piotr Nowicki890b5ca2020-01-15 16:19:07 +01002414
2415 /* The result depends on whether any data was sent */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002416 if (send_ret[i] > 0) {
2417 TEST_ASSERT(recv_ret[i] > 0);
2418 TEST_ASSERT(recv_ret[i] <= BUFLEN);
Piotr Nowicki890b5ca2020-01-15 16:19:07 +01002419 read[i] += recv_ret[i];
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002420 } else if (blocking) {
2421 TEST_ASSERT(recv_ret[i] == 0);
2422 } else {
2423 TEST_ASSERT(recv_ret[i] == MBEDTLS_ERR_SSL_WANT_READ);
Piotr Nowicki890b5ca2020-01-15 16:19:07 +01002424 recv_ret[i] = 0;
2425 }
2426
2427 /* If the buffer is empty we can test blocking and non-blocking
2428 * read */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002429 if (recv_ret[i] == BUFLEN) {
2430 int blocking_ret = recv(socket, received[i], 1);
2431 if (blocking) {
2432 TEST_ASSERT(blocking_ret == 0);
2433 } else {
2434 TEST_ASSERT(blocking_ret == MBEDTLS_ERR_SSL_WANT_READ);
Piotr Nowicki890b5ca2020-01-15 16:19:07 +01002435 }
2436 }
Janos Follath3766ba52019-11-27 13:31:42 +00002437 }
Janos Follath031827f2019-11-27 11:12:14 +00002438
2439 progress = 0;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002440 for (i = 0; i < ROUNDS; i++) {
Piotr Nowicki890b5ca2020-01-15 16:19:07 +01002441 progress += send_ret[i] + recv_ret[i];
Janos Follath031827f2019-11-27 11:12:14 +00002442 }
2443 }
2444
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002445 for (i = 0; i < ROUNDS; i++) {
2446 TEST_ASSERT(memcmp(message[i], received[i], MSGLEN) == 0);
2447 }
Janos Follath031827f2019-11-27 11:12:14 +00002448
2449exit:
2450
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002451 mbedtls_mock_socket_close(&client);
2452 mbedtls_mock_socket_close(&server);
Janos Follath031827f2019-11-27 11:12:14 +00002453}
2454/* END_CASE */
2455
Andrzej Kurek13719cd2020-01-22 06:36:39 -05002456/* BEGIN_CASE */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002457void ssl_message_queue_sanity()
Andrzej Kurek13719cd2020-01-22 06:36:39 -05002458{
2459 mbedtls_test_message_queue queue;
2460
2461 /* Trying to push/pull to an empty queue */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002462 TEST_ASSERT(mbedtls_test_message_queue_push_info(NULL, 1)
2463 == MBEDTLS_TEST_ERROR_ARG_NULL);
2464 TEST_ASSERT(mbedtls_test_message_queue_pop_info(NULL, 1)
2465 == MBEDTLS_TEST_ERROR_ARG_NULL);
Andrzej Kurek13719cd2020-01-22 06:36:39 -05002466
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002467 TEST_ASSERT(mbedtls_test_message_queue_setup(&queue, 3) == 0);
2468 TEST_ASSERT(queue.capacity == 3);
2469 TEST_ASSERT(queue.num == 0);
Andrzej Kurek13719cd2020-01-22 06:36:39 -05002470
2471exit:
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002472 mbedtls_test_message_queue_free(&queue);
Andrzej Kurek13719cd2020-01-22 06:36:39 -05002473}
2474/* END_CASE */
2475
2476/* BEGIN_CASE */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002477void ssl_message_queue_basic()
Andrzej Kurek13719cd2020-01-22 06:36:39 -05002478{
2479 mbedtls_test_message_queue queue;
2480
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002481 TEST_ASSERT(mbedtls_test_message_queue_setup(&queue, 3) == 0);
Andrzej Kurek13719cd2020-01-22 06:36:39 -05002482
2483 /* Sanity test - 3 pushes and 3 pops with sufficient space */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002484 TEST_ASSERT(mbedtls_test_message_queue_push_info(&queue, 1) == 1);
2485 TEST_ASSERT(queue.capacity == 3);
2486 TEST_ASSERT(queue.num == 1);
2487 TEST_ASSERT(mbedtls_test_message_queue_push_info(&queue, 1) == 1);
2488 TEST_ASSERT(queue.capacity == 3);
2489 TEST_ASSERT(queue.num == 2);
2490 TEST_ASSERT(mbedtls_test_message_queue_push_info(&queue, 2) == 2);
2491 TEST_ASSERT(queue.capacity == 3);
2492 TEST_ASSERT(queue.num == 3);
Andrzej Kurek13719cd2020-01-22 06:36:39 -05002493
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002494 TEST_ASSERT(mbedtls_test_message_queue_pop_info(&queue, 1) == 1);
2495 TEST_ASSERT(mbedtls_test_message_queue_pop_info(&queue, 1) == 1);
2496 TEST_ASSERT(mbedtls_test_message_queue_pop_info(&queue, 2) == 2);
Andrzej Kurek13719cd2020-01-22 06:36:39 -05002497
2498exit:
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002499 mbedtls_test_message_queue_free(&queue);
Andrzej Kurek13719cd2020-01-22 06:36:39 -05002500}
2501/* END_CASE */
2502
2503/* BEGIN_CASE */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002504void ssl_message_queue_overflow_underflow()
Andrzej Kurek13719cd2020-01-22 06:36:39 -05002505{
2506 mbedtls_test_message_queue queue;
2507
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002508 TEST_ASSERT(mbedtls_test_message_queue_setup(&queue, 3) == 0);
Andrzej Kurek13719cd2020-01-22 06:36:39 -05002509
2510 /* 4 pushes (last one with an error), 4 pops (last one with an error) */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002511 TEST_ASSERT(mbedtls_test_message_queue_push_info(&queue, 1) == 1);
2512 TEST_ASSERT(mbedtls_test_message_queue_push_info(&queue, 1) == 1);
2513 TEST_ASSERT(mbedtls_test_message_queue_push_info(&queue, 2) == 2);
2514 TEST_ASSERT(mbedtls_test_message_queue_push_info(&queue, 3)
2515 == MBEDTLS_ERR_SSL_WANT_WRITE);
Andrzej Kurek13719cd2020-01-22 06:36:39 -05002516
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002517 TEST_ASSERT(mbedtls_test_message_queue_pop_info(&queue, 1) == 1);
2518 TEST_ASSERT(mbedtls_test_message_queue_pop_info(&queue, 1) == 1);
2519 TEST_ASSERT(mbedtls_test_message_queue_pop_info(&queue, 2) == 2);
Andrzej Kurek13719cd2020-01-22 06:36:39 -05002520
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002521 TEST_ASSERT(mbedtls_test_message_queue_pop_info(&queue, 1)
2522 == MBEDTLS_ERR_SSL_WANT_READ);
Andrzej Kurek13719cd2020-01-22 06:36:39 -05002523
2524exit:
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002525 mbedtls_test_message_queue_free(&queue);
Andrzej Kurek13719cd2020-01-22 06:36:39 -05002526}
2527/* END_CASE */
2528
2529/* BEGIN_CASE */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002530void ssl_message_queue_interleaved()
Andrzej Kurek13719cd2020-01-22 06:36:39 -05002531{
2532 mbedtls_test_message_queue queue;
2533
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002534 TEST_ASSERT(mbedtls_test_message_queue_setup(&queue, 3) == 0);
Andrzej Kurek13719cd2020-01-22 06:36:39 -05002535
2536 /* Interleaved test - [2 pushes, 1 pop] twice, and then two pops
2537 * (to wrap around the buffer) */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002538 TEST_ASSERT(mbedtls_test_message_queue_push_info(&queue, 1) == 1);
2539 TEST_ASSERT(mbedtls_test_message_queue_push_info(&queue, 1) == 1);
Andrzej Kurek13719cd2020-01-22 06:36:39 -05002540
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002541 TEST_ASSERT(mbedtls_test_message_queue_pop_info(&queue, 1) == 1);
Andrzej Kurek13719cd2020-01-22 06:36:39 -05002542
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002543 TEST_ASSERT(mbedtls_test_message_queue_push_info(&queue, 2) == 2);
2544 TEST_ASSERT(mbedtls_test_message_queue_push_info(&queue, 3) == 3);
Andrzej Kurek13719cd2020-01-22 06:36:39 -05002545
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002546 TEST_ASSERT(mbedtls_test_message_queue_pop_info(&queue, 1) == 1);
2547 TEST_ASSERT(mbedtls_test_message_queue_pop_info(&queue, 2) == 2);
Andrzej Kurek13719cd2020-01-22 06:36:39 -05002548
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002549 TEST_ASSERT(mbedtls_test_message_queue_push_info(&queue, 5) == 5);
2550 TEST_ASSERT(mbedtls_test_message_queue_push_info(&queue, 8) == 8);
Andrzej Kurek13719cd2020-01-22 06:36:39 -05002551
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002552 TEST_ASSERT(mbedtls_test_message_queue_pop_info(&queue, 3) == 3);
Andrzej Kurek13719cd2020-01-22 06:36:39 -05002553
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002554 TEST_ASSERT(mbedtls_test_message_queue_pop_info(&queue, 5) == 5);
Andrzej Kurek13719cd2020-01-22 06:36:39 -05002555
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002556 TEST_ASSERT(mbedtls_test_message_queue_pop_info(&queue, 8) == 8);
Andrzej Kurek13719cd2020-01-22 06:36:39 -05002557
2558exit:
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002559 mbedtls_test_message_queue_free(&queue);
Andrzej Kurek13719cd2020-01-22 06:36:39 -05002560}
2561/* END_CASE */
2562
2563/* BEGIN_CASE */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002564void ssl_message_queue_insufficient_buffer()
Andrzej Kurek13719cd2020-01-22 06:36:39 -05002565{
2566 mbedtls_test_message_queue queue;
2567 size_t message_len = 10;
2568 size_t buffer_len = 5;
2569
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002570 TEST_ASSERT(mbedtls_test_message_queue_setup(&queue, 1) == 0);
Andrzej Kurek13719cd2020-01-22 06:36:39 -05002571
2572 /* Popping without a sufficient buffer */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002573 TEST_ASSERT(mbedtls_test_message_queue_push_info(&queue, message_len)
2574 == (int) message_len);
2575 TEST_ASSERT(mbedtls_test_message_queue_pop_info(&queue, buffer_len)
2576 == (int) buffer_len);
Andrzej Kurek13719cd2020-01-22 06:36:39 -05002577exit:
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002578 mbedtls_test_message_queue_free(&queue);
Andrzej Kurek13719cd2020-01-22 06:36:39 -05002579}
2580/* END_CASE */
2581
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002582/* BEGIN_CASE */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002583void ssl_message_mock_uninitialized()
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002584{
2585 enum { MSGLEN = 10 };
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002586 unsigned char message[MSGLEN] = { 0 }, received[MSGLEN];
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002587 mbedtls_mock_socket client, server;
2588 mbedtls_test_message_queue server_queue, client_queue;
2589 mbedtls_test_message_socket_context server_context, client_context;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002590 mbedtls_message_socket_init(&server_context);
2591 mbedtls_message_socket_init(&client_context);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002592
2593 /* Send with a NULL context */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002594 TEST_ASSERT(mbedtls_mock_tcp_send_msg(NULL, message, MSGLEN)
2595 == MBEDTLS_TEST_ERROR_CONTEXT_ERROR);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002596
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002597 TEST_ASSERT(mbedtls_mock_tcp_recv_msg(NULL, message, MSGLEN)
2598 == MBEDTLS_TEST_ERROR_CONTEXT_ERROR);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002599
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002600 TEST_ASSERT(mbedtls_message_socket_setup(&server_queue, &client_queue, 1,
2601 &server,
2602 &server_context) == 0);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002603
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002604 TEST_ASSERT(mbedtls_message_socket_setup(&client_queue, &server_queue, 1,
2605 &client,
2606 &client_context) == 0);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002607
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002608 TEST_ASSERT(mbedtls_mock_tcp_send_msg(&client_context, message, MSGLEN)
2609 == MBEDTLS_TEST_ERROR_SEND_FAILED);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002610
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002611 TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received, MSGLEN)
2612 == MBEDTLS_ERR_SSL_WANT_READ);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002613
2614 /* Push directly to a queue to later simulate a disconnected behavior */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002615 TEST_ASSERT(mbedtls_test_message_queue_push_info(&server_queue, MSGLEN)
2616 == MSGLEN);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002617
2618 /* Test if there's an error when trying to read from a disconnected
2619 * socket */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002620 TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received, MSGLEN)
2621 == MBEDTLS_TEST_ERROR_RECV_FAILED);
2622exit:
2623 mbedtls_message_socket_close(&server_context);
2624 mbedtls_message_socket_close(&client_context);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002625}
2626/* END_CASE */
2627
2628/* BEGIN_CASE */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002629void ssl_message_mock_basic()
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002630{
2631 enum { MSGLEN = 10 };
2632 unsigned char message[MSGLEN], received[MSGLEN];
2633 mbedtls_mock_socket client, server;
2634 unsigned i;
2635 mbedtls_test_message_queue server_queue, client_queue;
2636 mbedtls_test_message_socket_context server_context, client_context;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002637 mbedtls_message_socket_init(&server_context);
2638 mbedtls_message_socket_init(&client_context);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002639
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002640 TEST_ASSERT(mbedtls_message_socket_setup(&server_queue, &client_queue, 1,
2641 &server,
2642 &server_context) == 0);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002643
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002644 TEST_ASSERT(mbedtls_message_socket_setup(&client_queue, &server_queue, 1,
2645 &client,
2646 &client_context) == 0);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002647
2648 /* Fill up the buffer with structured data so that unwanted changes
2649 * can be detected */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002650 for (i = 0; i < MSGLEN; i++) {
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002651 message[i] = i & 0xFF;
2652 }
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002653 TEST_ASSERT(0 == mbedtls_mock_socket_connect(&client, &server,
2654 MSGLEN));
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002655
2656 /* Send the message to the server */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002657 TEST_ASSERT(mbedtls_mock_tcp_send_msg(&client_context, message,
2658 MSGLEN) == MSGLEN);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002659
2660 /* Read from the server */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002661 TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received, MSGLEN)
2662 == MSGLEN);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002663
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002664 TEST_ASSERT(memcmp(message, received, MSGLEN) == 0);
2665 memset(received, 0, MSGLEN);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002666
2667 /* Send the message to the client */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002668 TEST_ASSERT(mbedtls_mock_tcp_send_msg(&server_context, message,
2669 MSGLEN) == MSGLEN);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002670
2671 /* Read from the client */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002672 TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&client_context, received, MSGLEN)
2673 == MSGLEN);
2674 TEST_ASSERT(memcmp(message, received, MSGLEN) == 0);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002675
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002676exit:
2677 mbedtls_message_socket_close(&server_context);
2678 mbedtls_message_socket_close(&client_context);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002679}
2680/* END_CASE */
2681
2682/* BEGIN_CASE */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002683void ssl_message_mock_queue_overflow_underflow()
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002684{
2685 enum { MSGLEN = 10 };
2686 unsigned char message[MSGLEN], received[MSGLEN];
2687 mbedtls_mock_socket client, server;
2688 unsigned i;
2689 mbedtls_test_message_queue server_queue, client_queue;
2690 mbedtls_test_message_socket_context server_context, client_context;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002691 mbedtls_message_socket_init(&server_context);
2692 mbedtls_message_socket_init(&client_context);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002693
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002694 TEST_ASSERT(mbedtls_message_socket_setup(&server_queue, &client_queue, 2,
2695 &server,
2696 &server_context) == 0);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002697
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002698 TEST_ASSERT(mbedtls_message_socket_setup(&client_queue, &server_queue, 2,
2699 &client,
2700 &client_context) == 0);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002701
2702 /* Fill up the buffer with structured data so that unwanted changes
2703 * can be detected */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002704 for (i = 0; i < MSGLEN; i++) {
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002705 message[i] = i & 0xFF;
2706 }
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002707 TEST_ASSERT(0 == mbedtls_mock_socket_connect(&client, &server,
2708 MSGLEN*2));
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002709
2710 /* Send three message to the server, last one with an error */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002711 TEST_ASSERT(mbedtls_mock_tcp_send_msg(&client_context, message,
2712 MSGLEN - 1) == MSGLEN - 1);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002713
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002714 TEST_ASSERT(mbedtls_mock_tcp_send_msg(&client_context, message,
2715 MSGLEN) == MSGLEN);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002716
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002717 TEST_ASSERT(mbedtls_mock_tcp_send_msg(&client_context, message,
2718 MSGLEN)
2719 == MBEDTLS_ERR_SSL_WANT_WRITE);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002720
2721 /* Read three messages from the server, last one with an error */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002722 TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received,
2723 MSGLEN - 1) == MSGLEN - 1);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002724
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002725 TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received, MSGLEN)
2726 == MSGLEN);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002727
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002728 TEST_ASSERT(memcmp(message, received, MSGLEN) == 0);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002729
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002730 TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received, MSGLEN)
2731 == MBEDTLS_ERR_SSL_WANT_READ);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002732
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002733exit:
2734 mbedtls_message_socket_close(&server_context);
2735 mbedtls_message_socket_close(&client_context);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002736}
2737/* END_CASE */
2738
2739/* BEGIN_CASE */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002740void ssl_message_mock_socket_overflow()
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002741{
2742 enum { MSGLEN = 10 };
2743 unsigned char message[MSGLEN], received[MSGLEN];
2744 mbedtls_mock_socket client, server;
2745 unsigned i;
2746 mbedtls_test_message_queue server_queue, client_queue;
2747 mbedtls_test_message_socket_context server_context, client_context;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002748 mbedtls_message_socket_init(&server_context);
2749 mbedtls_message_socket_init(&client_context);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002750
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002751 TEST_ASSERT(mbedtls_message_socket_setup(&server_queue, &client_queue, 2,
2752 &server,
2753 &server_context) == 0);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002754
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002755 TEST_ASSERT(mbedtls_message_socket_setup(&client_queue, &server_queue, 2,
2756 &client,
2757 &client_context) == 0);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002758
2759 /* Fill up the buffer with structured data so that unwanted changes
2760 * can be detected */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002761 for (i = 0; i < MSGLEN; i++) {
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002762 message[i] = i & 0xFF;
2763 }
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002764 TEST_ASSERT(0 == mbedtls_mock_socket_connect(&client, &server,
2765 MSGLEN));
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002766
2767 /* Send two message to the server, second one with an error */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002768 TEST_ASSERT(mbedtls_mock_tcp_send_msg(&client_context, message,
2769 MSGLEN) == MSGLEN);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002770
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002771 TEST_ASSERT(mbedtls_mock_tcp_send_msg(&client_context, message,
2772 MSGLEN)
2773 == MBEDTLS_TEST_ERROR_SEND_FAILED);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002774
2775 /* Read the only message from the server */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002776 TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received, MSGLEN)
2777 == MSGLEN);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002778
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002779 TEST_ASSERT(memcmp(message, received, MSGLEN) == 0);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002780
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002781exit:
2782 mbedtls_message_socket_close(&server_context);
2783 mbedtls_message_socket_close(&client_context);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002784}
2785/* END_CASE */
2786
2787/* BEGIN_CASE */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002788void ssl_message_mock_truncated()
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002789{
2790 enum { MSGLEN = 10 };
2791 unsigned char message[MSGLEN], received[MSGLEN];
2792 mbedtls_mock_socket client, server;
2793 unsigned i;
2794 mbedtls_test_message_queue server_queue, client_queue;
2795 mbedtls_test_message_socket_context server_context, client_context;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002796 mbedtls_message_socket_init(&server_context);
2797 mbedtls_message_socket_init(&client_context);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002798
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002799 TEST_ASSERT(mbedtls_message_socket_setup(&server_queue, &client_queue, 2,
2800 &server,
2801 &server_context) == 0);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002802
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002803 TEST_ASSERT(mbedtls_message_socket_setup(&client_queue, &server_queue, 2,
2804 &client,
2805 &client_context) == 0);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002806
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002807 memset(received, 0, MSGLEN);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002808 /* Fill up the buffer with structured data so that unwanted changes
2809 * can be detected */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002810 for (i = 0; i < MSGLEN; i++) {
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002811 message[i] = i & 0xFF;
2812 }
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002813 TEST_ASSERT(0 == mbedtls_mock_socket_connect(&client, &server,
2814 2 * MSGLEN));
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002815
2816 /* Send two messages to the server, the second one small enough to fit in the
2817 * receiver's buffer. */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002818 TEST_ASSERT(mbedtls_mock_tcp_send_msg(&client_context, message,
2819 MSGLEN) == MSGLEN);
2820 TEST_ASSERT(mbedtls_mock_tcp_send_msg(&client_context, message,
2821 MSGLEN / 2) == MSGLEN / 2);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002822 /* Read a truncated message from the server */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002823 TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received, MSGLEN/2)
2824 == MSGLEN/2);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002825
2826 /* Test that the first half of the message is valid, and second one isn't */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002827 TEST_ASSERT(memcmp(message, received, MSGLEN/2) == 0);
2828 TEST_ASSERT(memcmp(message + MSGLEN/2, received + MSGLEN/2, MSGLEN/2)
2829 != 0);
2830 memset(received, 0, MSGLEN);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002831
2832 /* Read a full message from the server */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002833 TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received, MSGLEN/2)
2834 == MSGLEN / 2);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002835
2836 /* Test that the first half of the message is valid */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002837 TEST_ASSERT(memcmp(message, received, MSGLEN/2) == 0);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002838
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002839exit:
2840 mbedtls_message_socket_close(&server_context);
2841 mbedtls_message_socket_close(&client_context);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002842}
2843/* END_CASE */
2844
2845/* BEGIN_CASE */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002846void ssl_message_mock_socket_read_error()
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002847{
2848 enum { MSGLEN = 10 };
2849 unsigned char message[MSGLEN], received[MSGLEN];
2850 mbedtls_mock_socket client, server;
2851 unsigned i;
2852 mbedtls_test_message_queue server_queue, client_queue;
2853 mbedtls_test_message_socket_context server_context, client_context;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002854 mbedtls_message_socket_init(&server_context);
2855 mbedtls_message_socket_init(&client_context);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002856
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002857 TEST_ASSERT(mbedtls_message_socket_setup(&server_queue, &client_queue, 1,
2858 &server,
2859 &server_context) == 0);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002860
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002861 TEST_ASSERT(mbedtls_message_socket_setup(&client_queue, &server_queue, 1,
2862 &client,
2863 &client_context) == 0);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002864
2865 /* Fill up the buffer with structured data so that unwanted changes
2866 * can be detected */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002867 for (i = 0; i < MSGLEN; i++) {
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002868 message[i] = i & 0xFF;
2869 }
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002870 TEST_ASSERT(0 == mbedtls_mock_socket_connect(&client, &server,
2871 MSGLEN));
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002872
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002873 TEST_ASSERT(mbedtls_mock_tcp_send_msg(&client_context, message,
2874 MSGLEN) == MSGLEN);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002875
2876 /* Force a read error by disconnecting the socket by hand */
2877 server.status = 0;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002878 TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received, MSGLEN)
2879 == MBEDTLS_TEST_ERROR_RECV_FAILED);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002880 /* Return to a valid state */
2881 server.status = MBEDTLS_MOCK_SOCKET_CONNECTED;
2882
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002883 memset(received, 0, sizeof(received));
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002884
2885 /* Test that even though the server tried to read once disconnected, the
2886 * continuity is preserved */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002887 TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received, MSGLEN)
2888 == MSGLEN);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002889
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002890 TEST_ASSERT(memcmp(message, received, MSGLEN) == 0);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002891
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002892exit:
2893 mbedtls_message_socket_close(&server_context);
2894 mbedtls_message_socket_close(&client_context);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002895}
2896/* END_CASE */
2897
2898/* BEGIN_CASE */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002899void ssl_message_mock_interleaved_one_way()
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002900{
2901 enum { MSGLEN = 10 };
2902 unsigned char message[MSGLEN], received[MSGLEN];
2903 mbedtls_mock_socket client, server;
2904 unsigned i;
2905 mbedtls_test_message_queue server_queue, client_queue;
2906 mbedtls_test_message_socket_context server_context, client_context;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002907 mbedtls_message_socket_init(&server_context);
2908 mbedtls_message_socket_init(&client_context);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002909
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002910 TEST_ASSERT(mbedtls_message_socket_setup(&server_queue, &client_queue, 3,
2911 &server,
2912 &server_context) == 0);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002913
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002914 TEST_ASSERT(mbedtls_message_socket_setup(&client_queue, &server_queue, 3,
2915 &client,
2916 &client_context) == 0);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002917
2918 /* Fill up the buffer with structured data so that unwanted changes
2919 * can be detected */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002920 for (i = 0; i < MSGLEN; i++) {
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002921 message[i] = i & 0xFF;
2922 }
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002923 TEST_ASSERT(0 == mbedtls_mock_socket_connect(&client, &server,
2924 MSGLEN*3));
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002925
2926 /* Interleaved test - [2 sends, 1 read] twice, and then two reads
2927 * (to wrap around the buffer) */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002928 for (i = 0; i < 2; i++) {
2929 TEST_ASSERT(mbedtls_mock_tcp_send_msg(&client_context, message,
2930 MSGLEN) == MSGLEN);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002931
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002932 TEST_ASSERT(mbedtls_mock_tcp_send_msg(&client_context, message,
2933 MSGLEN) == MSGLEN);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002934
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002935 TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received,
2936 MSGLEN) == MSGLEN);
2937 TEST_ASSERT(memcmp(message, received, MSGLEN) == 0);
2938 memset(received, 0, sizeof(received));
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002939 }
2940
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002941 for (i = 0; i < 2; i++) {
2942 TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received,
2943 MSGLEN) == MSGLEN);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002944
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002945 TEST_ASSERT(memcmp(message, received, MSGLEN) == 0);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002946 }
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002947 TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received, MSGLEN)
2948 == MBEDTLS_ERR_SSL_WANT_READ);
2949exit:
2950 mbedtls_message_socket_close(&server_context);
2951 mbedtls_message_socket_close(&client_context);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002952}
2953/* END_CASE */
2954
2955/* BEGIN_CASE */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002956void ssl_message_mock_interleaved_two_ways()
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002957{
2958 enum { MSGLEN = 10 };
2959 unsigned char message[MSGLEN], received[MSGLEN];
2960 mbedtls_mock_socket client, server;
2961 unsigned i;
2962 mbedtls_test_message_queue server_queue, client_queue;
2963 mbedtls_test_message_socket_context server_context, client_context;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002964 mbedtls_message_socket_init(&server_context);
2965 mbedtls_message_socket_init(&client_context);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002966
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002967 TEST_ASSERT(mbedtls_message_socket_setup(&server_queue, &client_queue, 3,
2968 &server,
2969 &server_context) == 0);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002970
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002971 TEST_ASSERT(mbedtls_message_socket_setup(&client_queue, &server_queue, 3,
2972 &client,
2973 &client_context) == 0);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002974
2975 /* Fill up the buffer with structured data so that unwanted changes
2976 * can be detected */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002977 for (i = 0; i < MSGLEN; i++) {
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002978 message[i] = i & 0xFF;
2979 }
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002980 TEST_ASSERT(0 == mbedtls_mock_socket_connect(&client, &server,
2981 MSGLEN*3));
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002982
2983 /* Interleaved test - [2 sends, 1 read] twice, both ways, and then two reads
2984 * (to wrap around the buffer) both ways. */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002985 for (i = 0; i < 2; i++) {
2986 TEST_ASSERT(mbedtls_mock_tcp_send_msg(&client_context, message,
2987 MSGLEN) == MSGLEN);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002988
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002989 TEST_ASSERT(mbedtls_mock_tcp_send_msg(&client_context, message,
2990 MSGLEN) == MSGLEN);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002991
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002992 TEST_ASSERT(mbedtls_mock_tcp_send_msg(&server_context, message,
2993 MSGLEN) == MSGLEN);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002994
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002995 TEST_ASSERT(mbedtls_mock_tcp_send_msg(&server_context, message,
2996 MSGLEN) == MSGLEN);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05002997
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01002998 TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received,
2999 MSGLEN) == MSGLEN);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05003000
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003001 TEST_ASSERT(memcmp(message, received, MSGLEN) == 0);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05003002
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003003 memset(received, 0, sizeof(received));
Andrzej Kurekbc483de2020-01-22 03:40:00 -05003004
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003005 TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&client_context, received,
3006 MSGLEN) == MSGLEN);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05003007
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003008 TEST_ASSERT(memcmp(message, received, MSGLEN) == 0);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05003009
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003010 memset(received, 0, sizeof(received));
Andrzej Kurekbc483de2020-01-22 03:40:00 -05003011 }
3012
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003013 for (i = 0; i < 2; i++) {
3014 TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received,
3015 MSGLEN) == MSGLEN);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05003016
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003017 TEST_ASSERT(memcmp(message, received, MSGLEN) == 0);
3018 memset(received, 0, sizeof(received));
Andrzej Kurekbc483de2020-01-22 03:40:00 -05003019
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003020 TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&client_context, received,
3021 MSGLEN) == MSGLEN);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05003022
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003023 TEST_ASSERT(memcmp(message, received, MSGLEN) == 0);
3024 memset(received, 0, sizeof(received));
Andrzej Kurekbc483de2020-01-22 03:40:00 -05003025 }
3026
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003027 TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received, MSGLEN)
3028 == MBEDTLS_ERR_SSL_WANT_READ);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05003029
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003030 TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&client_context, received, MSGLEN)
3031 == MBEDTLS_ERR_SSL_WANT_READ);
3032exit:
3033 mbedtls_message_socket_close(&server_context);
3034 mbedtls_message_socket_close(&client_context);
Andrzej Kurekbc483de2020-01-22 03:40:00 -05003035}
3036/* END_CASE */
3037
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003038/* BEGIN_CASE depends_on:MBEDTLS_SSL_DTLS_ANTI_REPLAY */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003039void ssl_dtls_replay(data_t *prevs, data_t *new, int ret)
Manuel Pégourié-Gonnard4956fd72014-09-24 11:13:44 +02003040{
Azim Khand30ca132017-06-09 04:32:58 +01003041 uint32_t len = 0;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003042 mbedtls_ssl_context ssl;
Manuel Pégourié-Gonnarddef0bbe2015-05-04 14:56:36 +02003043 mbedtls_ssl_config conf;
Manuel Pégourié-Gonnard4956fd72014-09-24 11:13:44 +02003044
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003045 mbedtls_ssl_init(&ssl);
3046 mbedtls_ssl_config_init(&conf);
Manuel Pégourié-Gonnard41d479e2015-04-29 00:48:22 +02003047
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003048 TEST_ASSERT(mbedtls_ssl_config_defaults(&conf,
3049 MBEDTLS_SSL_IS_CLIENT,
3050 MBEDTLS_SSL_TRANSPORT_DATAGRAM,
3051 MBEDTLS_SSL_PRESET_DEFAULT) == 0);
3052 TEST_ASSERT(mbedtls_ssl_setup(&ssl, &conf) == 0);
Manuel Pégourié-Gonnard4956fd72014-09-24 11:13:44 +02003053
3054 /* Read previous record numbers */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003055 for (len = 0; len < prevs->len; len += 6) {
3056 memcpy(ssl.in_ctr + 2, prevs->x + len, 6);
3057 mbedtls_ssl_dtls_replay_update(&ssl);
Manuel Pégourié-Gonnard4956fd72014-09-24 11:13:44 +02003058 }
3059
3060 /* Check new number */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003061 memcpy(ssl.in_ctr + 2, new->x, 6);
3062 TEST_ASSERT(mbedtls_ssl_dtls_replay_check(&ssl) == ret);
Manuel Pégourié-Gonnard4956fd72014-09-24 11:13:44 +02003063
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003064 mbedtls_ssl_free(&ssl);
3065 mbedtls_ssl_config_free(&conf);
Manuel Pégourié-Gonnard4956fd72014-09-24 11:13:44 +02003066}
3067/* END_CASE */
Hanno Beckerb25c0c72017-05-05 11:24:30 +01003068
Gilles Peskine33d03fe2023-02-01 18:37:49 +01003069/* BEGIN_CASE depends_on:MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED:MBEDTLS_CERTS_C */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003070void ssl_set_hostname_twice(char *hostname0, char *hostname1)
Hanno Beckerb25c0c72017-05-05 11:24:30 +01003071{
3072 mbedtls_ssl_context ssl;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003073 mbedtls_ssl_init(&ssl);
Hanno Beckerb25c0c72017-05-05 11:24:30 +01003074
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003075 TEST_ASSERT(mbedtls_ssl_set_hostname(&ssl, hostname0) == 0);
3076 TEST_ASSERT(mbedtls_ssl_set_hostname(&ssl, hostname1) == 0);
Hanno Beckerb25c0c72017-05-05 11:24:30 +01003077
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003078 mbedtls_ssl_free(&ssl);
Hanno Beckerb25c0c72017-05-05 11:24:30 +01003079}
Darryl Green11999bb2018-03-13 15:22:58 +00003080/* END_CASE */
Hanno Beckera18d1322018-01-03 14:27:32 +00003081
3082/* BEGIN_CASE */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003083void ssl_crypt_record(int cipher_type, int hash_id,
3084 int etm, int tag_mode, int ver,
3085 int cid0_len, int cid1_len)
Hanno Beckera18d1322018-01-03 14:27:32 +00003086{
3087 /*
3088 * Test several record encryptions and decryptions
3089 * with plenty of space before and after the data
3090 * within the record buffer.
3091 */
3092
3093 int ret;
3094 int num_records = 16;
3095 mbedtls_ssl_context ssl; /* ONLY for debugging */
3096
3097 mbedtls_ssl_transform t0, t1;
Hanno Becker81e16a32019-03-01 11:21:44 +00003098 unsigned char *buf = NULL;
Hanno Beckera18d1322018-01-03 14:27:32 +00003099 size_t const buflen = 512;
3100 mbedtls_record rec, rec_backup;
3101
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003102 mbedtls_ssl_init(&ssl);
3103 mbedtls_ssl_transform_init(&t0);
3104 mbedtls_ssl_transform_init(&t1);
3105 TEST_ASSERT(build_transforms(&t0, &t1, cipher_type, hash_id,
3106 etm, tag_mode, ver,
3107 (size_t) cid0_len,
3108 (size_t) cid1_len) == 0);
Hanno Beckera18d1322018-01-03 14:27:32 +00003109
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003110 TEST_ASSERT((buf = mbedtls_calloc(1, buflen)) != NULL);
Hanno Beckera18d1322018-01-03 14:27:32 +00003111
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003112 while (num_records-- > 0) {
Hanno Beckera18d1322018-01-03 14:27:32 +00003113 mbedtls_ssl_transform *t_dec, *t_enc;
3114 /* Take turns in who's sending and who's receiving. */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003115 if (num_records % 3 == 0) {
Hanno Beckera18d1322018-01-03 14:27:32 +00003116 t_dec = &t0;
3117 t_enc = &t1;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003118 } else {
Hanno Beckera18d1322018-01-03 14:27:32 +00003119 t_dec = &t1;
3120 t_enc = &t0;
3121 }
3122
3123 /*
3124 * The record header affects the transformation in two ways:
3125 * 1) It determines the AEAD additional data
3126 * 2) The record counter sometimes determines the IV.
3127 *
3128 * Apart from that, the fields don't have influence.
3129 * In particular, it is currently not the responsibility
3130 * of ssl_encrypt/decrypt_buf to check if the transform
3131 * version matches the record version, or that the
3132 * type is sensible.
3133 */
3134
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003135 memset(rec.ctr, num_records, sizeof(rec.ctr));
Hanno Beckera18d1322018-01-03 14:27:32 +00003136 rec.type = 42;
3137 rec.ver[0] = num_records;
3138 rec.ver[1] = num_records;
Hanno Beckera0e20d02019-05-15 14:03:01 +01003139#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
Hanno Beckerd856c822019-04-29 17:30:59 +01003140 rec.cid_len = 0;
Hanno Beckera0e20d02019-05-15 14:03:01 +01003141#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
Hanno Beckera18d1322018-01-03 14:27:32 +00003142
3143 rec.buf = buf;
3144 rec.buf_len = buflen;
3145 rec.data_offset = 16;
3146 /* Make sure to vary the length to exercise different
3147 * paddings. */
3148 rec.data_len = 1 + num_records;
3149
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003150 memset(rec.buf + rec.data_offset, 42, rec.data_len);
Hanno Beckera18d1322018-01-03 14:27:32 +00003151
3152 /* Make a copy for later comparison */
3153 rec_backup = rec;
3154
3155 /* Encrypt record */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003156 ret = mbedtls_ssl_encrypt_buf(&ssl, t_enc, &rec,
3157 mbedtls_test_rnd_std_rand, NULL);
3158 TEST_ASSERT(ret == 0 || ret == MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL);
3159 if (ret != 0) {
Hanno Beckera18d1322018-01-03 14:27:32 +00003160 continue;
3161 }
3162
Hanno Beckerb2713ab2020-05-07 14:54:22 +01003163#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003164 if (rec.cid_len != 0) {
Hanno Beckerb2713ab2020-05-07 14:54:22 +01003165 /* DTLS 1.2 + CID hides the real content type and
3166 * uses a special CID content type in the protected
3167 * record. Double-check this. */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003168 TEST_ASSERT(rec.type == MBEDTLS_SSL_MSG_CID);
Hanno Beckerb2713ab2020-05-07 14:54:22 +01003169 }
3170#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
3171
3172#if defined(MBEDTLS_SSL_PROTO_TLS1_3_EXPERIMENTAL)
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003173 if (t_enc->minor_ver == MBEDTLS_SSL_MINOR_VERSION_4) {
Hanno Beckerb2713ab2020-05-07 14:54:22 +01003174 /* TLS 1.3 hides the real content type and
3175 * always uses Application Data as the content type
3176 * for protected records. Double-check this. */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003177 TEST_ASSERT(rec.type == MBEDTLS_SSL_MSG_APPLICATION_DATA);
Hanno Beckerb2713ab2020-05-07 14:54:22 +01003178 }
3179#endif /* MBEDTLS_SSL_PROTO_TLS1_3_EXPERIMENTAL */
3180
Hanno Beckera18d1322018-01-03 14:27:32 +00003181 /* Decrypt record with t_dec */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003182 ret = mbedtls_ssl_decrypt_buf(&ssl, t_dec, &rec);
3183 TEST_ASSERT(ret == 0);
Hanno Beckera18d1322018-01-03 14:27:32 +00003184
3185 /* Compare results */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003186 TEST_ASSERT(rec.type == rec_backup.type);
3187 TEST_ASSERT(memcmp(rec.ctr, rec_backup.ctr, 8) == 0);
3188 TEST_ASSERT(rec.ver[0] == rec_backup.ver[0]);
3189 TEST_ASSERT(rec.ver[1] == rec_backup.ver[1]);
3190 TEST_ASSERT(rec.data_len == rec_backup.data_len);
3191 TEST_ASSERT(rec.data_offset == rec_backup.data_offset);
3192 TEST_ASSERT(memcmp(rec.buf + rec.data_offset,
3193 rec_backup.buf + rec_backup.data_offset,
3194 rec.data_len) == 0);
Hanno Beckera18d1322018-01-03 14:27:32 +00003195 }
3196
Hanno Becker81e16a32019-03-01 11:21:44 +00003197exit:
3198
Hanno Beckera18d1322018-01-03 14:27:32 +00003199 /* Cleanup */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003200 mbedtls_ssl_free(&ssl);
3201 mbedtls_ssl_transform_free(&t0);
3202 mbedtls_ssl_transform_free(&t1);
Hanno Beckera18d1322018-01-03 14:27:32 +00003203
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003204 mbedtls_free(buf);
Hanno Beckera18d1322018-01-03 14:27:32 +00003205}
3206/* END_CASE */
Hanno Beckerb3268da2018-01-05 15:20:24 +00003207
3208/* BEGIN_CASE */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003209void ssl_crypt_record_small(int cipher_type, int hash_id,
3210 int etm, int tag_mode, int ver,
3211 int cid0_len, int cid1_len)
Hanno Beckerb3268da2018-01-05 15:20:24 +00003212{
3213 /*
3214 * Test pairs of encryption and decryption with an increasing
3215 * amount of space in the record buffer - in more detail:
3216 * 1) Try to encrypt with 0, 1, 2, ... bytes available
3217 * in front of the plaintext, and expect the encryption
3218 * to succeed starting from some offset. Always keep
3219 * enough space in the end of the buffer.
3220 * 2) Try to encrypt with 0, 1, 2, ... bytes available
3221 * at the end of the plaintext, and expect the encryption
3222 * to succeed starting from some offset. Always keep
3223 * enough space at the beginning of the buffer.
3224 * 3) Try to encrypt with 0, 1, 2, ... bytes available
3225 * both at the front and end of the plaintext,
3226 * and expect the encryption to succeed starting from
3227 * some offset.
3228 *
3229 * If encryption succeeds, check that decryption succeeds
3230 * and yields the original record.
3231 */
3232
3233 mbedtls_ssl_context ssl; /* ONLY for debugging */
3234
3235 mbedtls_ssl_transform t0, t1;
Hanno Becker81e16a32019-03-01 11:21:44 +00003236 unsigned char *buf = NULL;
Hanno Beckerd856c822019-04-29 17:30:59 +01003237 size_t const buflen = 256;
Hanno Beckerb3268da2018-01-05 15:20:24 +00003238 mbedtls_record rec, rec_backup;
3239
3240 int ret;
Hanno Beckerd856c822019-04-29 17:30:59 +01003241 int mode; /* Mode 1, 2 or 3 as explained above */
3242 size_t offset; /* Available space at beginning/end/both */
3243 size_t threshold = 96; /* Maximum offset to test against */
Hanno Beckerb3268da2018-01-05 15:20:24 +00003244
Hanno Beckerd856c822019-04-29 17:30:59 +01003245 size_t default_pre_padding = 64; /* Pre-padding to use in mode 2 */
3246 size_t default_post_padding = 128; /* Post-padding to use in mode 1 */
Hanno Beckerb3268da2018-01-05 15:20:24 +00003247
3248 int seen_success; /* Indicates if in the current mode we've
3249 * already seen a successful test. */
3250
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003251 mbedtls_ssl_init(&ssl);
3252 mbedtls_ssl_transform_init(&t0);
3253 mbedtls_ssl_transform_init(&t1);
3254 TEST_ASSERT(build_transforms(&t0, &t1, cipher_type, hash_id,
3255 etm, tag_mode, ver,
3256 (size_t) cid0_len,
3257 (size_t) cid1_len) == 0);
Hanno Beckerb3268da2018-01-05 15:20:24 +00003258
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003259 TEST_ASSERT((buf = mbedtls_calloc(1, buflen)) != NULL);
Hanno Beckerb3268da2018-01-05 15:20:24 +00003260
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003261 for (mode = 1; mode <= 3; mode++) {
Hanno Beckerb3268da2018-01-05 15:20:24 +00003262 seen_success = 0;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003263 for (offset = 0; offset <= threshold; offset++) {
Hanno Beckerb3268da2018-01-05 15:20:24 +00003264 mbedtls_ssl_transform *t_dec, *t_enc;
Hanno Becker6c87b3f2019-04-29 17:24:44 +01003265 t_dec = &t0;
3266 t_enc = &t1;
Hanno Beckerb3268da2018-01-05 15:20:24 +00003267
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003268 memset(rec.ctr, offset, sizeof(rec.ctr));
Hanno Beckerb3268da2018-01-05 15:20:24 +00003269 rec.type = 42;
3270 rec.ver[0] = offset;
3271 rec.ver[1] = offset;
3272 rec.buf = buf;
3273 rec.buf_len = buflen;
Hanno Beckera0e20d02019-05-15 14:03:01 +01003274#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
Hanno Beckerd856c822019-04-29 17:30:59 +01003275 rec.cid_len = 0;
Hanno Beckera0e20d02019-05-15 14:03:01 +01003276#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
Hanno Beckerb3268da2018-01-05 15:20:24 +00003277
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003278 switch (mode) {
Hanno Beckerb3268da2018-01-05 15:20:24 +00003279 case 1: /* Space in the beginning */
3280 rec.data_offset = offset;
3281 rec.data_len = buflen - offset - default_post_padding;
3282 break;
3283
3284 case 2: /* Space in the end */
3285 rec.data_offset = default_pre_padding;
3286 rec.data_len = buflen - default_pre_padding - offset;
3287 break;
3288
3289 case 3: /* Space in the beginning and end */
3290 rec.data_offset = offset;
3291 rec.data_len = buflen - 2 * offset;
3292 break;
3293
3294 default:
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003295 TEST_ASSERT(0);
Hanno Beckerb3268da2018-01-05 15:20:24 +00003296 break;
3297 }
3298
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003299 memset(rec.buf + rec.data_offset, 42, rec.data_len);
Hanno Beckerb3268da2018-01-05 15:20:24 +00003300
3301 /* Make a copy for later comparison */
3302 rec_backup = rec;
3303
3304 /* Encrypt record */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003305 ret = mbedtls_ssl_encrypt_buf(&ssl, t_enc, &rec,
3306 mbedtls_test_rnd_std_rand, NULL);
Hanno Beckerb3268da2018-01-05 15:20:24 +00003307
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003308 if ((mode == 1 || mode == 2) && seen_success) {
3309 TEST_ASSERT(ret == 0);
3310 } else {
3311 TEST_ASSERT(ret == 0 || ret == MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL);
3312 if (ret == 0) {
Hanno Beckerb3268da2018-01-05 15:20:24 +00003313 seen_success = 1;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003314 }
Hanno Beckerb3268da2018-01-05 15:20:24 +00003315 }
3316
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003317 if (ret != 0) {
Hanno Beckerb3268da2018-01-05 15:20:24 +00003318 continue;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003319 }
Hanno Beckerb3268da2018-01-05 15:20:24 +00003320
Hanno Beckerb2713ab2020-05-07 14:54:22 +01003321#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003322 if (rec.cid_len != 0) {
Hanno Beckerb2713ab2020-05-07 14:54:22 +01003323 /* DTLS 1.2 + CID hides the real content type and
3324 * uses a special CID content type in the protected
3325 * record. Double-check this. */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003326 TEST_ASSERT(rec.type == MBEDTLS_SSL_MSG_CID);
Hanno Beckerb2713ab2020-05-07 14:54:22 +01003327 }
3328#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
3329
3330#if defined(MBEDTLS_SSL_PROTO_TLS1_3_EXPERIMENTAL)
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003331 if (t_enc->minor_ver == MBEDTLS_SSL_MINOR_VERSION_4) {
Hanno Beckerb2713ab2020-05-07 14:54:22 +01003332 /* TLS 1.3 hides the real content type and
3333 * always uses Application Data as the content type
3334 * for protected records. Double-check this. */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003335 TEST_ASSERT(rec.type == MBEDTLS_SSL_MSG_APPLICATION_DATA);
Hanno Beckerb2713ab2020-05-07 14:54:22 +01003336 }
3337#endif /* MBEDTLS_SSL_PROTO_TLS1_3_EXPERIMENTAL */
3338
Hanno Beckerb3268da2018-01-05 15:20:24 +00003339 /* Decrypt record with t_dec */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003340 TEST_ASSERT(mbedtls_ssl_decrypt_buf(&ssl, t_dec, &rec) == 0);
Hanno Beckerb3268da2018-01-05 15:20:24 +00003341
3342 /* Compare results */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003343 TEST_ASSERT(rec.type == rec_backup.type);
3344 TEST_ASSERT(memcmp(rec.ctr, rec_backup.ctr, 8) == 0);
3345 TEST_ASSERT(rec.ver[0] == rec_backup.ver[0]);
3346 TEST_ASSERT(rec.ver[1] == rec_backup.ver[1]);
3347 TEST_ASSERT(rec.data_len == rec_backup.data_len);
3348 TEST_ASSERT(rec.data_offset == rec_backup.data_offset);
3349 TEST_ASSERT(memcmp(rec.buf + rec.data_offset,
3350 rec_backup.buf + rec_backup.data_offset,
3351 rec.data_len) == 0);
Hanno Beckerb3268da2018-01-05 15:20:24 +00003352 }
3353
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003354 TEST_ASSERT(seen_success == 1);
Hanno Beckerb3268da2018-01-05 15:20:24 +00003355 }
3356
Hanno Becker81e16a32019-03-01 11:21:44 +00003357exit:
3358
Hanno Beckerb3268da2018-01-05 15:20:24 +00003359 /* Cleanup */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003360 mbedtls_ssl_free(&ssl);
3361 mbedtls_ssl_transform_free(&t0);
3362 mbedtls_ssl_transform_free(&t1);
Hanno Beckerb3268da2018-01-05 15:20:24 +00003363
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003364 mbedtls_free(buf);
Hanno Beckerb3268da2018-01-05 15:20:24 +00003365}
3366/* END_CASE */
Ron Eldor824ad7b2019-05-13 14:09:00 +03003367
Manuel Pégourié-Gonnard913a2042020-07-09 10:02:41 +02003368/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CBC:MBEDTLS_AES_C:MBEDTLS_SSL_PROTO_TLS1_2 */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003369void ssl_decrypt_non_etm_cbc(int cipher_type, int hash_id, int trunc_hmac,
3370 int length_selector)
Manuel Pégourié-Gonnard0ac01a12020-07-03 12:49:10 +02003371{
3372 /*
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003373 * Test record decryption for CBC without EtM, focused on the verification
3374 * of padding and MAC.
Manuel Pégourié-Gonnard0ac01a12020-07-03 12:49:10 +02003375 *
3376 * Actually depends on TLS >= 1.0 (SSL 3.0 computes the MAC differently),
Manuel Pégourié-Gonnard913a2042020-07-09 10:02:41 +02003377 * and either AES, ARIA, Camellia or DES, but since the test framework
3378 * doesn't support alternation in dependency statements, just depend on
3379 * TLS 1.2 and AES.
Manuel Pégourié-Gonnard864abbf2020-07-21 10:37:14 +02003380 *
3381 * The length_selector argument is interpreted as follows:
3382 * - if it's -1, the plaintext length is 0 and minimal padding is applied
3383 * - if it's -2, the plaintext length is 0 and maximal padding is applied
3384 * - otherwise it must be in [0, 255] and is padding_length from RFC 5246:
3385 * it's the length of the rest of the padding, that is, excluding the
3386 * byte that encodes the length. The minimal non-zero plaintext length
3387 * that gives this padding_length is automatically selected.
Manuel Pégourié-Gonnard0ac01a12020-07-03 12:49:10 +02003388 */
3389 mbedtls_ssl_context ssl; /* ONLY for debugging */
3390 mbedtls_ssl_transform t0, t1;
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003391 mbedtls_record rec, rec_save;
3392 unsigned char *buf = NULL, *buf_save = NULL;
Manuel Pégourié-Gonnard0ac01a12020-07-03 12:49:10 +02003393 size_t buflen, olen = 0;
Manuel Pégourié-Gonnard864abbf2020-07-21 10:37:14 +02003394 size_t plaintext_len, block_size, i;
Manuel Pégourié-Gonnarde55653f2020-07-22 11:42:57 +02003395 unsigned char padlen; /* excluding the padding_length byte */
Manuel Pégourié-Gonnard0ac01a12020-07-03 12:49:10 +02003396 unsigned char add_data[13];
3397 unsigned char mac[MBEDTLS_MD_MAX_SIZE];
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003398 int exp_ret;
Manuel Pégourié-Gonnard4adc04a2020-07-16 10:00:48 +02003399 const unsigned char pad_max_len = 255; /* Per the standard */
Manuel Pégourié-Gonnard0ac01a12020-07-03 12:49:10 +02003400
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003401 mbedtls_ssl_init(&ssl);
3402 mbedtls_ssl_transform_init(&t0);
3403 mbedtls_ssl_transform_init(&t1);
Manuel Pégourié-Gonnard0ac01a12020-07-03 12:49:10 +02003404
3405 /* Set up transforms with dummy keys */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003406 TEST_ASSERT(build_transforms(&t0, &t1, cipher_type, hash_id,
3407 0, trunc_hmac,
3408 MBEDTLS_SSL_MINOR_VERSION_3,
3409 0, 0) == 0);
Manuel Pégourié-Gonnard0ac01a12020-07-03 12:49:10 +02003410
Manuel Pégourié-Gonnard864abbf2020-07-21 10:37:14 +02003411 /* Determine padding/plaintext length */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003412 TEST_ASSERT(length_selector >= -2 && length_selector <= 255);
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003413 block_size = t0.ivlen;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003414 if (length_selector < 0) {
Manuel Pégourié-Gonnard864abbf2020-07-21 10:37:14 +02003415 plaintext_len = 0;
3416
Manuel Pégourié-Gonnarde55653f2020-07-22 11:42:57 +02003417 /* Minimal padding
3418 * The +1 is for the padding_length byte, not counted in padlen. */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003419 padlen = block_size - (t0.maclen + 1) % block_size;
Manuel Pégourié-Gonnard864abbf2020-07-21 10:37:14 +02003420
3421 /* Maximal padding? */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003422 if (length_selector == -2) {
3423 padlen += block_size * ((pad_max_len - padlen) / block_size);
3424 }
3425 } else {
Manuel Pégourié-Gonnard864abbf2020-07-21 10:37:14 +02003426 padlen = length_selector;
3427
Manuel Pégourié-Gonnarde55653f2020-07-22 11:42:57 +02003428 /* Minimal non-zero plaintext_length giving desired padding.
3429 * The +1 is for the padding_length byte, not counted in padlen. */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003430 plaintext_len = block_size - (padlen + t0.maclen + 1) % block_size;
Manuel Pégourié-Gonnard864abbf2020-07-21 10:37:14 +02003431 }
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003432
Manuel Pégourié-Gonnard0ac01a12020-07-03 12:49:10 +02003433 /* Prepare a buffer for record data */
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003434 buflen = block_size
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003435 + plaintext_len
3436 + t0.maclen
3437 + padlen + 1;
3438 ASSERT_ALLOC(buf, buflen);
3439 ASSERT_ALLOC(buf_save, buflen);
Manuel Pégourié-Gonnard0ac01a12020-07-03 12:49:10 +02003440
3441 /* Prepare a dummy record header */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003442 memset(rec.ctr, 0, sizeof(rec.ctr));
Manuel Pégourié-Gonnard0ac01a12020-07-03 12:49:10 +02003443 rec.type = MBEDTLS_SSL_MSG_APPLICATION_DATA;
3444 rec.ver[0] = MBEDTLS_SSL_MAJOR_VERSION_3;
3445 rec.ver[1] = MBEDTLS_SSL_MINOR_VERSION_3;
3446#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
3447 rec.cid_len = 0;
3448#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
3449
3450 /* Prepare dummy record content */
3451 rec.buf = buf;
3452 rec.buf_len = buflen;
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003453 rec.data_offset = block_size;
Manuel Pégourié-Gonnard0ac01a12020-07-03 12:49:10 +02003454 rec.data_len = plaintext_len;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003455 memset(rec.buf + rec.data_offset, 42, rec.data_len);
Manuel Pégourié-Gonnard0ac01a12020-07-03 12:49:10 +02003456
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003457 /* Serialized version of record header for MAC purposes */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003458 memcpy(add_data, rec.ctr, 8);
Manuel Pégourié-Gonnard0ac01a12020-07-03 12:49:10 +02003459 add_data[8] = rec.type;
3460 add_data[9] = rec.ver[0];
3461 add_data[10] = rec.ver[1];
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003462 add_data[11] = (rec.data_len >> 8) & 0xff;
3463 add_data[12] = (rec.data_len >> 0) & 0xff;
Manuel Pégourié-Gonnard0ac01a12020-07-03 12:49:10 +02003464
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003465 /* Set dummy IV */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003466 memset(t0.iv_enc, 0x55, t0.ivlen);
3467 memcpy(rec.buf, t0.iv_enc, t0.ivlen);
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003468
3469 /*
3470 * Prepare a pre-encryption record (with MAC and padding), and save it.
3471 */
3472
3473 /* MAC with additional data */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003474 TEST_EQUAL(0, mbedtls_md_hmac_update(&t0.md_ctx_enc, add_data, 13));
3475 TEST_EQUAL(0, mbedtls_md_hmac_update(&t0.md_ctx_enc,
3476 rec.buf + rec.data_offset,
3477 rec.data_len));
3478 TEST_EQUAL(0, mbedtls_md_hmac_finish(&t0.md_ctx_enc, mac));
Manuel Pégourié-Gonnard0ac01a12020-07-03 12:49:10 +02003479
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003480 memcpy(rec.buf + rec.data_offset + rec.data_len, mac, t0.maclen);
Manuel Pégourié-Gonnard0ac01a12020-07-03 12:49:10 +02003481 rec.data_len += t0.maclen;
3482
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003483 /* Pad */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003484 memset(rec.buf + rec.data_offset + rec.data_len, padlen, padlen + 1);
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003485 rec.data_len += padlen + 1;
Manuel Pégourié-Gonnard0ac01a12020-07-03 12:49:10 +02003486
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003487 /* Save correct pre-encryption record */
3488 rec_save = rec;
3489 rec_save.buf = buf_save;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003490 memcpy(buf_save, buf, buflen);
Manuel Pégourié-Gonnard0ac01a12020-07-03 12:49:10 +02003491
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003492 /*
3493 * Encrypt and decrypt the correct record, expecting success
3494 */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003495 TEST_EQUAL(0, mbedtls_cipher_crypt(&t0.cipher_ctx_enc,
3496 t0.iv_enc, t0.ivlen,
3497 rec.buf + rec.data_offset, rec.data_len,
3498 rec.buf + rec.data_offset, &olen));
Manuel Pégourié-Gonnard0ac01a12020-07-03 12:49:10 +02003499 rec.data_offset -= t0.ivlen;
3500 rec.data_len += t0.ivlen;
3501
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003502 TEST_EQUAL(0, mbedtls_ssl_decrypt_buf(&ssl, &t1, &rec));
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003503
Manuel Pégourié-Gonnard0ac01a12020-07-03 12:49:10 +02003504 /*
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003505 * Modify each byte of the pre-encryption record before encrypting and
3506 * decrypting it, expecting failure every time.
Manuel Pégourié-Gonnard0ac01a12020-07-03 12:49:10 +02003507 */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003508 for (i = block_size; i < buflen; i++) {
3509 mbedtls_test_set_step(i);
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003510
3511 /* Restore correct pre-encryption record */
3512 rec = rec_save;
3513 rec.buf = buf;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003514 memcpy(buf, buf_save, buflen);
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003515
Manuel Pégourié-Gonnardb51f0442020-07-21 10:40:25 +02003516 /* Corrupt one byte of the data (could be plaintext, MAC or padding) */
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003517 rec.buf[i] ^= 0x01;
3518
3519 /* Encrypt */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003520 TEST_EQUAL(0, mbedtls_cipher_crypt(&t0.cipher_ctx_enc,
3521 t0.iv_enc, t0.ivlen,
3522 rec.buf + rec.data_offset, rec.data_len,
3523 rec.buf + rec.data_offset, &olen));
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003524 rec.data_offset -= t0.ivlen;
3525 rec.data_len += t0.ivlen;
3526
3527 /* Decrypt and expect failure */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003528 TEST_EQUAL(MBEDTLS_ERR_SSL_INVALID_MAC,
3529 mbedtls_ssl_decrypt_buf(&ssl, &t1, &rec));
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003530 }
3531
3532 /*
3533 * Use larger values of the padding bytes - with small buffers, this tests
3534 * the case where the announced padlen would be larger than the buffer
3535 * (and before that, than the buffer minus the size of the MAC), to make
3536 * sure our padding checking code does not perform any out-of-bounds reads
3537 * in this case. (With larger buffers, ie when the plaintext is long or
3538 * maximal length padding is used, this is less relevant but still doesn't
3539 * hurt to test.)
3540 *
3541 * (Start the loop with correct padding, just to double-check that record
3542 * saving did work, and that we're overwriting the correct bytes.)
3543 */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003544 for (i = padlen; i <= pad_max_len; i++) {
3545 mbedtls_test_set_step(i);
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003546
3547 /* Restore correct pre-encryption record */
3548 rec = rec_save;
3549 rec.buf = buf;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003550 memcpy(buf, buf_save, buflen);
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003551
3552 /* Set padding bytes to new value */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003553 memset(buf + buflen - padlen - 1, i, padlen + 1);
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003554
3555 /* Encrypt */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003556 TEST_EQUAL(0, mbedtls_cipher_crypt(&t0.cipher_ctx_enc,
3557 t0.iv_enc, t0.ivlen,
3558 rec.buf + rec.data_offset, rec.data_len,
3559 rec.buf + rec.data_offset, &olen));
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003560 rec.data_offset -= t0.ivlen;
3561 rec.data_len += t0.ivlen;
3562
3563 /* Decrypt and expect failure except the first time */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003564 exp_ret = (i == padlen) ? 0 : MBEDTLS_ERR_SSL_INVALID_MAC;
3565 TEST_EQUAL(exp_ret, mbedtls_ssl_decrypt_buf(&ssl, &t1, &rec));
Manuel Pégourié-Gonnard527c1ff2020-07-07 10:43:37 +02003566 }
Manuel Pégourié-Gonnard0ac01a12020-07-03 12:49:10 +02003567
3568exit:
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003569 mbedtls_ssl_free(&ssl);
3570 mbedtls_ssl_transform_free(&t0);
3571 mbedtls_ssl_transform_free(&t1);
3572 mbedtls_free(buf);
3573 mbedtls_free(buf_save);
Manuel Pégourié-Gonnard0ac01a12020-07-03 12:49:10 +02003574}
3575/* END_CASE */
3576
Hanno Becker39ff4922020-08-21 13:36:56 +01003577/* BEGIN_CASE depends_on:MBEDTLS_SSL_PROTO_TLS1_3_EXPERIMENTAL */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003578void ssl_tls1_3_hkdf_expand_label(int hash_alg,
3579 data_t *secret,
3580 int label_idx,
3581 data_t *ctx,
3582 int desired_length,
3583 data_t *expected)
Hanno Becker39ff4922020-08-21 13:36:56 +01003584{
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003585 unsigned char dst[100];
Hanno Becker39ff4922020-08-21 13:36:56 +01003586
Hanno Becker70d7fb02020-09-09 10:11:21 +01003587 unsigned char const *lbl = NULL;
3588 size_t lbl_len;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003589#define MBEDTLS_SSL_TLS1_3_LABEL(name, string) \
3590 if (label_idx == (int) tls1_3_label_ ## name) \
Hanno Becker70d7fb02020-09-09 10:11:21 +01003591 { \
3592 lbl = mbedtls_ssl_tls1_3_labels.name; \
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003593 lbl_len = sizeof(mbedtls_ssl_tls1_3_labels.name); \
Hanno Becker70d7fb02020-09-09 10:11:21 +01003594 }
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003595 MBEDTLS_SSL_TLS1_3_LABEL_LIST
Hanno Becker70d7fb02020-09-09 10:11:21 +01003596#undef MBEDTLS_SSL_TLS1_3_LABEL
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003597 TEST_ASSERT(lbl != NULL);
Hanno Becker39ff4922020-08-21 13:36:56 +01003598
3599 /* Check sanity of test parameters. */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003600 TEST_ASSERT((size_t) desired_length <= sizeof(dst));
3601 TEST_ASSERT((size_t) desired_length == expected->len);
Hanno Becker39ff4922020-08-21 13:36:56 +01003602
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003603 TEST_ASSERT(mbedtls_ssl_tls1_3_hkdf_expand_label(
3604 (mbedtls_md_type_t) hash_alg,
3605 secret->x, secret->len,
3606 lbl, lbl_len,
3607 ctx->x, ctx->len,
3608 dst, desired_length) == 0);
Hanno Becker39ff4922020-08-21 13:36:56 +01003609
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003610 ASSERT_COMPARE(dst, (size_t) desired_length,
3611 expected->x, (size_t) expected->len);
Hanno Becker39ff4922020-08-21 13:36:56 +01003612}
3613/* END_CASE */
3614
Hanno Becker19498f82020-08-21 13:37:08 +01003615/* BEGIN_CASE depends_on:MBEDTLS_SSL_PROTO_TLS1_3_EXPERIMENTAL */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003616void ssl_tls1_3_traffic_key_generation(int hash_alg,
3617 data_t *server_secret,
3618 data_t *client_secret,
3619 int desired_iv_len,
3620 int desired_key_len,
3621 data_t *expected_server_write_key,
3622 data_t *expected_server_write_iv,
3623 data_t *expected_client_write_key,
3624 data_t *expected_client_write_iv)
Hanno Becker19498f82020-08-21 13:37:08 +01003625{
3626 mbedtls_ssl_key_set keys;
3627
3628 /* Check sanity of test parameters. */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003629 TEST_ASSERT(client_secret->len == server_secret->len);
3630 TEST_ASSERT(expected_client_write_iv->len == expected_server_write_iv->len &&
3631 expected_client_write_iv->len == (size_t) desired_iv_len);
3632 TEST_ASSERT(expected_client_write_key->len == expected_server_write_key->len &&
3633 expected_client_write_key->len == (size_t) desired_key_len);
Hanno Becker19498f82020-08-21 13:37:08 +01003634
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003635 TEST_ASSERT(mbedtls_ssl_tls1_3_make_traffic_keys(
3636 (mbedtls_md_type_t) hash_alg,
3637 client_secret->x,
3638 server_secret->x,
3639 client_secret->len /* == server_secret->len */,
3640 desired_key_len, desired_iv_len,
3641 &keys) == 0);
Hanno Becker19498f82020-08-21 13:37:08 +01003642
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003643 ASSERT_COMPARE(keys.client_write_key,
3644 keys.key_len,
3645 expected_client_write_key->x,
3646 (size_t) desired_key_len);
3647 ASSERT_COMPARE(keys.server_write_key,
3648 keys.key_len,
3649 expected_server_write_key->x,
3650 (size_t) desired_key_len);
3651 ASSERT_COMPARE(keys.client_write_iv,
3652 keys.iv_len,
3653 expected_client_write_iv->x,
3654 (size_t) desired_iv_len);
3655 ASSERT_COMPARE(keys.server_write_iv,
3656 keys.iv_len,
3657 expected_server_write_iv->x,
3658 (size_t) desired_iv_len);
Hanno Becker19498f82020-08-21 13:37:08 +01003659}
3660/* END_CASE */
3661
Hanno Beckere4849d12020-08-21 14:14:14 +01003662/* BEGIN_CASE depends_on:MBEDTLS_SSL_PROTO_TLS1_3_EXPERIMENTAL */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003663void ssl_tls1_3_derive_secret(int hash_alg,
3664 data_t *secret,
3665 int label_idx,
3666 data_t *ctx,
3667 int desired_length,
3668 int already_hashed,
3669 data_t *expected)
Hanno Beckere4849d12020-08-21 14:14:14 +01003670{
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003671 unsigned char dst[100];
Hanno Beckere4849d12020-08-21 14:14:14 +01003672
Hanno Becker70d7fb02020-09-09 10:11:21 +01003673 unsigned char const *lbl = NULL;
3674 size_t lbl_len;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003675#define MBEDTLS_SSL_TLS1_3_LABEL(name, string) \
3676 if (label_idx == (int) tls1_3_label_ ## name) \
Hanno Becker70d7fb02020-09-09 10:11:21 +01003677 { \
3678 lbl = mbedtls_ssl_tls1_3_labels.name; \
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003679 lbl_len = sizeof(mbedtls_ssl_tls1_3_labels.name); \
Hanno Becker70d7fb02020-09-09 10:11:21 +01003680 }
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003681 MBEDTLS_SSL_TLS1_3_LABEL_LIST
Hanno Becker70d7fb02020-09-09 10:11:21 +01003682#undef MBEDTLS_SSL_TLS1_3_LABEL
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003683 TEST_ASSERT(lbl != NULL);
Hanno Becker70d7fb02020-09-09 10:11:21 +01003684
Hanno Beckere4849d12020-08-21 14:14:14 +01003685 /* Check sanity of test parameters. */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003686 TEST_ASSERT((size_t) desired_length <= sizeof(dst));
3687 TEST_ASSERT((size_t) desired_length == expected->len);
Hanno Beckere4849d12020-08-21 14:14:14 +01003688
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003689 TEST_ASSERT(mbedtls_ssl_tls1_3_derive_secret(
3690 (mbedtls_md_type_t) hash_alg,
3691 secret->x, secret->len,
3692 lbl, lbl_len,
3693 ctx->x, ctx->len,
3694 already_hashed,
3695 dst, desired_length) == 0);
Hanno Beckere4849d12020-08-21 14:14:14 +01003696
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003697 ASSERT_COMPARE(dst, desired_length,
3698 expected->x, desired_length);
Hanno Beckere4849d12020-08-21 14:14:14 +01003699}
3700/* END_CASE */
3701
Hanno Becker2d2c3eb2020-08-20 14:54:24 +01003702/* BEGIN_CASE depends_on:MBEDTLS_SSL_PROTO_TLS1_3_EXPERIMENTAL */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003703void ssl_tls1_3_key_evolution(int hash_alg,
3704 data_t *secret,
3705 data_t *input,
3706 data_t *expected)
Hanno Becker2d2c3eb2020-08-20 14:54:24 +01003707{
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003708 unsigned char secret_new[MBEDTLS_MD_MAX_SIZE];
Hanno Becker2d2c3eb2020-08-20 14:54:24 +01003709
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003710 TEST_ASSERT(mbedtls_ssl_tls1_3_evolve_secret(
3711 (mbedtls_md_type_t) hash_alg,
3712 secret->len ? secret->x : NULL,
3713 input->len ? input->x : NULL, input->len,
3714 secret_new) == 0);
Hanno Becker2d2c3eb2020-08-20 14:54:24 +01003715
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003716 ASSERT_COMPARE(secret_new, (size_t) expected->len,
3717 expected->x, (size_t) expected->len);
Hanno Becker2d2c3eb2020-08-20 14:54:24 +01003718}
3719/* END_CASE */
3720
Ron Eldor824ad7b2019-05-13 14:09:00 +03003721/* BEGIN_CASE */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003722void ssl_tls_prf(int type, data_t *secret, data_t *random,
3723 char *label, data_t *result_str, int exp_ret)
Ron Eldor824ad7b2019-05-13 14:09:00 +03003724{
3725 unsigned char *output;
3726
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003727 output = mbedtls_calloc(1, result_str->len);
3728 if (output == NULL) {
Ron Eldor824ad7b2019-05-13 14:09:00 +03003729 goto exit;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003730 }
Ron Eldor824ad7b2019-05-13 14:09:00 +03003731
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003732 USE_PSA_INIT();
Ron Eldor6b9b1b82019-05-15 17:04:33 +03003733
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003734 TEST_ASSERT(mbedtls_ssl_tls_prf(type, secret->x, secret->len,
3735 label, random->x, random->len,
3736 output, result_str->len) == exp_ret);
Ron Eldor824ad7b2019-05-13 14:09:00 +03003737
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003738 if (exp_ret == 0) {
3739 TEST_ASSERT(mbedtls_test_hexcmp(output, result_str->x,
3740 result_str->len, result_str->len) == 0);
Ron Eldor824ad7b2019-05-13 14:09:00 +03003741 }
3742exit:
3743
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003744 mbedtls_free(output);
3745 USE_PSA_DONE();
Ron Eldor824ad7b2019-05-13 14:09:00 +03003746}
3747/* END_CASE */
Manuel Pégourié-Gonnard6eac11b2019-05-23 09:30:55 +02003748
Manuel Pégourié-Gonnardf9deaec2019-05-24 09:41:39 +02003749/* BEGIN_CASE */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003750void ssl_serialize_session_save_load(int ticket_len, char *crt_file)
Manuel Pégourié-Gonnardf9deaec2019-05-24 09:41:39 +02003751{
3752 mbedtls_ssl_session original, restored;
3753 unsigned char *buf = NULL;
3754 size_t len;
3755
3756 /*
3757 * Test that a save-load pair is the identity
3758 */
3759
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003760 mbedtls_ssl_session_init(&original);
3761 mbedtls_ssl_session_init(&restored);
Manuel Pégourié-Gonnardf9deaec2019-05-24 09:41:39 +02003762
3763 /* Prepare a dummy session to work on */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003764 TEST_ASSERT(ssl_populate_session(&original, ticket_len, crt_file) == 0);
Manuel Pégourié-Gonnardf9deaec2019-05-24 09:41:39 +02003765
Manuel Pégourié-Gonnard686adb42019-06-03 09:55:16 +02003766 /* Serialize it */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003767 TEST_ASSERT(mbedtls_ssl_session_save(&original, NULL, 0, &len)
3768 == MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL);
3769 TEST_ASSERT((buf = mbedtls_calloc(1, len)) != NULL);
3770 TEST_ASSERT(mbedtls_ssl_session_save(&original, buf, len, &len)
3771 == 0);
Manuel Pégourié-Gonnardf9deaec2019-05-24 09:41:39 +02003772
Manuel Pégourié-Gonnard686adb42019-06-03 09:55:16 +02003773 /* Restore session from serialized data */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003774 TEST_ASSERT(mbedtls_ssl_session_load(&restored, buf, len) == 0);
Manuel Pégourié-Gonnardf9deaec2019-05-24 09:41:39 +02003775
3776 /*
3777 * Make sure both session structures are identical
3778 */
3779#if defined(MBEDTLS_HAVE_TIME)
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003780 TEST_ASSERT(original.start == restored.start);
Manuel Pégourié-Gonnardf9deaec2019-05-24 09:41:39 +02003781#endif
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003782 TEST_ASSERT(original.ciphersuite == restored.ciphersuite);
3783 TEST_ASSERT(original.compression == restored.compression);
3784 TEST_ASSERT(original.id_len == restored.id_len);
3785 TEST_ASSERT(memcmp(original.id,
3786 restored.id, sizeof(original.id)) == 0);
3787 TEST_ASSERT(memcmp(original.master,
3788 restored.master, sizeof(original.master)) == 0);
Manuel Pégourié-Gonnardf9deaec2019-05-24 09:41:39 +02003789
Gilles Peskine33d03fe2023-02-01 18:37:49 +01003790#if defined(MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED) && \
3791 defined(MBEDTLS_CERTS_C)
Manuel Pégourié-Gonnardee13a732019-07-29 13:00:39 +02003792#if defined(MBEDTLS_SSL_KEEP_PEER_CERTIFICATE)
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003793 TEST_ASSERT((original.peer_cert == NULL) ==
3794 (restored.peer_cert == NULL));
3795 if (original.peer_cert != NULL) {
3796 TEST_ASSERT(original.peer_cert->raw.len ==
3797 restored.peer_cert->raw.len);
3798 TEST_ASSERT(memcmp(original.peer_cert->raw.p,
3799 restored.peer_cert->raw.p,
3800 original.peer_cert->raw.len) == 0);
Manuel Pégourié-Gonnardf9deaec2019-05-24 09:41:39 +02003801 }
Manuel Pégourié-Gonnardee13a732019-07-29 13:00:39 +02003802#else /* MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003803 TEST_ASSERT(original.peer_cert_digest_type ==
3804 restored.peer_cert_digest_type);
3805 TEST_ASSERT(original.peer_cert_digest_len ==
3806 restored.peer_cert_digest_len);
3807 TEST_ASSERT((original.peer_cert_digest == NULL) ==
3808 (restored.peer_cert_digest == NULL));
3809 if (original.peer_cert_digest != NULL) {
3810 TEST_ASSERT(memcmp(original.peer_cert_digest,
3811 restored.peer_cert_digest,
3812 original.peer_cert_digest_len) == 0);
Manuel Pégourié-Gonnardee13a732019-07-29 13:00:39 +02003813 }
3814#endif /* MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
Gilles Peskine33d03fe2023-02-01 18:37:49 +01003815#endif /* MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED && MBEDTLS_CERTS_C */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003816 TEST_ASSERT(original.verify_result == restored.verify_result);
Manuel Pégourié-Gonnardf9deaec2019-05-24 09:41:39 +02003817
3818#if defined(MBEDTLS_SSL_SESSION_TICKETS) && defined(MBEDTLS_SSL_CLI_C)
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003819 TEST_ASSERT(original.ticket_len == restored.ticket_len);
3820 if (original.ticket_len != 0) {
3821 TEST_ASSERT(original.ticket != NULL);
3822 TEST_ASSERT(restored.ticket != NULL);
3823 TEST_ASSERT(memcmp(original.ticket,
3824 restored.ticket, original.ticket_len) == 0);
Manuel Pégourié-Gonnardf9deaec2019-05-24 09:41:39 +02003825 }
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003826 TEST_ASSERT(original.ticket_lifetime == restored.ticket_lifetime);
Manuel Pégourié-Gonnardf9deaec2019-05-24 09:41:39 +02003827#endif
3828
3829#if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003830 TEST_ASSERT(original.mfl_code == restored.mfl_code);
Manuel Pégourié-Gonnardf9deaec2019-05-24 09:41:39 +02003831#endif
3832
3833#if defined(MBEDTLS_SSL_TRUNCATED_HMAC)
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003834 TEST_ASSERT(original.trunc_hmac == restored.trunc_hmac);
Manuel Pégourié-Gonnardf9deaec2019-05-24 09:41:39 +02003835#endif
3836
3837#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003838 TEST_ASSERT(original.encrypt_then_mac == restored.encrypt_then_mac);
Manuel Pégourié-Gonnardf9deaec2019-05-24 09:41:39 +02003839#endif
3840
3841exit:
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003842 mbedtls_ssl_session_free(&original);
3843 mbedtls_ssl_session_free(&restored);
3844 mbedtls_free(buf);
Manuel Pégourié-Gonnardf9deaec2019-05-24 09:41:39 +02003845}
3846/* END_CASE */
3847
Manuel Pégourié-Gonnardaa755832019-06-03 10:53:47 +02003848/* BEGIN_CASE */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003849void ssl_serialize_session_load_save(int ticket_len, char *crt_file)
Manuel Pégourié-Gonnard6eac11b2019-05-23 09:30:55 +02003850{
3851 mbedtls_ssl_session session;
3852 unsigned char *buf1 = NULL, *buf2 = NULL;
3853 size_t len0, len1, len2;
3854
3855 /*
3856 * Test that a load-save pair is the identity
3857 */
3858
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003859 mbedtls_ssl_session_init(&session);
Manuel Pégourié-Gonnard6eac11b2019-05-23 09:30:55 +02003860
Manuel Pégourié-Gonnard3caa6ca2019-05-23 10:06:14 +02003861 /* Prepare a dummy session to work on */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003862 TEST_ASSERT(ssl_populate_session(&session, ticket_len, crt_file) == 0);
Manuel Pégourié-Gonnard3caa6ca2019-05-23 10:06:14 +02003863
Manuel Pégourié-Gonnard686adb42019-06-03 09:55:16 +02003864 /* Get desired buffer size for serializing */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003865 TEST_ASSERT(mbedtls_ssl_session_save(&session, NULL, 0, &len0)
3866 == MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL);
Manuel Pégourié-Gonnard6eac11b2019-05-23 09:30:55 +02003867
3868 /* Allocate first buffer */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003869 buf1 = mbedtls_calloc(1, len0);
3870 TEST_ASSERT(buf1 != NULL);
Manuel Pégourié-Gonnard6eac11b2019-05-23 09:30:55 +02003871
Manuel Pégourié-Gonnard686adb42019-06-03 09:55:16 +02003872 /* Serialize to buffer and free live session */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003873 TEST_ASSERT(mbedtls_ssl_session_save(&session, buf1, len0, &len1)
3874 == 0);
3875 TEST_ASSERT(len0 == len1);
3876 mbedtls_ssl_session_free(&session);
Manuel Pégourié-Gonnard6eac11b2019-05-23 09:30:55 +02003877
Manuel Pégourié-Gonnard686adb42019-06-03 09:55:16 +02003878 /* Restore session from serialized data */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003879 TEST_ASSERT(mbedtls_ssl_session_load(&session, buf1, len1) == 0);
Manuel Pégourié-Gonnard6eac11b2019-05-23 09:30:55 +02003880
Manuel Pégourié-Gonnard686adb42019-06-03 09:55:16 +02003881 /* Allocate second buffer and serialize to it */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003882 buf2 = mbedtls_calloc(1, len0);
3883 TEST_ASSERT(buf2 != NULL);
3884 TEST_ASSERT(mbedtls_ssl_session_save(&session, buf2, len0, &len2)
3885 == 0);
Manuel Pégourié-Gonnard6eac11b2019-05-23 09:30:55 +02003886
Manuel Pégourié-Gonnard686adb42019-06-03 09:55:16 +02003887 /* Make sure both serialized versions are identical */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003888 TEST_ASSERT(len1 == len2);
3889 TEST_ASSERT(memcmp(buf1, buf2, len1) == 0);
Manuel Pégourié-Gonnard6eac11b2019-05-23 09:30:55 +02003890
3891exit:
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003892 mbedtls_ssl_session_free(&session);
3893 mbedtls_free(buf1);
3894 mbedtls_free(buf2);
Manuel Pégourié-Gonnard6eac11b2019-05-23 09:30:55 +02003895}
3896/* END_CASE */
Manuel Pégourié-Gonnardf5fa0aa2019-05-23 10:38:11 +02003897
3898/* BEGIN_CASE */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003899void ssl_serialize_session_save_buf_size(int ticket_len, char *crt_file)
Manuel Pégourié-Gonnardf5fa0aa2019-05-23 10:38:11 +02003900{
3901 mbedtls_ssl_session session;
3902 unsigned char *buf = NULL;
3903 size_t good_len, bad_len, test_len;
3904
3905 /*
3906 * Test that session_save() fails cleanly on small buffers
3907 */
3908
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003909 mbedtls_ssl_session_init(&session);
Manuel Pégourié-Gonnardf5fa0aa2019-05-23 10:38:11 +02003910
Manuel Pégourié-Gonnard686adb42019-06-03 09:55:16 +02003911 /* Prepare dummy session and get serialized size */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003912 TEST_ASSERT(ssl_populate_session(&session, ticket_len, crt_file) == 0);
3913 TEST_ASSERT(mbedtls_ssl_session_save(&session, NULL, 0, &good_len)
3914 == MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL);
Manuel Pégourié-Gonnardf5fa0aa2019-05-23 10:38:11 +02003915
3916 /* Try all possible bad lengths */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003917 for (bad_len = 1; bad_len < good_len; bad_len++) {
Manuel Pégourié-Gonnardf5fa0aa2019-05-23 10:38:11 +02003918 /* Allocate exact size so that asan/valgrind can detect any overwrite */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003919 mbedtls_free(buf);
3920 TEST_ASSERT((buf = mbedtls_calloc(1, bad_len)) != NULL);
3921 TEST_ASSERT(mbedtls_ssl_session_save(&session, buf, bad_len,
3922 &test_len)
3923 == MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL);
3924 TEST_ASSERT(test_len == good_len);
Manuel Pégourié-Gonnardf5fa0aa2019-05-23 10:38:11 +02003925 }
3926
3927exit:
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003928 mbedtls_ssl_session_free(&session);
3929 mbedtls_free(buf);
Manuel Pégourié-Gonnardf5fa0aa2019-05-23 10:38:11 +02003930}
3931/* END_CASE */
Manuel Pégourié-Gonnarda3d831b2019-05-23 12:28:45 +02003932
3933/* BEGIN_CASE */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003934void ssl_serialize_session_load_buf_size(int ticket_len, char *crt_file)
Manuel Pégourié-Gonnarda3d831b2019-05-23 12:28:45 +02003935{
3936 mbedtls_ssl_session session;
3937 unsigned char *good_buf = NULL, *bad_buf = NULL;
3938 size_t good_len, bad_len;
3939
3940 /*
3941 * Test that session_load() fails cleanly on small buffers
3942 */
3943
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003944 mbedtls_ssl_session_init(&session);
Manuel Pégourié-Gonnarda3d831b2019-05-23 12:28:45 +02003945
Manuel Pégourié-Gonnard686adb42019-06-03 09:55:16 +02003946 /* Prepare serialized session data */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003947 TEST_ASSERT(ssl_populate_session(&session, ticket_len, crt_file) == 0);
3948 TEST_ASSERT(mbedtls_ssl_session_save(&session, NULL, 0, &good_len)
3949 == MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL);
3950 TEST_ASSERT((good_buf = mbedtls_calloc(1, good_len)) != NULL);
3951 TEST_ASSERT(mbedtls_ssl_session_save(&session, good_buf, good_len,
3952 &good_len) == 0);
3953 mbedtls_ssl_session_free(&session);
Manuel Pégourié-Gonnarda3d831b2019-05-23 12:28:45 +02003954
3955 /* Try all possible bad lengths */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003956 for (bad_len = 0; bad_len < good_len; bad_len++) {
Manuel Pégourié-Gonnarda3d831b2019-05-23 12:28:45 +02003957 /* Allocate exact size so that asan/valgrind can detect any overread */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003958 mbedtls_free(bad_buf);
3959 bad_buf = mbedtls_calloc(1, bad_len ? bad_len : 1);
3960 TEST_ASSERT(bad_buf != NULL);
3961 memcpy(bad_buf, good_buf, bad_len);
Manuel Pégourié-Gonnarda3d831b2019-05-23 12:28:45 +02003962
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003963 TEST_ASSERT(mbedtls_ssl_session_load(&session, bad_buf, bad_len)
3964 == MBEDTLS_ERR_SSL_BAD_INPUT_DATA);
Manuel Pégourié-Gonnarda3d831b2019-05-23 12:28:45 +02003965 }
3966
3967exit:
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003968 mbedtls_ssl_session_free(&session);
3969 mbedtls_free(good_buf);
3970 mbedtls_free(bad_buf);
Manuel Pégourié-Gonnarda3d831b2019-05-23 12:28:45 +02003971}
3972/* END_CASE */
Hanno Becker861d0bb2019-05-21 16:39:30 +01003973
Hanno Becker363b6462019-05-29 12:44:28 +01003974/* BEGIN_CASE */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003975void ssl_session_serialize_version_check(int corrupt_major,
3976 int corrupt_minor,
3977 int corrupt_patch,
3978 int corrupt_config)
Hanno Becker861d0bb2019-05-21 16:39:30 +01003979{
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003980 unsigned char serialized_session[2048];
Hanno Becker363b6462019-05-29 12:44:28 +01003981 size_t serialized_session_len;
Hanno Beckerfe1275e2019-05-29 12:45:21 +01003982 unsigned cur_byte;
Hanno Becker861d0bb2019-05-21 16:39:30 +01003983 mbedtls_ssl_session session;
Hanno Beckerfe1275e2019-05-29 12:45:21 +01003984 uint8_t should_corrupt_byte[] = { corrupt_major == 1,
3985 corrupt_minor == 1,
3986 corrupt_patch == 1,
3987 corrupt_config == 1,
3988 corrupt_config == 1 };
3989
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003990 mbedtls_ssl_session_init(&session);
Hanno Becker861d0bb2019-05-21 16:39:30 +01003991
Hanno Beckerfe1275e2019-05-29 12:45:21 +01003992 /* Infer length of serialized session. */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003993 TEST_ASSERT(mbedtls_ssl_session_save(&session,
3994 serialized_session,
3995 sizeof(serialized_session),
3996 &serialized_session_len) == 0);
Hanno Becker861d0bb2019-05-21 16:39:30 +01003997
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01003998 mbedtls_ssl_session_free(&session);
Hanno Becker861d0bb2019-05-21 16:39:30 +01003999
Hanno Beckerfe1275e2019-05-29 12:45:21 +01004000 /* Without any modification, we should be able to successfully
Hanno Becker363b6462019-05-29 12:44:28 +01004001 * de-serialize the session - double-check that. */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004002 TEST_ASSERT(mbedtls_ssl_session_load(&session,
4003 serialized_session,
4004 serialized_session_len) == 0);
4005 mbedtls_ssl_session_free(&session);
Hanno Becker861d0bb2019-05-21 16:39:30 +01004006
Hanno Beckerfe1275e2019-05-29 12:45:21 +01004007 /* Go through the bytes in the serialized session header and
4008 * corrupt them bit-by-bit. */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004009 for (cur_byte = 0; cur_byte < sizeof(should_corrupt_byte); cur_byte++) {
Hanno Beckerfe1275e2019-05-29 12:45:21 +01004010 int cur_bit;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004011 unsigned char * const byte = &serialized_session[cur_byte];
Hanno Beckerfe1275e2019-05-29 12:45:21 +01004012
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004013 if (should_corrupt_byte[cur_byte] == 0) {
Hanno Beckerfe1275e2019-05-29 12:45:21 +01004014 continue;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004015 }
Hanno Beckerfe1275e2019-05-29 12:45:21 +01004016
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004017 for (cur_bit = 0; cur_bit < CHAR_BIT; cur_bit++) {
Hanno Beckerfe1275e2019-05-29 12:45:21 +01004018 unsigned char const corrupted_bit = 0x1u << cur_bit;
4019 /* Modify a single bit in the serialized session. */
4020 *byte ^= corrupted_bit;
4021
4022 /* Attempt to deserialize */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004023 TEST_ASSERT(mbedtls_ssl_session_load(&session,
4024 serialized_session,
4025 serialized_session_len) ==
4026 MBEDTLS_ERR_SSL_VERSION_MISMATCH);
Hanno Beckerfe1275e2019-05-29 12:45:21 +01004027
4028 /* Undo the change */
4029 *byte ^= corrupted_bit;
4030 }
Hanno Becker861d0bb2019-05-21 16:39:30 +01004031 }
4032
Hanno Becker861d0bb2019-05-21 16:39:30 +01004033}
4034/* END_CASE */
Piotr Nowicki2a1f1782020-01-13 09:42:10 +01004035
Gilles Peskine33d03fe2023-02-01 18:37:49 +01004036/* BEGIN_CASE depends_on:MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED:MBEDTLS_CERTS_C:MBEDTLS_RSA_C:MBEDTLS_ECP_DP_SECP384R1_ENABLED:!MBEDTLS_USE_PSA_CRYPTO:MBEDTLS_PKCS1_V15:MBEDTLS_ENTROPY_C:MBEDTLS_ENTROPY_C:MBEDTLS_CTR_DRBG_C:MBEDTLS_SHA256_C */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004037void mbedtls_endpoint_sanity(int endpoint_type)
Piotr Nowicki2a1f1782020-01-13 09:42:10 +01004038{
4039 enum { BUFFSIZE = 1024 };
4040 mbedtls_endpoint ep;
4041 int ret = -1;
4042
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004043 ret = mbedtls_endpoint_init(NULL, endpoint_type, MBEDTLS_PK_RSA,
4044 NULL, NULL, NULL, NULL);
4045 TEST_ASSERT(MBEDTLS_ERR_SSL_BAD_INPUT_DATA == ret);
Piotr Nowicki2a1f1782020-01-13 09:42:10 +01004046
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004047 ret = mbedtls_endpoint_certificate_init(NULL, MBEDTLS_PK_RSA);
4048 TEST_ASSERT(MBEDTLS_ERR_SSL_BAD_INPUT_DATA == ret);
Piotr Nowicki2a1f1782020-01-13 09:42:10 +01004049
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004050 ret = mbedtls_endpoint_init(&ep, endpoint_type, MBEDTLS_PK_RSA,
4051 NULL, NULL, NULL, NULL);
4052 TEST_ASSERT(ret == 0);
Piotr Nowicki2a1f1782020-01-13 09:42:10 +01004053
4054exit:
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004055 mbedtls_endpoint_free(&ep, NULL);
Piotr Nowicki2a1f1782020-01-13 09:42:10 +01004056}
4057/* END_CASE */
4058
Gilles Peskine33d03fe2023-02-01 18:37:49 +01004059/* BEGIN_CASE depends_on:MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED:MBEDTLS_CERTS_C:MBEDTLS_RSA_C:MBEDTLS_ECP_DP_SECP384R1_ENABLED:!MBEDTLS_USE_PSA_CRYPTO:MBEDTLS_PKCS1_V15:MBEDTLS_ENTROPY_C:MBEDTLS_ENTROPY_C:MBEDTLS_CTR_DRBG_C:MBEDTLS_ECP_C:MBEDTLS_SHA256_C */
Piotr Nowicki2a1f1782020-01-13 09:42:10 +01004060void move_handshake_to_state(int endpoint_type, int state, int need_pass)
4061{
4062 enum { BUFFSIZE = 1024 };
4063 mbedtls_endpoint base_ep, second_ep;
4064 int ret = -1;
4065
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004066 mbedtls_platform_zeroize(&base_ep, sizeof(base_ep));
4067 mbedtls_platform_zeroize(&second_ep, sizeof(second_ep));
Andrzej Kurek0d2982b2022-10-18 07:55:46 -04004068
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004069 ret = mbedtls_endpoint_init(&base_ep, endpoint_type, MBEDTLS_PK_RSA,
4070 NULL, NULL, NULL, NULL);
4071 TEST_ASSERT(ret == 0);
Piotr Nowicki2a1f1782020-01-13 09:42:10 +01004072
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004073 ret = mbedtls_endpoint_init(&second_ep,
4074 (endpoint_type == MBEDTLS_SSL_IS_SERVER) ?
4075 MBEDTLS_SSL_IS_CLIENT : MBEDTLS_SSL_IS_SERVER,
4076 MBEDTLS_PK_RSA, NULL, NULL, NULL, NULL);
4077 TEST_ASSERT(ret == 0);
Piotr Nowicki2a1f1782020-01-13 09:42:10 +01004078
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004079 ret = mbedtls_mock_socket_connect(&(base_ep.socket),
4080 &(second_ep.socket),
4081 BUFFSIZE);
4082 TEST_ASSERT(ret == 0);
Piotr Nowicki2a1f1782020-01-13 09:42:10 +01004083
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004084 ret = mbedtls_move_handshake_to_state(&(base_ep.ssl),
4085 &(second_ep.ssl),
4086 state);
4087 if (need_pass) {
4088 TEST_ASSERT(ret == 0);
4089 TEST_ASSERT(base_ep.ssl.state == state);
4090 } else {
4091 TEST_ASSERT(ret != 0);
4092 TEST_ASSERT(base_ep.ssl.state != state);
Piotr Nowicki2a1f1782020-01-13 09:42:10 +01004093 }
4094
4095exit:
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004096 mbedtls_endpoint_free(&base_ep, NULL);
4097 mbedtls_endpoint_free(&second_ep, NULL);
Piotr Nowicki2a1f1782020-01-13 09:42:10 +01004098}
4099/* END_CASE */
Andrzej Kurekf40daa32020-02-04 09:00:01 -05004100
Gilles Peskine33d03fe2023-02-01 18:37:49 +01004101/* BEGIN_CASE depends_on:MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED:MBEDTLS_CERTS_C:!MBEDTLS_USE_PSA_CRYPTO:MBEDTLS_PKCS1_V15:MBEDTLS_RSA_C:MBEDTLS_ECP_DP_SECP384R1_ENABLED:MBEDTLS_ENTROPY_C:MBEDTLS_CTR_DRBG_C:MBEDTLS_ECP_C:MBEDTLS_SHA256_C:MBEDTLS_CAN_HANDLE_RSA_TEST_KEY */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004102void handshake_version(int dtls, int client_min_version, int client_max_version,
4103 int server_min_version, int server_max_version,
4104 int expected_negotiated_version)
Andrzej Kurekf40daa32020-02-04 09:00:01 -05004105{
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05004106 handshake_test_options options;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004107 init_handshake_options(&options);
Andrzej Kurekda2b6782020-02-12 07:56:36 -05004108
Paul Elliottc8570442020-04-15 17:00:50 +01004109 options.client_min_version = client_min_version;
4110 options.client_max_version = client_max_version;
4111 options.server_min_version = server_min_version;
4112 options.server_max_version = server_max_version;
4113
4114 options.expected_negotiated_version = expected_negotiated_version;
4115
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05004116 options.dtls = dtls;
Piotr Nowicki438bf3b2020-03-10 12:59:10 +01004117 /* By default, SSLv3.0 and TLSv1.0 use 1/n-1 splitting when sending data, so
4118 * the number of fragments will be twice as big. */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004119 if (expected_negotiated_version == MBEDTLS_SSL_MINOR_VERSION_0 ||
4120 expected_negotiated_version == MBEDTLS_SSL_MINOR_VERSION_1) {
Piotr Nowicki438bf3b2020-03-10 12:59:10 +01004121 options.expected_cli_fragments = 2;
4122 options.expected_srv_fragments = 2;
Andrzej Kurek941962e2020-02-07 09:20:32 -05004123 }
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004124 perform_handshake(&options);
Andrzej Kurekf40daa32020-02-04 09:00:01 -05004125
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05004126 /* The goto below is used to avoid an "unused label" warning.*/
4127 goto exit;
4128}
4129/* END_CASE */
Andrzej Kurek9e9efdc2020-02-26 05:25:23 -05004130
Gilles Peskine33d03fe2023-02-01 18:37:49 +01004131/* BEGIN_CASE depends_on:MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED:MBEDTLS_CERTS_C:!MBEDTLS_USE_PSA_CRYPTO:MBEDTLS_PKCS1_V15:MBEDTLS_SSL_PROTO_TLS1_2:MBEDTLS_ENTROPY_C:MBEDTLS_CTR_DRBG_C:MBEDTLS_SHA256_C */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004132void handshake_psk_cipher(char *cipher, int pk_alg, data_t *psk_str, int dtls)
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05004133{
4134 handshake_test_options options;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004135 init_handshake_options(&options);
Andrzej Kurekf40daa32020-02-04 09:00:01 -05004136
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05004137 options.cipher = cipher;
4138 options.dtls = dtls;
4139 options.psk_str = psk_str;
4140 options.pk_alg = pk_alg;
Andrzej Kurekcc5169c2020-02-04 09:04:56 -05004141
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004142 perform_handshake(&options);
Andrzej Kurek316da1f2020-02-26 09:03:47 -05004143
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05004144 /* The goto below is used to avoid an "unused label" warning.*/
4145 goto exit;
4146}
4147/* END_CASE */
Andrzej Kurek316da1f2020-02-26 09:03:47 -05004148
Gilles Peskine33d03fe2023-02-01 18:37:49 +01004149/* BEGIN_CASE depends_on:MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED:MBEDTLS_CERTS_C:!MBEDTLS_USE_PSA_CRYPTO:MBEDTLS_PKCS1_V15:MBEDTLS_SSL_PROTO_TLS1_2:MBEDTLS_ENTROPY_C:MBEDTLS_CTR_DRBG_C:MBEDTLS_SHA256_C */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004150void handshake_cipher(char *cipher, int pk_alg, int dtls)
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05004151{
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004152 test_handshake_psk_cipher(cipher, pk_alg, NULL, dtls);
Andrzej Kurekf40daa32020-02-04 09:00:01 -05004153
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05004154 /* The goto below is used to avoid an "unused label" warning.*/
4155 goto exit;
4156}
4157/* END_CASE */
Andrzej Kurekf40daa32020-02-04 09:00:01 -05004158
Gilles Peskine33d03fe2023-02-01 18:37:49 +01004159/* BEGIN_CASE depends_on:MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED:MBEDTLS_CERTS_C:!MBEDTLS_USE_PSA_CRYPTO:MBEDTLS_PKCS1_V15:MBEDTLS_SSL_PROTO_TLS1_2:MBEDTLS_RSA_C:MBEDTLS_ECP_DP_SECP384R1_ENABLED:MBEDTLS_ENTROPY_C:MBEDTLS_CTR_DRBG_C:MBEDTLS_SHA256_C */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004160void app_data(int mfl, int cli_msg_len, int srv_msg_len,
4161 int expected_cli_fragments,
4162 int expected_srv_fragments, int dtls)
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05004163{
4164 handshake_test_options options;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004165 init_handshake_options(&options);
Andrzej Kurekda2b6782020-02-12 07:56:36 -05004166
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05004167 options.mfl = mfl;
4168 options.cli_msg_len = cli_msg_len;
4169 options.srv_msg_len = srv_msg_len;
4170 options.expected_cli_fragments = expected_cli_fragments;
4171 options.expected_srv_fragments = expected_srv_fragments;
4172 options.dtls = dtls;
Andrzej Kurekda2b6782020-02-12 07:56:36 -05004173
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004174 perform_handshake(&options);
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05004175 /* The goto below is used to avoid an "unused label" warning.*/
4176 goto exit;
4177}
4178/* END_CASE */
Andrzej Kurekda2b6782020-02-12 07:56:36 -05004179
Gilles Peskine33d03fe2023-02-01 18:37:49 +01004180/* BEGIN_CASE depends_on:MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED:MBEDTLS_CERTS_C:!MBEDTLS_USE_PSA_CRYPTO:MBEDTLS_PKCS1_V15:MBEDTLS_SSL_PROTO_TLS1_2:MBEDTLS_RSA_C:MBEDTLS_ECP_DP_SECP384R1_ENABLED:MBEDTLS_ENTROPY_C:MBEDTLS_CTR_DRBG_C:MBEDTLS_ECP_C:MBEDTLS_SHA256_C:MBEDTLS_CAN_HANDLE_RSA_TEST_KEY */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004181void app_data_tls(int mfl, int cli_msg_len, int srv_msg_len,
4182 int expected_cli_fragments,
4183 int expected_srv_fragments)
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05004184{
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004185 test_app_data(mfl, cli_msg_len, srv_msg_len, expected_cli_fragments,
4186 expected_srv_fragments, 0);
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05004187 /* The goto below is used to avoid an "unused label" warning.*/
4188 goto exit;
4189}
4190/* END_CASE */
Andrzej Kurekda2b6782020-02-12 07:56:36 -05004191
Gilles Peskine33d03fe2023-02-01 18:37:49 +01004192/* BEGIN_CASE depends_on:MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED:MBEDTLS_CERTS_C:!MBEDTLS_USE_PSA_CRYPTO:MBEDTLS_PKCS1_V15:MBEDTLS_SSL_PROTO_TLS1_2:MBEDTLS_RSA_C:MBEDTLS_ECP_DP_SECP384R1_ENABLED:MBEDTLS_SSL_PROTO_DTLS:MBEDTLS_ENTROPY_C:MBEDTLS_CTR_DRBG_C:MBEDTLS_SHA256_C:MBEDTLS_CAN_HANDLE_RSA_TEST_KEY */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004193void app_data_dtls(int mfl, int cli_msg_len, int srv_msg_len,
4194 int expected_cli_fragments,
4195 int expected_srv_fragments)
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05004196{
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004197 test_app_data(mfl, cli_msg_len, srv_msg_len, expected_cli_fragments,
4198 expected_srv_fragments, 1);
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05004199 /* The goto below is used to avoid an "unused label" warning.*/
4200 goto exit;
4201}
4202/* END_CASE */
Andrzej Kurekda2b6782020-02-12 07:56:36 -05004203
Gilles Peskine33d03fe2023-02-01 18:37:49 +01004204/* BEGIN_CASE depends_on:MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED:MBEDTLS_CERTS_C:!MBEDTLS_USE_PSA_CRYPTO:MBEDTLS_PKCS1_V15:MBEDTLS_SSL_PROTO_TLS1_2:MBEDTLS_RSA_C:MBEDTLS_ECP_DP_SECP384R1_ENABLED:MBEDTLS_SSL_PROTO_DTLS:MBEDTLS_SSL_RENEGOTIATION:MBEDTLS_SSL_CONTEXT_SERIALIZATION:MBEDTLS_ENTROPY_C:MBEDTLS_CTR_DRBG_C:MBEDTLS_SHA256_C:MBEDTLS_CAN_HANDLE_RSA_TEST_KEY */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004205void handshake_serialization()
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05004206{
4207 handshake_test_options options;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004208 init_handshake_options(&options);
Andrzej Kurekda2b6782020-02-12 07:56:36 -05004209
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05004210 options.serialize = 1;
4211 options.dtls = 1;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004212 perform_handshake(&options);
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05004213 /* The goto below is used to avoid an "unused label" warning.*/
4214 goto exit;
4215}
4216/* END_CASE */
Andrzej Kurekda2b6782020-02-12 07:56:36 -05004217
Gilles Peskine33d03fe2023-02-01 18:37:49 +01004218/* BEGIN_CASE depends_on:MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED:MBEDTLS_CERTS_C:!MBEDTLS_USE_PSA_CRYPTO:MBEDTLS_PKCS1_V15:MBEDTLS_RSA_C:MBEDTLS_ECP_DP_SECP384R1_ENABLED:MBEDTLS_DEBUG_C:MBEDTLS_SSL_MAX_FRAGMENT_LENGTH:MBEDTLS_CIPHER_MODE_CBC:MBEDTLS_ENTROPY_C:MBEDTLS_CTR_DRBG_C:MBEDTLS_SHA256_C:MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED*/
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004219void handshake_fragmentation(int mfl,
4220 int expected_srv_hs_fragmentation,
4221 int expected_cli_hs_fragmentation)
Piotr Nowickibde7ee82020-02-21 10:59:50 +01004222{
4223 handshake_test_options options;
4224 log_pattern srv_pattern, cli_pattern;
4225
4226 srv_pattern.pattern = cli_pattern.pattern = "found fragmented DTLS handshake";
4227 srv_pattern.counter = 0;
4228 cli_pattern.counter = 0;
4229
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004230 init_handshake_options(&options);
Piotr Nowickibde7ee82020-02-21 10:59:50 +01004231 options.dtls = 1;
4232 options.mfl = mfl;
Darryl Greenaad82f92019-12-02 10:53:11 +00004233 /* Set cipher to one using CBC so that record splitting can be tested */
4234 options.cipher = "TLS-DHE-RSA-WITH-AES-256-CBC-SHA256";
Piotr Nowickibde7ee82020-02-21 10:59:50 +01004235 options.srv_auth_mode = MBEDTLS_SSL_VERIFY_REQUIRED;
4236 options.srv_log_obj = &srv_pattern;
4237 options.cli_log_obj = &cli_pattern;
4238 options.srv_log_fun = log_analyzer;
4239 options.cli_log_fun = log_analyzer;
4240
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004241 perform_handshake(&options);
Piotr Nowickibde7ee82020-02-21 10:59:50 +01004242
4243 /* Test if the server received a fragmented handshake */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004244 if (expected_srv_hs_fragmentation) {
4245 TEST_ASSERT(srv_pattern.counter >= 1);
Piotr Nowickibde7ee82020-02-21 10:59:50 +01004246 }
4247 /* Test if the client received a fragmented handshake */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004248 if (expected_cli_hs_fragmentation) {
4249 TEST_ASSERT(cli_pattern.counter >= 1);
Piotr Nowickibde7ee82020-02-21 10:59:50 +01004250 }
4251}
4252/* END_CASE */
4253
Gilles Peskine33d03fe2023-02-01 18:37:49 +01004254/* BEGIN_CASE depends_on:MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED:MBEDTLS_CERTS_C:!MBEDTLS_USE_PSA_CRYPTO:MBEDTLS_PKCS1_V15:MBEDTLS_SSL_PROTO_TLS1_2:MBEDTLS_RSA_C:MBEDTLS_ECP_DP_SECP384R1_ENABLED:MBEDTLS_SSL_PROTO_DTLS:MBEDTLS_SSL_RENEGOTIATION:MBEDTLS_ENTROPY_C:MBEDTLS_CTR_DRBG_C:MBEDTLS_SHA256_C:MBEDTLS_CAN_HANDLE_RSA_TEST_KEY */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004255void renegotiation(int legacy_renegotiation)
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05004256{
4257 handshake_test_options options;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004258 init_handshake_options(&options);
Andrzej Kurekda2b6782020-02-12 07:56:36 -05004259
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05004260 options.renegotiate = 1;
4261 options.legacy_renegotiation = legacy_renegotiation;
4262 options.dtls = 1;
Andrzej Kurek316da1f2020-02-26 09:03:47 -05004263
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004264 perform_handshake(&options);
Andrzej Kurek8a6ff152020-02-26 09:10:14 -05004265 /* The goto below is used to avoid an "unused label" warning.*/
4266 goto exit;
Andrzej Kurekf40daa32020-02-04 09:00:01 -05004267}
4268/* END_CASE */
Andrzej Kurek0afa2a12020-03-03 10:39:58 -05004269
Gilles Peskine33d03fe2023-02-01 18:37:49 +01004270/* BEGIN_CASE depends_on:MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED:MBEDTLS_CERTS_C:!MBEDTLS_USE_PSA_CRYPTO:MBEDTLS_PKCS1_V15:MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH:MBEDTLS_SSL_PROTO_TLS1_2:MBEDTLS_RSA_C:MBEDTLS_ECP_DP_SECP384R1_ENABLED:MBEDTLS_ENTROPY_C:MBEDTLS_CTR_DRBG_C:MBEDTLS_SHA256_C */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004271void resize_buffers(int mfl, int renegotiation, int legacy_renegotiation,
4272 int serialize, int dtls, char *cipher)
Andrzej Kurek0afa2a12020-03-03 10:39:58 -05004273{
4274 handshake_test_options options;
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004275 init_handshake_options(&options);
Andrzej Kurek0afa2a12020-03-03 10:39:58 -05004276
4277 options.mfl = mfl;
Andrzej Kurek8ea68722020-04-03 06:40:47 -04004278 options.cipher = cipher;
Andrzej Kurek0afa2a12020-03-03 10:39:58 -05004279 options.renegotiate = renegotiation;
4280 options.legacy_renegotiation = legacy_renegotiation;
4281 options.serialize = serialize;
4282 options.dtls = dtls;
4283 options.resize_buffers = 1;
4284
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004285 perform_handshake(&options);
Andrzej Kurek0afa2a12020-03-03 10:39:58 -05004286 /* The goto below is used to avoid an "unused label" warning.*/
4287 goto exit;
4288}
4289/* END_CASE */
4290
Gilles Peskine33d03fe2023-02-01 18:37:49 +01004291/* BEGIN_CASE depends_on:MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED:MBEDTLS_CERTS_C:!MBEDTLS_USE_PSA_CRYPTO:MBEDTLS_PKCS1_V15:MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH:MBEDTLS_SSL_CONTEXT_SERIALIZATION:MBEDTLS_SSL_PROTO_TLS1_2:MBEDTLS_RSA_C:MBEDTLS_ECP_DP_SECP384R1_ENABLED:MBEDTLS_SSL_PROTO_DTLS:MBEDTLS_ENTROPY_C:MBEDTLS_CTR_DRBG_C:MBEDTLS_SHA256_C:MBEDTLS_CAN_HANDLE_RSA_TEST_KEY */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004292void resize_buffers_serialize_mfl(int mfl)
Andrzej Kurek0afa2a12020-03-03 10:39:58 -05004293{
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004294 test_resize_buffers(mfl, 0, MBEDTLS_SSL_LEGACY_NO_RENEGOTIATION, 1, 1,
4295 (char *) "");
Andrzej Kurek0afa2a12020-03-03 10:39:58 -05004296
4297 /* The goto below is used to avoid an "unused label" warning.*/
4298 goto exit;
4299}
4300/* END_CASE */
4301
Gilles Peskine33d03fe2023-02-01 18:37:49 +01004302/* BEGIN_CASE depends_on:MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED:MBEDTLS_CERTS_C:!MBEDTLS_USE_PSA_CRYPTO:MBEDTLS_PKCS1_V15:MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH:MBEDTLS_SSL_PROTO_TLS1_2:MBEDTLS_RSA_C:MBEDTLS_ECP_DP_SECP384R1_ENABLED:MBEDTLS_ENTROPY_C:MBEDTLS_CTR_DRBG_C:MBEDTLS_SHA256_C:MBEDTLS_SSL_RENEGOTIATION:MBEDTLS_CAN_HANDLE_RSA_TEST_KEY */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004303void resize_buffers_renegotiate_mfl(int mfl, int legacy_renegotiation,
4304 char *cipher)
Andrzej Kurek0afa2a12020-03-03 10:39:58 -05004305{
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004306 test_resize_buffers(mfl, 1, legacy_renegotiation, 0, 1, cipher);
Andrzej Kurek0afa2a12020-03-03 10:39:58 -05004307
4308 /* The goto below is used to avoid an "unused label" warning.*/
4309 goto exit;
4310}
4311/* END_CASE */
Manuel Pégourié-Gonnard045f0942020-07-02 11:34:02 +02004312
Gilles Peskine33d03fe2023-02-01 18:37:49 +01004313/* BEGIN_CASE depends_on:MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED:MBEDTLS_CERTS_C:MBEDTLS_USE_PSA_CRYPTO:MBEDTLS_PKCS1_V15:MBEDTLS_SSL_PROTO_TLS1_2:MBEDTLS_ECP_DP_SECP256R1_ENABLED:MBEDTLS_ENTROPY_C:MBEDTLS_RSA_C:MBEDTLS_ECP_DP_SECP384R1_ENABLED:MBEDTLS_CTR_DRBG_C:MBEDTLS_ECP_C:MBEDTLS_ECDSA_C */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004314void raw_key_agreement_fail(int bad_server_ecdhe_key)
Andrzej Kurekb4eedf72022-04-15 05:41:14 -04004315{
4316 enum { BUFFSIZE = 17000 };
4317 mbedtls_endpoint client, server;
4318 mbedtls_psa_stats_t stats;
Andrzej Kurek2582ba32022-03-31 06:30:54 -04004319 size_t free_slots_before = -1;
Andrzej Kurekb4eedf72022-04-15 05:41:14 -04004320
Andrzej Kurekb4eedf72022-04-15 05:41:14 -04004321 mbedtls_ecp_group_id curve_list[] = { MBEDTLS_ECP_DP_SECP256R1,
4322 MBEDTLS_ECP_DP_NONE };
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004323 USE_PSA_INIT();
4324 mbedtls_platform_zeroize(&client, sizeof(client));
4325 mbedtls_platform_zeroize(&server, sizeof(server));
Andrzej Kurekb4eedf72022-04-15 05:41:14 -04004326
4327 /* Client side, force SECP256R1 to make one key bitflip fail
Andrzej Kurek9cb14d42022-04-14 08:51:41 -04004328 * the raw key agreement. Flipping the first byte makes the
4329 * required 0x04 identifier invalid. */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004330 TEST_EQUAL(mbedtls_endpoint_init(&client, MBEDTLS_SSL_IS_CLIENT,
4331 MBEDTLS_PK_ECDSA, NULL, NULL,
4332 NULL, curve_list), 0);
Andrzej Kurekb4eedf72022-04-15 05:41:14 -04004333
4334 /* Server side */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004335 TEST_EQUAL(mbedtls_endpoint_init(&server, MBEDTLS_SSL_IS_SERVER,
4336 MBEDTLS_PK_ECDSA, NULL, NULL,
4337 NULL, NULL), 0);
Andrzej Kurekb4eedf72022-04-15 05:41:14 -04004338
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004339 TEST_EQUAL(mbedtls_mock_socket_connect(&(client.socket),
4340 &(server.socket),
4341 BUFFSIZE), 0);
Andrzej Kurekb4eedf72022-04-15 05:41:14 -04004342
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004343 TEST_EQUAL(mbedtls_move_handshake_to_state(&(client.ssl),
4344 &(server.ssl),
4345 MBEDTLS_SSL_CLIENT_KEY_EXCHANGE)
4346 , 0);
Andrzej Kurekb4eedf72022-04-15 05:41:14 -04004347
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004348 mbedtls_psa_get_stats(&stats);
Andrzej Kurek2582ba32022-03-31 06:30:54 -04004349 /* Save the number of slots in use up to this point.
4350 * With PSA, one can be used for the ECDH private key. */
4351 free_slots_before = stats.empty_slots;
Andrzej Kurek99f67782022-03-31 07:17:18 -04004352
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004353 if (bad_server_ecdhe_key) {
Gilles Peskine6dd489c2022-04-15 05:54:40 -04004354 /* Force a simulated bitflip in the server key. to make the
4355 * raw key agreement in ssl_write_client_key_exchange fail. */
4356 (client.ssl).handshake->ecdh_psa_peerkey[0] ^= 0x02;
4357 }
Andrzej Kurekb4eedf72022-04-15 05:41:14 -04004358
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004359 TEST_EQUAL(mbedtls_move_handshake_to_state(&(client.ssl),
4360 &(server.ssl),
4361 MBEDTLS_SSL_HANDSHAKE_OVER),
4362 bad_server_ecdhe_key ? MBEDTLS_ERR_SSL_HW_ACCEL_FAILED : 0);
Andrzej Kurekb4eedf72022-04-15 05:41:14 -04004363
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004364 mbedtls_psa_get_stats(&stats);
Andrzej Kurekb4eedf72022-04-15 05:41:14 -04004365
Gilles Peskine6dd489c2022-04-15 05:54:40 -04004366 /* Make sure that the key slot is already destroyed in case of failure,
4367 * without waiting to close the connection. */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004368 if (bad_server_ecdhe_key) {
4369 TEST_EQUAL(free_slots_before, stats.empty_slots);
4370 }
Andrzej Kurekb4eedf72022-04-15 05:41:14 -04004371
4372exit:
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004373 mbedtls_endpoint_free(&client, NULL);
4374 mbedtls_endpoint_free(&server, NULL);
Andrzej Kurek99f67782022-03-31 07:17:18 -04004375
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004376 USE_PSA_DONE();
Andrzej Kurekb4eedf72022-04-15 05:41:14 -04004377}
4378/* END_CASE */
Andrzej Kurek862acb82022-06-06 13:08:23 -04004379
Andrzej Kurek3c036f52022-06-08 11:57:57 -04004380/* BEGIN_CASE depends_on:MBEDTLS_SSL_SRV_C:MBEDTLS_SSL_DTLS_CLIENT_PORT_REUSE:MBEDTLS_TEST_HOOKS */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004381void cookie_parsing(data_t *cookie, int exp_ret)
Andrzej Kurek862acb82022-06-06 13:08:23 -04004382{
4383 mbedtls_ssl_context ssl;
4384 mbedtls_ssl_config conf;
4385 size_t len;
4386
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004387 mbedtls_ssl_init(&ssl);
4388 mbedtls_ssl_config_init(&conf);
4389 TEST_EQUAL(mbedtls_ssl_config_defaults(&conf, MBEDTLS_SSL_IS_SERVER,
4390 MBEDTLS_SSL_TRANSPORT_DATAGRAM,
4391 MBEDTLS_SSL_PRESET_DEFAULT),
4392 0);
Andrzej Kurek862acb82022-06-06 13:08:23 -04004393
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004394 TEST_EQUAL(mbedtls_ssl_setup(&ssl, &conf), 0);
4395 TEST_EQUAL(mbedtls_ssl_check_dtls_clihlo_cookie(&ssl, ssl.cli_id,
4396 ssl.cli_id_len,
4397 cookie->x, cookie->len,
4398 ssl.out_buf,
4399 MBEDTLS_SSL_OUT_CONTENT_LEN,
4400 &len),
4401 exp_ret);
Andrzej Kurek862acb82022-06-06 13:08:23 -04004402
Gilles Peskine1b6c09a2023-01-11 14:52:35 +01004403 mbedtls_ssl_free(&ssl);
4404 mbedtls_ssl_config_free(&conf);
Andrzej Kurek862acb82022-06-06 13:08:23 -04004405}
4406/* END_CASE */