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