55424b1093b2240dff0aa0522bed47206dbaae0e
[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 int ssl_log_secret(SSL *ssl,
188                    const char *label,
189                    const uint8_t *secret,
190                    size_t secret_len)
191 {
192     return 1;
193 }
194
195 const EVP_MD *ssl_md(int idx)
196 {
197     return EVP_sha256();
198 }
199
200 /* End of mocked out code */
201
202 static int test_secret(SSL *s, unsigned char *prk,
203                        const unsigned char *label, size_t labellen,
204                        const unsigned char *ref_secret,
205                        const unsigned char *ref_key, const unsigned char *ref_iv)
206 {
207     size_t hashsize;
208     unsigned char gensecret[EVP_MAX_MD_SIZE];
209     unsigned char hash[EVP_MAX_MD_SIZE];
210     unsigned char key[KEYLEN];
211     unsigned char iv[IVLEN];
212     const EVP_MD *md = ssl_handshake_md(s);
213
214     if (!ssl_handshake_hash(s, hash, sizeof(hash), &hashsize)) {
215         fprintf(stderr, "Failed to get hash\n");
216         return 0;
217     }
218
219     if (!tls13_hkdf_expand(s, md, prk, label, labellen, hash, gensecret,
220                            hashsize)) {
221         fprintf(stderr, "Secret generation failed\n");
222         return 0;
223     }
224
225     if (memcmp(gensecret, ref_secret, hashsize) != 0) {
226         fprintf(stderr, "Generated secret does not match\n");
227         return 0;
228     }
229
230     if (!tls13_derive_key(s, md, gensecret, key, KEYLEN)) {
231         fprintf(stderr, "Key generation failed\n");
232         return 0;
233     }
234
235     if (memcmp(key, ref_key, KEYLEN) != 0) {
236         fprintf(stderr, "Generated key does not match\n");
237         return 0;
238     }
239
240     if (!tls13_derive_iv(s, md, gensecret, iv, IVLEN)) {
241         fprintf(stderr, "IV generation failed\n");
242         return 0;
243     }
244
245     if (memcmp(iv, ref_iv, IVLEN) != 0) {
246         fprintf(stderr, "Generated IV does not match\n");
247         return 0;
248     }
249
250     return 1;
251 }
252
253 static int test_handshake_secrets(void)
254 {
255     SSL_CTX *ctx = NULL;
256     SSL *s = NULL;
257     int ret = 0;
258     size_t hashsize;
259     unsigned char out_master_secret[EVP_MAX_MD_SIZE];
260     size_t master_secret_length;
261
262     ctx = SSL_CTX_new(TLS_method());
263     if (ctx == NULL)
264         goto err;
265
266     s = SSL_new(ctx);
267     if (s == NULL)
268         goto err;
269
270     s->session = SSL_SESSION_new();
271     if (s->session == NULL)
272         goto err;
273
274     if (!tls13_generate_secret(s, ssl_handshake_md(s), NULL, NULL, 0,
275                                (unsigned char *)&s->early_secret)) {
276         fprintf(stderr, "Early secret generation failed\n");
277         goto err;
278     }
279
280     if (memcmp(s->early_secret, early_secret, sizeof(early_secret)) != 0) {
281         fprintf(stderr, "Early secret does not match\n");
282         goto err;
283     }
284
285     if (!tls13_generate_handshake_secret(s, ecdhe_secret,
286                                          sizeof(ecdhe_secret))) {
287         fprintf(stderr, "Hanshake secret generation failed\n");
288         goto err;
289     }
290
291     if (memcmp(s->handshake_secret, handshake_secret,
292                sizeof(handshake_secret)) != 0) {
293         fprintf(stderr, "Handshake secret does not match\n");
294         goto err;
295     }
296
297     hashsize = EVP_MD_size(ssl_handshake_md(s));
298     if (sizeof(client_hts) != hashsize || sizeof(client_hts_key) != KEYLEN
299             || sizeof(client_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 *)client_hts_label,
305                      strlen(client_hts_label), client_hts, client_hts_key,
306                      client_hts_iv)) {
307         fprintf(stderr, "Client handshake secret test failed\n");
308         goto err;
309     }
310
311     if (sizeof(server_hts) != hashsize || sizeof(server_hts_key) != KEYLEN
312             || sizeof(server_hts_iv) != IVLEN) {
313         fprintf(stderr, "Internal test error\n");
314         goto err;
315     }
316
317     if (!test_secret(s, s->handshake_secret, (unsigned char *)server_hts_label,
318                      strlen(server_hts_label), server_hts, server_hts_key,
319                      server_hts_iv)) {
320         fprintf(stderr, "Server handshake secret test failed\n");
321         goto err;
322     }
323
324     /*
325      * Ensure the mocked out ssl_handshake_hash() returns the full handshake
326      * hash.
327      */
328     full_hash = 1;
329
330     if (!tls13_generate_master_secret(s, out_master_secret,
331                                       s->handshake_secret, hashsize,
332                                       &master_secret_length)) {
333         fprintf(stderr, "Master secret generation failed\n");
334         goto err;
335     }
336
337     if (master_secret_length != sizeof(master_secret) ||
338             memcmp(out_master_secret, master_secret,
339                    sizeof(master_secret)) != 0) {
340         fprintf(stderr, "Master secret does not match\n");
341         goto err;
342     }
343
344     if (sizeof(client_ats) != hashsize || sizeof(client_ats_key) != KEYLEN
345             || sizeof(client_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 *)client_ats_label,
351                      strlen(client_ats_label), client_ats, client_ats_key,
352                      client_ats_iv)) {
353         fprintf(stderr, "Client application data secret test failed\n");
354         goto err;
355     }
356
357     if (sizeof(server_ats) != hashsize || sizeof(server_ats_key) != KEYLEN
358             || sizeof(server_ats_iv) != IVLEN) {
359         fprintf(stderr, "Internal test error\n");
360         goto err;
361     }
362
363     if (!test_secret(s, out_master_secret, (unsigned char *)server_ats_label,
364                      strlen(server_ats_label), server_ats, server_ats_key,
365                      server_ats_iv)) {
366         fprintf(stderr, "Server application data secret test failed\n");
367         goto err;
368     }
369
370     ret = 1;
371  err:
372     SSL_free(s);
373     SSL_CTX_free(ctx);
374     return ret;
375 }
376
377 void register_tests()
378 {
379     ADD_TEST(test_handshake_secrets);
380 }