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