69b85b820e0bea58d8faf6e65bfc25e16354187e
[openssl.git] / test / tls13secretstest.c
1 /*
2  * Copyright 2016 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 <openssl/ssl.h>
11 #include <openssl/evp.h>
12 #include "../ssl/ssl_locl.h"
13
14 #include "testutil.h"
15 #include "test_main.h"
16
17 #define IVLEN   12
18 #define KEYLEN  16
19
20 /* The following are unofficial test vectors generated from a locally modified
21  * version of picotls.
22  * TODO(TLS1.3): As and when official vectors become available we should use
23  * those, e.g. see
24  * https://www.ietf.org/id/draft-thomson-tls-tls13-vectors-00.txt, however at
25  * the time of writing these are not suitable because they are based on
26  * draft -16, which works slightly differently to the draft -18 vectors below.
27  */
28
29 static unsigned char hs_start_hash[] = {
30 0xec, 0x14, 0x7a, 0x06, 0xde, 0xa3, 0xc8, 0x84, 0x6c, 0x02, 0xb2, 0x23, 0x8e,
31 0x41, 0xbd, 0xdc, 0x9d, 0x89, 0xf9, 0xae, 0xa1, 0x7b, 0x5e, 0xfd, 0x4d, 0x74,
32 0x82, 0xaf, 0x75, 0x88, 0x1c, 0x0a
33 };
34
35 static unsigned char hs_full_hash[] = {
36 0x75, 0x1a, 0x3d, 0x4a, 0x14, 0xdf, 0xab, 0xeb, 0x68, 0xe9, 0x2c, 0xa5, 0x91,
37 0x8e, 0x24, 0x08, 0xb9, 0xbc, 0xb0, 0x74, 0x89, 0x82, 0xec, 0x9c, 0x32, 0x30,
38 0xac, 0x30, 0xbb, 0xeb, 0x23, 0xe2,
39 };
40
41 static unsigned char early_secret[] = {
42 0x33, 0xad, 0x0a, 0x1c, 0x60, 0x7e, 0xc0, 0x3b, 0x09, 0xe6, 0xcd, 0x98, 0x93,
43 0x68, 0x0c, 0xe2, 0x10, 0xad, 0xf3, 0x00, 0xaa, 0x1f, 0x26, 0x60, 0xe1, 0xb2,
44 0x2e, 0x10, 0xf1, 0x70, 0xf9, 0x2a
45 };
46
47 static unsigned char ecdhe_secret[] = {
48 0xe7, 0xb8, 0xfe, 0xf8, 0x90, 0x3b, 0x52, 0x0c, 0xb9, 0xa1, 0x89, 0x71, 0xb6,
49 0x9d, 0xd4, 0x5d, 0xca, 0x53, 0xce, 0x2f, 0x12, 0xbf, 0x3b, 0xef, 0x93, 0x15,
50 0xe3, 0x12, 0x71, 0xdf, 0x4b, 0x40
51 };
52
53 static unsigned char handshake_secret[] = {
54 0xdf, 0xc9, 0x41, 0xd8, 0x26, 0x93, 0x2a, 0x59, 0x11, 0xb3, 0xb7, 0xd0, 0x38,
55 0xcb, 0x65, 0x6f, 0xda, 0xaf, 0x77, 0x07, 0x1e, 0x40, 0x9a, 0x9b, 0xa6, 0xca,
56 0x74, 0xda, 0x17, 0xb4, 0xe0, 0x04,
57 };
58
59 static const char *client_hts_label = "client handshake traffic secret";
60
61 static unsigned char client_hts[] = {
62 0x4b, 0x38, 0x48, 0xf1, 0x5d, 0xb1, 0x5e, 0x88, 0xcf, 0x3e, 0x3b, 0xff, 0xa6,
63 0xba, 0x02, 0xc1, 0xc5, 0xd1, 0xe5, 0xb1, 0xc3, 0xf3, 0x10, 0xdf, 0xe5, 0xc9,
64 0x69, 0x5a, 0x4a, 0xc6, 0x06, 0x38,
65 };
66
67 static unsigned char client_hts_key[] = {
68 0xe5, 0x7b, 0x8c, 0x38, 0x6d, 0x6f, 0x09, 0x14, 0xe2, 0xe5, 0x4e, 0x36, 0x23,
69 0x91, 0x2a, 0xd4
70 };
71
72 static unsigned char client_hts_iv[] = {
73 0x4d, 0x2e, 0x61, 0x0c, 0x4d, 0x3a, 0x8e, 0x5f, 0x15, 0x41, 0x1e, 0xfd
74 };
75
76 static const char *server_hts_label = "server handshake traffic secret";
77
78 static unsigned char server_hts[] = {
79 0x74, 0x1f, 0xb3, 0xb8, 0x41, 0x24, 0xc4, 0x7e, 0x1b, 0x2e, 0xa9, 0x4f, 0x0c,
80 0x42, 0xc9, 0x06, 0xb7, 0x7c, 0x84, 0x92, 0x05, 0xed, 0x5f, 0x19, 0xda, 0xbb,
81 0xbb, 0xce, 0xc7, 0x29, 0x06, 0x7e,
82 };
83
84 static unsigned char server_hts_key[] = {
85 0x72, 0x61, 0x1c, 0xc8, 0x0d, 0x65, 0x9c, 0x89, 0xf8, 0x94, 0x9e, 0x32, 0x67,
86 0xe1, 0x6c, 0x2d
87
88 };
89
90 static unsigned char server_hts_iv[] = {
91 0x43, 0xfe, 0x11, 0x29, 0x0f, 0xe8, 0xfe, 0x84, 0x9c, 0x9b, 0x21, 0xef,
92 };
93
94 static unsigned char master_secret[] = {
95 0xfe, 0x8d, 0xfb, 0xd0, 0x14, 0x94, 0x4e, 0x22, 0x65, 0x16, 0x7d, 0xc4, 0x20,
96 0x01, 0x5b, 0x10, 0x64, 0x74, 0xb7, 0x22, 0x9a, 0x95, 0xd1, 0x48, 0x0c, 0xb9,
97 0xac, 0xd1, 0xa0, 0x28, 0xb7, 0x67
98 };
99
100 static const char *client_ats_label = "client application traffic secret";
101
102 static unsigned char client_ats[] = {
103 0x56, 0x9e, 0x9c, 0x17, 0xe3, 0x52, 0x1f, 0xdd, 0x09, 0xf4, 0xb8, 0x4f, 0x6c,
104 0xd6, 0x6d, 0xa8, 0x23, 0xde, 0xeb, 0x81, 0xbb, 0xb1, 0xde, 0x61, 0xe2, 0x82,
105 0x56, 0x27, 0xf7, 0x00, 0x63, 0x81,
106 };
107
108 static unsigned char client_ats_key[] = {
109 0xcb, 0xfa, 0xae, 0x71, 0x8d, 0xfb, 0x52, 0xba, 0x7b, 0x87, 0xde, 0x8b, 0x6d,
110 0xac, 0x92, 0x60
111 };
112
113 static unsigned char client_ats_iv[] = {
114 0x74, 0x86, 0x88, 0xe9, 0x7f, 0x72, 0xfb, 0xf3, 0x33, 0x1e, 0xfb, 0x55
115 };
116
117 static const char *server_ats_label = "server application traffic secret";
118
119 static unsigned char server_ats[] = {
120 0xd1, 0xbf, 0xdc, 0x8b, 0x84, 0xf4, 0x16, 0xb7, 0xc6, 0x90, 0xd9, 0xc9, 0x2c,
121 0x23, 0x11, 0xb3, 0x05, 0xad, 0x75, 0xfc, 0xe6, 0x29, 0x90, 0x2b, 0xe1, 0x03,
122 0xdd, 0x0c, 0x12, 0x51, 0xea, 0xd2,
123 };
124
125 static unsigned char server_ats_key[] = {
126 0x35, 0xc2, 0xd1, 0x54, 0xa8, 0x43, 0x03, 0xc6, 0x55, 0xa0, 0x2e, 0x5e, 0x1f,
127 0x82, 0x31, 0x62
128 };
129
130 static unsigned char server_ats_iv[] = {
131 0xe5, 0x77, 0xd9, 0x8a, 0xb3, 0x2e, 0xec, 0x79, 0xb1, 0x63, 0x68, 0xc2
132 };
133
134 /* Mocked out implementations of various functions */
135 int ssl3_digest_cached_records(SSL *s, int keep)
136 {
137     return 1;
138 }
139
140 static int full_hash = 0;
141
142 /* Give a hash of the currently set handshake */
143 int ssl_handshake_hash(SSL *s, unsigned char *out, size_t outlen,
144                        size_t *hashlen)
145 {
146     if (sizeof(hs_start_hash) > outlen
147             || sizeof(hs_full_hash) != sizeof(hs_start_hash))
148         return 0;
149
150     if (full_hash) {
151         memcpy(out, hs_full_hash, sizeof(hs_full_hash));
152         *hashlen = sizeof(hs_full_hash);
153     } else {
154         memcpy(out, hs_start_hash, sizeof(hs_start_hash));
155         *hashlen = sizeof(hs_start_hash);
156     }
157
158     return 1;
159 }
160
161 const EVP_MD *ssl_handshake_md(SSL *s)
162 {
163     return EVP_sha256();
164 }
165
166 void RECORD_LAYER_reset_read_sequence(RECORD_LAYER *rl)
167 {
168 }
169
170 void RECORD_LAYER_reset_write_sequence(RECORD_LAYER *rl)
171 {
172 }
173
174 int ssl_cipher_get_evp(const SSL_SESSION *s, const EVP_CIPHER **enc,
175                        const EVP_MD **md, int *mac_pkey_type,
176                        size_t *mac_secret_size, SSL_COMP **comp, int use_etm)
177
178 {
179     return 0;
180 }
181
182 int tls1_alert_code(int code)
183 {
184     return code;
185 }
186
187 /* End of mocked out code */
188
189 static int test_secret(SSL *s, unsigned char *prk,
190                        const unsigned char *label, size_t labellen,
191                        const unsigned char *ref_secret,
192                        const unsigned char *ref_key, const unsigned char *ref_iv)
193 {
194     size_t hashsize;
195     unsigned char gensecret[EVP_MAX_MD_SIZE];
196     unsigned char hash[EVP_MAX_MD_SIZE];
197     unsigned char key[KEYLEN];
198     unsigned char iv[IVLEN];
199     const EVP_MD *md = ssl_handshake_md(s);
200
201     if (!ssl_handshake_hash(s, hash, sizeof(hash), &hashsize)) {
202         fprintf(stderr, "Failed to get hash\n");
203         return 0;
204     }
205
206     if (!tls13_hkdf_expand(s, md, prk, label, labellen, hash, gensecret,
207                            hashsize)) {
208         fprintf(stderr, "Secret generation failed\n");
209         return 0;
210     }
211
212     if (memcmp(gensecret, ref_secret, hashsize) != 0) {
213         fprintf(stderr, "Generated secret does not match\n");
214         return 0;
215     }
216
217     if (!tls13_derive_key(s, gensecret, key, KEYLEN)) {
218         fprintf(stderr, "Key generation failed\n");
219         return 0;
220     }
221
222     if (memcmp(key, ref_key, KEYLEN) != 0) {
223         fprintf(stderr, "Generated key does not match\n");
224         return 0;
225     }
226
227     if (!tls13_derive_iv(s, gensecret, iv, IVLEN)) {
228         fprintf(stderr, "IV generation failed\n");
229         return 0;
230     }
231
232     if (memcmp(iv, ref_iv, IVLEN) != 0) {
233         fprintf(stderr, "Generated IV does not match\n");
234         return 0;
235     }
236
237     return 1;
238 }
239
240 static int test_handshake_secrets(void)
241 {
242     SSL_CTX *ctx = NULL;
243     SSL *s = NULL;
244     int ret = 0;
245     size_t hashsize;
246     unsigned char out_master_secret[EVP_MAX_MD_SIZE];
247     size_t master_secret_length;
248
249     ctx = SSL_CTX_new(TLS_method());
250     if (ctx == NULL)
251         goto err;
252
253     s = SSL_new(ctx);
254     if (s == NULL)
255         goto err;
256
257     s->session = SSL_SESSION_new();
258     if (s->session == NULL)
259         goto err;
260
261     if (!tls13_generate_secret(s, ssl_handshake_md(s), NULL, NULL, 0,
262                                (unsigned char *)&s->early_secret)) {
263         fprintf(stderr, "Early secret generation failed\n");
264         goto err;
265     }
266
267     if (memcmp(s->early_secret, early_secret, sizeof(early_secret)) != 0) {
268         fprintf(stderr, "Early secret does not match\n");
269         goto err;
270     }
271
272     if (!tls13_generate_handshake_secret(s, ecdhe_secret,
273                                          sizeof(ecdhe_secret))) {
274         fprintf(stderr, "Hanshake secret generation failed\n");
275         goto err;
276     }
277
278     if (memcmp(s->handshake_secret, handshake_secret,
279                sizeof(handshake_secret)) != 0) {
280         fprintf(stderr, "Handshake secret does not match\n");
281         goto err;
282     }
283
284     hashsize = EVP_MD_size(ssl_handshake_md(s));
285     if (sizeof(client_hts) != hashsize || sizeof(client_hts_key) != KEYLEN
286             || sizeof(client_hts_iv) != IVLEN) {
287         fprintf(stderr, "Internal test error\n");
288         goto err;
289     }
290
291     if (!test_secret(s, s->handshake_secret, (unsigned char *)client_hts_label,
292                      strlen(client_hts_label), client_hts, client_hts_key,
293                      client_hts_iv)) {
294         fprintf(stderr, "Client handshake secret test failed\n");
295         goto err;
296     }
297
298     if (sizeof(server_hts) != hashsize || sizeof(server_hts_key) != KEYLEN
299             || sizeof(server_hts_iv) != IVLEN) {
300         fprintf(stderr, "Internal test error\n");
301         goto err;
302     }
303
304     if (!test_secret(s, s->handshake_secret, (unsigned char *)server_hts_label,
305                      strlen(server_hts_label), server_hts, server_hts_key,
306                      server_hts_iv)) {
307         fprintf(stderr, "Server handshake secret test failed\n");
308         goto err;
309     }
310
311     /*
312      * Ensure the mocked out ssl_handshake_hash() returns the full handshake
313      * hash.
314      */
315     full_hash = 1;
316
317     if (!tls13_generate_master_secret(s, out_master_secret,
318                                       s->handshake_secret, hashsize,
319                                       &master_secret_length)) {
320         fprintf(stderr, "Master secret generation failed\n");
321         goto err;
322     }
323
324     if (master_secret_length != sizeof(master_secret) ||
325             memcmp(out_master_secret, master_secret,
326                    sizeof(master_secret)) != 0) {
327         fprintf(stderr, "Master secret does not match\n");
328         goto err;
329     }
330
331     if (sizeof(client_ats) != hashsize || sizeof(client_ats_key) != KEYLEN
332             || sizeof(client_ats_iv) != IVLEN) {
333         fprintf(stderr, "Internal test error\n");
334         goto err;
335     }
336
337     if (!test_secret(s, out_master_secret, (unsigned char *)client_ats_label,
338                      strlen(client_ats_label), client_ats, client_ats_key,
339                      client_ats_iv)) {
340         fprintf(stderr, "Client application data secret test failed\n");
341         goto err;
342     }
343
344     if (sizeof(server_ats) != hashsize || sizeof(server_ats_key) != KEYLEN
345             || sizeof(server_ats_iv) != IVLEN) {
346         fprintf(stderr, "Internal test error\n");
347         goto err;
348     }
349
350     if (!test_secret(s, out_master_secret, (unsigned char *)server_ats_label,
351                      strlen(server_ats_label), server_ats, server_ats_key,
352                      server_ats_iv)) {
353         fprintf(stderr, "Server application data secret test failed\n");
354         goto err;
355     }
356
357     ret = 1;
358  err:
359     SSL_free(s);
360     SSL_CTX_free(ctx);
361     return ret;
362 }
363
364 void register_tests()
365 {
366     ADD_TEST(test_handshake_secrets);
367 }