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 }