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