1 /*
2 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License").
5 * You may not use this file except in compliance with the License.
6 * A copy of the License is located at
7 *
8 * http://aws.amazon.com/apache2.0
9 *
10 * or in the "license" file accompanying this file. This file is distributed
11 * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
12 * express or implied. See the License for the specific language governing
13 * permissions and limitations under the License.
14 */
15
16 #include "s2n_test.h"
17 #include "tests/testlib/s2n_testlib.h"
18
19 #include "tls/extensions/s2n_quic_transport_params.h"
20
21 #include "tls/s2n_connection.h"
22 #include "tls/s2n_quic_support.h"
23 #include "tls/s2n_tls13.h"
24
25 static const uint8_t TEST_DATA[] = "These are transport parameters";
26
main(int argc,char ** argv)27 int main(int argc, char **argv)
28 {
29 BEGIN_TEST();
30
31 /* Test should_send */
32 {
33 struct s2n_config *config;
34 EXPECT_NOT_NULL(config = s2n_config_new());
35
36 struct s2n_connection *conn;
37 EXPECT_NOT_NULL(conn = s2n_connection_new(S2N_CLIENT));
38 EXPECT_SUCCESS(s2n_connection_set_config(conn, config));
39
40 /* Safety check */
41 EXPECT_FALSE(s2n_quic_transport_parameters_extension.should_send(NULL));
42
43 /* Don't send if quic not enabled (default) */
44 EXPECT_FALSE(s2n_quic_transport_parameters_extension.should_send(conn));
45
46 /* Send if quic enabled */
47 EXPECT_SUCCESS(s2n_config_enable_quic(config));
48 EXPECT_TRUE(s2n_quic_transport_parameters_extension.should_send(conn));
49
50 EXPECT_SUCCESS(s2n_connection_free(conn));
51 EXPECT_SUCCESS(s2n_config_free(config));
52 }
53
54 /* Test if_missing */
55 {
56 struct s2n_config *config;
57 EXPECT_NOT_NULL(config = s2n_config_new());
58
59 struct s2n_connection *conn;
60 EXPECT_NOT_NULL(conn = s2n_connection_new(S2N_CLIENT));
61 EXPECT_SUCCESS(s2n_connection_set_config(conn, config));
62
63 /* Safety check */
64 EXPECT_FAILURE_WITH_ERRNO(s2n_quic_transport_parameters_extension.if_missing(NULL), S2N_ERR_NULL);
65
66 /* Succeeds if quic not enabled (default) */
67 EXPECT_SUCCESS(s2n_quic_transport_parameters_extension.if_missing(conn));
68
69 /* Fails if quic enabled */
70 EXPECT_SUCCESS(s2n_config_enable_quic(config));
71 EXPECT_FAILURE_WITH_ERRNO(s2n_quic_transport_parameters_extension.if_missing(conn), S2N_ERR_MISSING_EXTENSION);
72
73 EXPECT_SUCCESS(s2n_connection_free(conn));
74 EXPECT_SUCCESS(s2n_config_free(config));
75 }
76
77 /* Test send */
78 {
79 /* Safety checks */
80 {
81 struct s2n_stuffer out = { 0 };
82
83 struct s2n_connection *conn;
84 EXPECT_NOT_NULL(conn = s2n_connection_new(S2N_CLIENT));
85
86 EXPECT_FAILURE_WITH_ERRNO(s2n_quic_transport_parameters_extension.send(NULL, &out), S2N_ERR_NULL);
87 EXPECT_FAILURE_WITH_ERRNO(s2n_quic_transport_parameters_extension.send(conn, NULL), S2N_ERR_NULL);
88
89 EXPECT_SUCCESS(s2n_connection_free(conn));
90 }
91
92 /* Writes transport parameters */
93 {
94 struct s2n_stuffer out = { 0 };
95 EXPECT_SUCCESS(s2n_stuffer_growable_alloc(&out, 0));
96
97 struct s2n_config *config;
98 EXPECT_NOT_NULL(config = s2n_config_new());
99 EXPECT_SUCCESS(s2n_config_enable_quic(config));
100
101 struct s2n_connection *conn;
102 EXPECT_NOT_NULL(conn = s2n_connection_new(S2N_CLIENT));
103 EXPECT_SUCCESS(s2n_connection_set_config(conn, config));
104 EXPECT_SUCCESS(s2n_connection_set_quic_transport_parameters(conn, TEST_DATA, sizeof(TEST_DATA)));
105
106 EXPECT_SUCCESS(s2n_quic_transport_parameters_extension.send(conn, &out));
107 EXPECT_BYTEARRAY_EQUAL(out.blob.data, TEST_DATA, sizeof(TEST_DATA));
108
109 EXPECT_SUCCESS(s2n_connection_free(conn));
110 EXPECT_SUCCESS(s2n_config_free(config));
111 EXPECT_SUCCESS(s2n_stuffer_free(&out));
112 }
113
114 /* Writes empty transport parameters */
115 {
116 struct s2n_stuffer out = { 0 };
117 EXPECT_SUCCESS(s2n_stuffer_growable_alloc(&out, 0));
118
119 struct s2n_config *config;
120 EXPECT_NOT_NULL(config = s2n_config_new());
121 EXPECT_SUCCESS(s2n_config_enable_quic(config));
122
123 struct s2n_connection *conn;
124 EXPECT_NOT_NULL(conn = s2n_connection_new(S2N_CLIENT));
125 EXPECT_SUCCESS(s2n_connection_set_config(conn, config));
126
127 EXPECT_SUCCESS(s2n_quic_transport_parameters_extension.send(conn, &out));
128 EXPECT_EQUAL(s2n_stuffer_data_available(&out), 0);
129
130 EXPECT_SUCCESS(s2n_connection_free(conn));
131 EXPECT_SUCCESS(s2n_config_free(config));
132 EXPECT_SUCCESS(s2n_stuffer_free(&out));
133 }
134 }
135
136 /* Test recv */
137 {
138 /* Safety checks */
139 {
140 struct s2n_stuffer extension = { 0 };
141
142 struct s2n_connection *conn;
143 EXPECT_NOT_NULL(conn = s2n_connection_new(S2N_CLIENT));
144
145 EXPECT_FAILURE_WITH_ERRNO(s2n_quic_transport_parameters_extension.recv(NULL, &extension), S2N_ERR_NULL);
146 EXPECT_FAILURE_WITH_ERRNO(s2n_quic_transport_parameters_extension.recv(conn, NULL), S2N_ERR_NULL);
147 EXPECT_FAILURE_WITH_ERRNO(s2n_quic_transport_parameters_extension.recv(conn, &extension),
148 S2N_ERR_UNSUPPORTED_EXTENSION);
149
150 EXPECT_SUCCESS(s2n_connection_free(conn));
151 }
152
153 /* Save transport parameters */
154 {
155 struct s2n_config *config;
156 EXPECT_NOT_NULL(config = s2n_config_new());
157 EXPECT_SUCCESS(s2n_config_enable_quic(config));
158
159 struct s2n_connection *conn;
160 EXPECT_NOT_NULL(conn = s2n_connection_new(S2N_CLIENT));
161 EXPECT_SUCCESS(s2n_connection_set_config(conn, config));
162
163 struct s2n_stuffer extension = { 0 };
164 EXPECT_SUCCESS(s2n_stuffer_growable_alloc(&extension, 0));
165 EXPECT_SUCCESS(s2n_stuffer_write_bytes(&extension, TEST_DATA, sizeof(TEST_DATA)));
166
167 EXPECT_SUCCESS(s2n_quic_transport_parameters_extension.recv(conn, &extension));
168 EXPECT_BYTEARRAY_EQUAL(conn->peer_quic_transport_parameters.data, TEST_DATA, sizeof(TEST_DATA));
169
170 EXPECT_SUCCESS(s2n_connection_free(conn));
171 EXPECT_SUCCESS(s2n_config_free(config));
172 EXPECT_SUCCESS(s2n_stuffer_free(&extension));
173 }
174
175 /* Save empty transport parameters */
176 {
177 struct s2n_config *config;
178 EXPECT_NOT_NULL(config = s2n_config_new());
179 EXPECT_SUCCESS(s2n_config_enable_quic(config));
180
181 struct s2n_connection *conn;
182 EXPECT_NOT_NULL(conn = s2n_connection_new(S2N_CLIENT));
183 EXPECT_SUCCESS(s2n_connection_set_config(conn, config));
184
185 struct s2n_stuffer extension = { 0 };
186
187 EXPECT_SUCCESS(s2n_quic_transport_parameters_extension.recv(conn, &extension));
188 EXPECT_EQUAL(conn->peer_quic_transport_parameters.size, 0);
189
190 EXPECT_SUCCESS(s2n_connection_free(conn));
191 EXPECT_SUCCESS(s2n_config_free(config));
192 }
193
194 /* recv processes the output of send */
195 {
196 struct s2n_stuffer out = { 0 };
197 EXPECT_SUCCESS(s2n_stuffer_growable_alloc(&out, 0));
198
199 struct s2n_config *config;
200 EXPECT_NOT_NULL(config = s2n_config_new());
201 EXPECT_SUCCESS(s2n_config_enable_quic(config));
202
203 struct s2n_connection *server_conn;
204 EXPECT_NOT_NULL(server_conn = s2n_connection_new(S2N_SERVER));
205 EXPECT_SUCCESS(s2n_connection_set_config(server_conn, config));
206
207 struct s2n_connection *client_conn;
208 EXPECT_NOT_NULL(client_conn = s2n_connection_new(S2N_CLIENT));
209 EXPECT_SUCCESS(s2n_connection_set_config(client_conn, config));
210 EXPECT_SUCCESS(s2n_connection_set_quic_transport_parameters(client_conn, TEST_DATA, sizeof(TEST_DATA)));
211
212 EXPECT_SUCCESS(s2n_quic_transport_parameters_extension.send(client_conn, &out));
213 EXPECT_EQUAL(server_conn->peer_quic_transport_parameters.size, 0);
214 EXPECT_SUCCESS(s2n_quic_transport_parameters_extension.recv(server_conn, &out));
215 EXPECT_BYTEARRAY_EQUAL(server_conn->peer_quic_transport_parameters.data, TEST_DATA, sizeof(TEST_DATA));
216
217 EXPECT_SUCCESS(s2n_connection_free(client_conn));
218 EXPECT_SUCCESS(s2n_connection_free(server_conn));
219 EXPECT_SUCCESS(s2n_config_free(config));
220 EXPECT_SUCCESS(s2n_stuffer_free(&out));
221 }
222 }
223
224 END_TEST();
225 }
226