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