Use "" not <> for internal/ includes
[openssl.git] / test / dtls_mtu_test.c
1 /*
2  * Copyright 2016-2017 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the OpenSSL license (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 #include <stdio.h>
11 #include <string.h>
12
13 #include <openssl/dtls1.h>
14 #include <openssl/ssl.h>
15 #include <openssl/err.h>
16
17 #include "ssltestlib.h"
18 #include "testutil.h"
19
20 /* for SSL_READ_ETM() */
21 #include "../ssl/ssl_locl.h"
22
23 static int debug = 0;
24
25 static unsigned int clnt_psk_callback(SSL *ssl, const char *hint,
26                                       char *ident, unsigned int max_ident_len,
27                                       unsigned char *psk,
28                                       unsigned int max_psk_len)
29 {
30     BIO_snprintf(ident, max_ident_len, "psk");
31
32     if (max_psk_len > 20)
33         max_psk_len = 20;
34     memset(psk, 0x5a, max_psk_len);
35
36     return max_psk_len;
37 }
38
39 static unsigned int srvr_psk_callback(SSL *ssl, const char *identity,
40                                       unsigned char *psk,
41                                       unsigned int max_psk_len)
42 {
43     if (max_psk_len > 20)
44         max_psk_len = 20;
45     memset(psk, 0x5a, max_psk_len);
46     return max_psk_len;
47 }
48
49 static int mtu_test(SSL_CTX *ctx, const char *cs, int no_etm)
50 {
51     SSL *srvr_ssl = NULL, *clnt_ssl = NULL;
52     BIO *sc_bio = NULL;
53     int i;
54     size_t s;
55     size_t mtus[30];
56     unsigned char buf[600];
57     int rv = 0;
58
59     memset(buf, 0x5a, sizeof(buf));
60
61     if (!TEST_true(create_ssl_objects(ctx, ctx, &srvr_ssl, &clnt_ssl,
62                                       NULL, NULL)))
63         goto end;
64
65     if (no_etm)
66         SSL_set_options(srvr_ssl, SSL_OP_NO_ENCRYPT_THEN_MAC);
67
68     if (!TEST_true(SSL_set_cipher_list(srvr_ssl, cs))
69             || !TEST_true(SSL_set_cipher_list(clnt_ssl, cs))
70             || !TEST_ptr(sc_bio = SSL_get_rbio(srvr_ssl))
71             || !TEST_true(create_ssl_connection(clnt_ssl, srvr_ssl,
72                                                 SSL_ERROR_NONE)))
73         goto end;
74
75     if (debug)
76         TEST_info("Channel established");
77
78     /* For record MTU values between 500 and 539, call DTLS_get_data_mtu()
79      * to query the payload MTU which will fit. */
80     for (i = 0; i < 30; i++) {
81         SSL_set_mtu(clnt_ssl, 500 + i);
82         mtus[i] = DTLS_get_data_mtu(clnt_ssl);
83         if (debug)
84             TEST_info("%s%s MTU for record mtu %d = %lu",
85                       cs, no_etm ? "-noEtM" : "",
86                       500 + i, (unsigned long)mtus[i]);
87         if (!TEST_size_t_ne(mtus[i], 0)) {
88             TEST_info("Cipher %s MTU %d", cs, 500 + i);
89             goto end;
90         }
91     }
92
93     /* Now get out of the way */
94     SSL_set_mtu(clnt_ssl, 1000);
95
96     /*
97      * Now for all values in the range of payload MTUs, send a payload of
98      * that size and see what actual record size we end up with.
99      */
100     for (s = mtus[0]; s <= mtus[29]; s++) {
101         size_t reclen;
102
103         if (!TEST_int_eq(SSL_write(clnt_ssl, buf, s), (int)s))
104             goto end;
105         reclen = BIO_read(sc_bio, buf, sizeof(buf));
106         if (debug)
107             TEST_info("record %zu for payload %zu", reclen, s);
108
109         for (i = 0; i < 30; i++) {
110             /* DTLS_get_data_mtu() with record MTU 500+i returned mtus[i] ... */
111
112             if (!TEST_false(s <= mtus[i] && reclen > (size_t)(500 + i))) {
113                 /*
114                  * We sent a packet smaller than or equal to mtus[j] and
115                  * that made a record *larger* than the record MTU 500+j!
116                  */
117                 TEST_error("%s: s=%lu, mtus[i]=%lu, reclen=%lu, i=%d",
118                            cs, (unsigned long)s, (unsigned long)mtus[i],
119                            (unsigned long)reclen, 500 + i);
120                 goto end;
121             }
122             if (!TEST_false(s > mtus[i] && reclen <= (size_t)(500 + i))) {
123                 /*
124                  * We sent a *larger* packet than mtus[i] and that *still*
125                  * fits within the record MTU 500+i, so DTLS_get_data_mtu()
126                  * was overly pessimistic.
127                  */
128                 TEST_error("%s: s=%lu, mtus[i]=%lu, reclen=%lu, i=%d",
129                            cs, (unsigned long)s, (unsigned long)mtus[i],
130                            (unsigned long)reclen, 500 + i);
131                 goto end;
132             }
133         }
134     }
135     rv = 1;
136     if (SSL_READ_ETM(clnt_ssl))
137         rv = 2;
138  end:
139     SSL_free(clnt_ssl);
140     SSL_free(srvr_ssl);
141     return rv;
142 }
143
144 static int run_mtu_tests(void)
145 {
146     SSL_CTX *ctx = NULL;
147     STACK_OF(SSL_CIPHER) *ciphers;
148     int i, ret = 0;
149
150     if (!TEST_ptr(ctx = SSL_CTX_new(DTLS_method())))
151         goto end;
152
153     SSL_CTX_set_psk_server_callback(ctx, srvr_psk_callback);
154     SSL_CTX_set_psk_client_callback(ctx, clnt_psk_callback);
155     SSL_CTX_set_security_level(ctx, 0);
156
157     /*
158      * We only care about iterating over each enc/mac; we don't want to
159      * repeat the test for each auth/kx variant. So keep life simple and
160      * only do (non-DH) PSK.
161      */
162     if (!TEST_true(SSL_CTX_set_cipher_list(ctx, "PSK")))
163         goto end;
164
165     ciphers = SSL_CTX_get_ciphers(ctx);
166     for (i = 0; i < sk_SSL_CIPHER_num(ciphers); i++) {
167         const SSL_CIPHER *cipher = sk_SSL_CIPHER_value(ciphers, i);
168         const char *cipher_name = SSL_CIPHER_get_name(cipher);
169
170         /* As noted above, only one test for each enc/mac variant. */
171         if (strncmp(cipher_name, "PSK-", 4) != 0)
172             continue;
173
174         if (!TEST_int_gt(ret = mtu_test(ctx, cipher_name, 0), 0))
175             break;
176         TEST_info("%s OK", cipher_name);
177         if (ret == 1)
178             continue;
179
180         /* mtu_test() returns 2 if it used Encrypt-then-MAC */
181         if (!TEST_int_gt(ret = mtu_test(ctx, cipher_name, 1), 0))
182             break;
183         TEST_info("%s without EtM OK", cipher_name);
184     }
185
186  end:
187     SSL_CTX_free(ctx);
188     bio_s_mempacket_test_free();
189     return ret;
190 }
191
192 int setup_tests()
193 {
194     ADD_TEST(run_mtu_tests);
195     return 1;
196 }