| 1 |
/* Copyright (c) 2014, Google Inc. |
| 2 |
* |
| 3 |
* Permission to use, copy, modify, and/or distribute this software for any |
| 4 |
* purpose with or without fee is hereby granted, provided that the above |
| 5 |
* copyright notice and this permission notice appear in all copies. |
| 6 |
* |
| 7 |
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
| 8 |
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
| 9 |
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY |
| 10 |
* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
| 11 |
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION |
| 12 |
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN |
| 13 |
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ |
| 14 |
|
| 15 |
#include <stdio.h> |
| 16 |
#include <string.h> |
| 17 |
#include <time.h> |
| 18 |
|
| 19 |
#include <algorithm> |
| 20 |
#include <string> |
| 21 |
#include <utility> |
| 22 |
#include <vector> |
| 23 |
|
| 24 |
#include <openssl/base64.h> |
| 25 |
#include <openssl/bio.h> |
| 26 |
#include <openssl/crypto.h> |
| 27 |
#include <openssl/err.h> |
| 28 |
#include <openssl/pem.h> |
| 29 |
#include <openssl/ssl.h> |
| 30 |
#include <openssl/x509.h> |
| 31 |
|
| 32 |
#include "test/scoped_types.h" |
| 33 |
#include "../crypto/test/test_util.h" |
| 34 |
|
| 35 |
|
| 36 |
struct ExpectedCipher { |
| 37 |
unsigned long id; |
| 38 |
int in_group_flag; |
| 39 |
}; |
| 40 |
|
| 41 |
struct CipherTest { |
| 42 |
// The rule string to apply. |
| 43 |
const char *rule; |
| 44 |
// The list of expected ciphers, in order. |
| 45 |
std::vector<ExpectedCipher> expected; |
| 46 |
}; |
| 47 |
|
| 48 |
static const CipherTest kCipherTests[] = { |
| 49 |
// Selecting individual ciphers should work. |
| 50 |
{ |
| 51 |
"ECDHE-ECDSA-CHACHA20-POLY1305:" |
| 52 |
"ECDHE-RSA-CHACHA20-POLY1305:" |
| 53 |
"ECDHE-ECDSA-AES128-GCM-SHA256:" |
| 54 |
"ECDHE-RSA-AES128-GCM-SHA256", |
| 55 |
{ |
| 56 |
{TLS1_CK_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256, 0}, |
| 57 |
{TLS1_CK_ECDHE_ECDSA_CHACHA20_POLY1305_OLD, 0}, |
| 58 |
{TLS1_CK_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256, 0}, |
| 59 |
{TLS1_CK_ECDHE_RSA_CHACHA20_POLY1305_OLD, 0}, |
| 60 |
{TLS1_CK_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, 0}, |
| 61 |
{TLS1_CK_ECDHE_RSA_WITH_AES_128_GCM_SHA256, 0}, |
| 62 |
}, |
| 63 |
}, |
| 64 |
// + reorders selected ciphers to the end, keeping their relative order. |
| 65 |
{ |
| 66 |
"ECDHE-ECDSA-CHACHA20-POLY1305:" |
| 67 |
"ECDHE-RSA-CHACHA20-POLY1305:" |
| 68 |
"ECDHE-ECDSA-AES128-GCM-SHA256:" |
| 69 |
"ECDHE-RSA-AES128-GCM-SHA256:" |
| 70 |
"+aRSA", |
| 71 |
{ |
| 72 |
{TLS1_CK_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256, 0}, |
| 73 |
{TLS1_CK_ECDHE_ECDSA_CHACHA20_POLY1305_OLD, 0}, |
| 74 |
{TLS1_CK_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, 0}, |
| 75 |
{TLS1_CK_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256, 0}, |
| 76 |
{TLS1_CK_ECDHE_RSA_CHACHA20_POLY1305_OLD, 0}, |
| 77 |
{TLS1_CK_ECDHE_RSA_WITH_AES_128_GCM_SHA256, 0}, |
| 78 |
}, |
| 79 |
}, |
| 80 |
// ! banishes ciphers from future selections. |
| 81 |
{ |
| 82 |
"!aRSA:" |
| 83 |
"ECDHE-ECDSA-CHACHA20-POLY1305:" |
| 84 |
"ECDHE-RSA-CHACHA20-POLY1305:" |
| 85 |
"ECDHE-ECDSA-AES128-GCM-SHA256:" |
| 86 |
"ECDHE-RSA-AES128-GCM-SHA256", |
| 87 |
{ |
| 88 |
{TLS1_CK_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256, 0}, |
| 89 |
{TLS1_CK_ECDHE_ECDSA_CHACHA20_POLY1305_OLD, 0}, |
| 90 |
{TLS1_CK_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, 0}, |
| 91 |
}, |
| 92 |
}, |
| 93 |
// Multiple masks can be ANDed in a single rule. |
| 94 |
{ |
| 95 |
"kRSA+AESGCM+AES128", |
| 96 |
{ |
| 97 |
{TLS1_CK_RSA_WITH_AES_128_GCM_SHA256, 0}, |
| 98 |
}, |
| 99 |
}, |
| 100 |
// - removes selected ciphers, but preserves their order for future |
| 101 |
// selections. Select AES_128_GCM, but order the key exchanges RSA, DHE_RSA, |
| 102 |
// ECDHE_RSA. |
| 103 |
{ |
| 104 |
"ALL:-kECDHE:-kDHE:-kRSA:-ALL:" |
| 105 |
"AESGCM+AES128+aRSA", |
| 106 |
{ |
| 107 |
{TLS1_CK_RSA_WITH_AES_128_GCM_SHA256, 0}, |
| 108 |
{TLS1_CK_DHE_RSA_WITH_AES_128_GCM_SHA256, 0}, |
| 109 |
{TLS1_CK_ECDHE_RSA_WITH_AES_128_GCM_SHA256, 0}, |
| 110 |
}, |
| 111 |
}, |
| 112 |
// Unknown selectors are no-ops. |
| 113 |
{ |
| 114 |
"ECDHE-ECDSA-CHACHA20-POLY1305:" |
| 115 |
"ECDHE-RSA-CHACHA20-POLY1305:" |
| 116 |
"ECDHE-ECDSA-AES128-GCM-SHA256:" |
| 117 |
"ECDHE-RSA-AES128-GCM-SHA256:" |
| 118 |
"BOGUS1:-BOGUS2:+BOGUS3:!BOGUS4", |
| 119 |
{ |
| 120 |
{TLS1_CK_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256, 0}, |
| 121 |
{TLS1_CK_ECDHE_ECDSA_CHACHA20_POLY1305_OLD, 0}, |
| 122 |
{TLS1_CK_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256, 0}, |
| 123 |
{TLS1_CK_ECDHE_RSA_CHACHA20_POLY1305_OLD, 0}, |
| 124 |
{TLS1_CK_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, 0}, |
| 125 |
{TLS1_CK_ECDHE_RSA_WITH_AES_128_GCM_SHA256, 0}, |
| 126 |
}, |
| 127 |
}, |
| 128 |
// Square brackets specify equi-preference groups. |
| 129 |
{ |
| 130 |
"[ECDHE-ECDSA-CHACHA20-POLY1305|ECDHE-ECDSA-AES128-GCM-SHA256]:" |
| 131 |
"[ECDHE-RSA-CHACHA20-POLY1305]:" |
| 132 |
"ECDHE-RSA-AES128-GCM-SHA256", |
| 133 |
{ |
| 134 |
{TLS1_CK_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256, 1}, |
| 135 |
{TLS1_CK_ECDHE_ECDSA_CHACHA20_POLY1305_OLD, 1}, |
| 136 |
{TLS1_CK_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, 0}, |
| 137 |
{TLS1_CK_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256, 1}, |
| 138 |
{TLS1_CK_ECDHE_RSA_CHACHA20_POLY1305_OLD, 0}, |
| 139 |
{TLS1_CK_ECDHE_RSA_WITH_AES_128_GCM_SHA256, 0}, |
| 140 |
}, |
| 141 |
}, |
| 142 |
// @STRENGTH performs a stable strength-sort of the selected ciphers and |
| 143 |
// only the selected ciphers. |
| 144 |
{ |
| 145 |
// To simplify things, banish all but {ECDHE_RSA,RSA} x |
| 146 |
// {CHACHA20,AES_256_CBC,AES_128_CBC,RC4} x SHA1. |
| 147 |
"!kEDH:!AESGCM:!3DES:!SHA256:!MD5:!SHA384:" |
| 148 |
// Order some ciphers backwards by strength. |
| 149 |
"ALL:-CHACHA20:-AES256:-AES128:-RC4:-ALL:" |
| 150 |
// Select ECDHE ones and sort them by strength. Ties should resolve |
| 151 |
// based on the order above. |
| 152 |
"kECDHE:@STRENGTH:-ALL:" |
| 153 |
// Now bring back everything uses RSA. ECDHE_RSA should be first, sorted |
| 154 |
// by strength. Then RSA, backwards by strength. |
| 155 |
"aRSA", |
| 156 |
{ |
| 157 |
{TLS1_CK_ECDHE_RSA_WITH_AES_256_CBC_SHA, 0}, |
| 158 |
{TLS1_CK_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256, 0}, |
| 159 |
{TLS1_CK_ECDHE_RSA_CHACHA20_POLY1305_OLD, 0}, |
| 160 |
{TLS1_CK_ECDHE_RSA_WITH_RC4_128_SHA, 0}, |
| 161 |
{TLS1_CK_ECDHE_RSA_WITH_AES_128_CBC_SHA, 0}, |
| 162 |
{SSL3_CK_RSA_RC4_128_SHA, 0}, |
| 163 |
{TLS1_CK_RSA_WITH_AES_128_SHA, 0}, |
| 164 |
{TLS1_CK_RSA_WITH_AES_256_SHA, 0}, |
| 165 |
}, |
| 166 |
}, |
| 167 |
// Exact ciphers may not be used in multi-part rules; they are treated |
| 168 |
// as unknown aliases. |
| 169 |
{ |
| 170 |
"ECDHE-ECDSA-AES128-GCM-SHA256:" |
| 171 |
"ECDHE-RSA-AES128-GCM-SHA256:" |
| 172 |
"!ECDHE-RSA-AES128-GCM-SHA256+RSA:" |
| 173 |
"!ECDSA+ECDHE-ECDSA-AES128-GCM-SHA256", |
| 174 |
{ |
| 175 |
{TLS1_CK_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, 0}, |
| 176 |
{TLS1_CK_ECDHE_RSA_WITH_AES_128_GCM_SHA256, 0}, |
| 177 |
}, |
| 178 |
}, |
| 179 |
// SSLv3 matches everything that existed before TLS 1.2. |
| 180 |
{ |
| 181 |
"AES128-SHA:AES128-SHA256:!SSLv3", |
| 182 |
{ |
| 183 |
{TLS1_CK_RSA_WITH_AES_128_SHA256, 0}, |
| 184 |
}, |
| 185 |
}, |
| 186 |
// TLSv1.2 matches everything added in TLS 1.2. |
| 187 |
{ |
| 188 |
"AES128-SHA:AES128-SHA256:!TLSv1.2", |
| 189 |
{ |
| 190 |
{TLS1_CK_RSA_WITH_AES_128_SHA, 0}, |
| 191 |
}, |
| 192 |
}, |
| 193 |
// The two directives have no intersection. |
| 194 |
{ |
| 195 |
"AES128-SHA:AES128-SHA256:!TLSv1.2+SSLv3", |
| 196 |
{ |
| 197 |
{TLS1_CK_RSA_WITH_AES_128_SHA, 0}, |
| 198 |
{TLS1_CK_RSA_WITH_AES_128_SHA256, 0}, |
| 199 |
}, |
| 200 |
}, |
| 201 |
// The shared name of the CHACHA20_POLY1305 variants behaves like a cipher |
| 202 |
// name and not an alias. It may not be used in a multipart rule. (That the |
| 203 |
// shared name works is covered by the standard tests.) |
| 204 |
{ |
| 205 |
"ECDHE-ECDSA-CHACHA20-POLY1305:" |
| 206 |
"ECDHE-RSA-CHACHA20-POLY1305:" |
| 207 |
"!ECDHE-RSA-CHACHA20-POLY1305+RSA:" |
| 208 |
"!ECDSA+ECDHE-ECDSA-CHACHA20-POLY1305", |
| 209 |
{ |
| 210 |
{TLS1_CK_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256, 0}, |
| 211 |
{TLS1_CK_ECDHE_ECDSA_CHACHA20_POLY1305_OLD, 0}, |
| 212 |
{TLS1_CK_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256, 0}, |
| 213 |
{TLS1_CK_ECDHE_RSA_CHACHA20_POLY1305_OLD, 0}, |
| 214 |
}, |
| 215 |
}, |
| 216 |
}; |
| 217 |
|
| 218 |
static const char *kBadRules[] = { |
| 219 |
// Invalid brackets. |
| 220 |
"[ECDHE-RSA-CHACHA20-POLY1305|ECDHE-RSA-AES128-GCM-SHA256", |
| 221 |
"RSA]", |
| 222 |
"[[RSA]]", |
| 223 |
// Operators inside brackets. |
| 224 |
"[+RSA]", |
| 225 |
// Unknown directive. |
| 226 |
"@BOGUS", |
| 227 |
// Empty cipher lists error at SSL_CTX_set_cipher_list. |
| 228 |
"", |
| 229 |
"BOGUS", |
| 230 |
// COMPLEMENTOFDEFAULT is empty. |
| 231 |
"COMPLEMENTOFDEFAULT", |
| 232 |
// Invalid command. |
| 233 |
"?BAR", |
| 234 |
// Special operators are not allowed if groups are used. |
| 235 |
"[ECDHE-RSA-CHACHA20-POLY1305|ECDHE-RSA-AES128-GCM-SHA256]:+FOO", |
| 236 |
"[ECDHE-RSA-CHACHA20-POLY1305|ECDHE-RSA-AES128-GCM-SHA256]:!FOO", |
| 237 |
"[ECDHE-RSA-CHACHA20-POLY1305|ECDHE-RSA-AES128-GCM-SHA256]:-FOO", |
| 238 |
"[ECDHE-RSA-CHACHA20-POLY1305|ECDHE-RSA-AES128-GCM-SHA256]:@STRENGTH", |
| 239 |
}; |
| 240 |
|
| 241 |
static const char *kMustNotIncludeNull[] = { |
| 242 |
"ALL", |
| 243 |
"DEFAULT", |
| 244 |
"ALL:!eNULL", |
| 245 |
"ALL:!NULL", |
| 246 |
"MEDIUM", |
| 247 |
"HIGH", |
| 248 |
"FIPS", |
| 249 |
"SHA", |
| 250 |
"SHA1", |
| 251 |
"RSA", |
| 252 |
"SSLv3", |
| 253 |
"TLSv1", |
| 254 |
"TLSv1.2", |
| 255 |
}; |
| 256 |
|
| 257 |
static const char *kMustNotIncludeCECPQ1[] = { |
| 258 |
"ALL", |
| 259 |
"DEFAULT", |
| 260 |
"MEDIUM", |
| 261 |
"HIGH", |
| 262 |
"FIPS", |
| 263 |
"SHA", |
| 264 |
"SHA1", |
| 265 |
"SHA256", |
| 266 |
"SHA384", |
| 267 |
"RSA", |
| 268 |
"SSLv3", |
| 269 |
"TLSv1", |
| 270 |
"TLSv1.2", |
| 271 |
"aRSA", |
| 272 |
"RSA", |
| 273 |
"aECDSA", |
| 274 |
"ECDSA", |
| 275 |
"AES", |
| 276 |
"AES128", |
| 277 |
"AES256", |
| 278 |
"AESGCM", |
| 279 |
"CHACHA20", |
| 280 |
}; |
| 281 |
|
| 282 |
static void PrintCipherPreferenceList(ssl_cipher_preference_list_st *list) { |
| 283 |
bool in_group = false; |
| 284 |
for (size_t i = 0; i < sk_SSL_CIPHER_num(list->ciphers); i++) { |
| 285 |
const SSL_CIPHER *cipher = sk_SSL_CIPHER_value(list->ciphers, i); |
| 286 |
if (!in_group && list->in_group_flags[i]) { |
| 287 |
fprintf(stderr, "\t[\n"); |
| 288 |
in_group = true; |
| 289 |
} |
| 290 |
fprintf(stderr, "\t"); |
| 291 |
if (in_group) { |
| 292 |
fprintf(stderr, " "); |
| 293 |
} |
| 294 |
fprintf(stderr, "%s\n", SSL_CIPHER_get_name(cipher)); |
| 295 |
if (in_group && !list->in_group_flags[i]) { |
| 296 |
fprintf(stderr, "\t]\n"); |
| 297 |
in_group = false; |
| 298 |
} |
| 299 |
} |
| 300 |
} |
| 301 |
|
| 302 |
static bool TestCipherRule(const CipherTest &t) { |
| 303 |
ScopedSSL_CTX ctx(SSL_CTX_new(TLS_method())); |
| 304 |
if (!ctx) { |
| 305 |
return false; |
| 306 |
} |
| 307 |
|
| 308 |
if (!SSL_CTX_set_cipher_list(ctx.get(), t.rule)) { |
| 309 |
fprintf(stderr, "Error testing cipher rule '%s'\n", t.rule); |
| 310 |
return false; |
| 311 |
} |
| 312 |
|
| 313 |
// Compare the two lists. |
| 314 |
if (sk_SSL_CIPHER_num(ctx->cipher_list->ciphers) != t.expected.size()) { |
| 315 |
fprintf(stderr, "Error: cipher rule '%s' evaluated to:\n", t.rule); |
| 316 |
PrintCipherPreferenceList(ctx->cipher_list); |
| 317 |
return false; |
| 318 |
} |
| 319 |
|
| 320 |
for (size_t i = 0; i < t.expected.size(); i++) { |
| 321 |
const SSL_CIPHER *cipher = |
| 322 |
sk_SSL_CIPHER_value(ctx->cipher_list->ciphers, i); |
| 323 |
if (t.expected[i].id != SSL_CIPHER_get_id(cipher) || |
| 324 |
t.expected[i].in_group_flag != ctx->cipher_list->in_group_flags[i]) { |
| 325 |
fprintf(stderr, "Error: cipher rule '%s' evaluated to:\n", t.rule); |
| 326 |
PrintCipherPreferenceList(ctx->cipher_list); |
| 327 |
return false; |
| 328 |
} |
| 329 |
} |
| 330 |
|
| 331 |
return true; |
| 332 |
} |
| 333 |
|
| 334 |
static bool TestRuleDoesNotIncludeNull(const char *rule) { |
| 335 |
ScopedSSL_CTX ctx(SSL_CTX_new(SSLv23_server_method())); |
| 336 |
if (!ctx) { |
| 337 |
return false; |
| 338 |
} |
| 339 |
if (!SSL_CTX_set_cipher_list(ctx.get(), rule)) { |
| 340 |
fprintf(stderr, "Error: cipher rule '%s' failed\n", rule); |
| 341 |
return false; |
| 342 |
} |
| 343 |
for (size_t i = 0; i < sk_SSL_CIPHER_num(ctx->cipher_list->ciphers); i++) { |
| 344 |
if (SSL_CIPHER_is_NULL(sk_SSL_CIPHER_value(ctx->cipher_list->ciphers, i))) { |
| 345 |
fprintf(stderr, "Error: cipher rule '%s' includes NULL\n",rule); |
| 346 |
return false; |
| 347 |
} |
| 348 |
} |
| 349 |
return true; |
| 350 |
} |
| 351 |
|
| 352 |
static bool TestRuleDoesNotIncludeCECPQ1(const char *rule) { |
| 353 |
ScopedSSL_CTX ctx(SSL_CTX_new(TLS_method())); |
| 354 |
if (!ctx) { |
| 355 |
return false; |
| 356 |
} |
| 357 |
if (!SSL_CTX_set_cipher_list(ctx.get(), rule)) { |
| 358 |
fprintf(stderr, "Error: cipher rule '%s' failed\n", rule); |
| 359 |
return false; |
| 360 |
} |
| 361 |
for (size_t i = 0; i < sk_SSL_CIPHER_num(ctx->cipher_list->ciphers); i++) { |
| 362 |
if (SSL_CIPHER_is_CECPQ1(sk_SSL_CIPHER_value(ctx->cipher_list->ciphers, i))) { |
| 363 |
fprintf(stderr, "Error: cipher rule '%s' includes CECPQ1\n",rule); |
| 364 |
return false; |
| 365 |
} |
| 366 |
} |
| 367 |
return true; |
| 368 |
} |
| 369 |
|
| 370 |
static bool TestCipherRules() { |
| 371 |
for (const CipherTest &test : kCipherTests) { |
| 372 |
if (!TestCipherRule(test)) { |
| 373 |
return false; |
| 374 |
} |
| 375 |
} |
| 376 |
|
| 377 |
for (const char *rule : kBadRules) { |
| 378 |
ScopedSSL_CTX ctx(SSL_CTX_new(SSLv23_server_method())); |
| 379 |
if (!ctx) { |
| 380 |
return false; |
| 381 |
} |
| 382 |
if (SSL_CTX_set_cipher_list(ctx.get(), rule)) { |
| 383 |
fprintf(stderr, "Cipher rule '%s' unexpectedly succeeded\n", rule); |
| 384 |
return false; |
| 385 |
} |
| 386 |
ERR_clear_error(); |
| 387 |
} |
| 388 |
|
| 389 |
for (const char *rule : kMustNotIncludeNull) { |
| 390 |
if (!TestRuleDoesNotIncludeNull(rule)) { |
| 391 |
return false; |
| 392 |
} |
| 393 |
} |
| 394 |
|
| 395 |
for (const char *rule : kMustNotIncludeCECPQ1) { |
| 396 |
if (!TestRuleDoesNotIncludeCECPQ1(rule)) { |
| 397 |
return false; |
| 398 |
} |
| 399 |
} |
| 400 |
|
| 401 |
return true; |
| 402 |
} |
| 403 |
|
| 404 |
// kOpenSSLSession is a serialized SSL_SESSION generated from openssl |
| 405 |
// s_client -sess_out. |
| 406 |
static const char kOpenSSLSession[] = |
| 407 |
"MIIFpQIBAQICAwMEAsAvBCAG5Q1ndq4Yfmbeo1zwLkNRKmCXGdNgWvGT3cskV0yQ" |
| 408 |
"kAQwJlrlzkAWBOWiLj/jJ76D7l+UXoizP2KI2C7I2FccqMmIfFmmkUy32nIJ0mZH" |
| 409 |
"IWoJoQYCBFRDO46iBAICASyjggR6MIIEdjCCA16gAwIBAgIIK9dUvsPWSlUwDQYJ" |
| 410 |
"KoZIhvcNAQEFBQAwSTELMAkGA1UEBhMCVVMxEzARBgNVBAoTCkdvb2dsZSBJbmMx" |
| 411 |
"JTAjBgNVBAMTHEdvb2dsZSBJbnRlcm5ldCBBdXRob3JpdHkgRzIwHhcNMTQxMDA4" |
| 412 |
"MTIwNzU3WhcNMTUwMTA2MDAwMDAwWjBoMQswCQYDVQQGEwJVUzETMBEGA1UECAwK" |
| 413 |
"Q2FsaWZvcm5pYTEWMBQGA1UEBwwNTW91bnRhaW4gVmlldzETMBEGA1UECgwKR29v" |
| 414 |
"Z2xlIEluYzEXMBUGA1UEAwwOd3d3Lmdvb2dsZS5jb20wggEiMA0GCSqGSIb3DQEB" |
| 415 |
"AQUAA4IBDwAwggEKAoIBAQCcKeLrplAC+Lofy8t/wDwtB6eu72CVp0cJ4V3lknN6" |
| 416 |
"huH9ct6FFk70oRIh/VBNBBz900jYy+7111Jm1b8iqOTQ9aT5C7SEhNcQFJvqzH3e" |
| 417 |
"MPkb6ZSWGm1yGF7MCQTGQXF20Sk/O16FSjAynU/b3oJmOctcycWYkY0ytS/k3LBu" |
| 418 |
"Id45PJaoMqjB0WypqvNeJHC3q5JjCB4RP7Nfx5jjHSrCMhw8lUMW4EaDxjaR9KDh" |
| 419 |
"PLgjsk+LDIySRSRDaCQGhEOWLJZVLzLo4N6/UlctCHEllpBUSvEOyFga52qroGjg" |
| 420 |
"rf3WOQ925MFwzd6AK+Ich0gDRg8sQfdLH5OuP1cfLfU1AgMBAAGjggFBMIIBPTAd" |
| 421 |
"BgNVHSUEFjAUBggrBgEFBQcDAQYIKwYBBQUHAwIwGQYDVR0RBBIwEIIOd3d3Lmdv" |
| 422 |
"b2dsZS5jb20waAYIKwYBBQUHAQEEXDBaMCsGCCsGAQUFBzAChh9odHRwOi8vcGtp" |
| 423 |
"Lmdvb2dsZS5jb20vR0lBRzIuY3J0MCsGCCsGAQUFBzABhh9odHRwOi8vY2xpZW50" |
| 424 |
"czEuZ29vZ2xlLmNvbS9vY3NwMB0GA1UdDgQWBBQ7a+CcxsZByOpc+xpYFcIbnUMZ" |
| 425 |
"hTAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFErdBhYbvPZotXb1gba7Yhq6WoEv" |
| 426 |
"MBcGA1UdIAQQMA4wDAYKKwYBBAHWeQIFATAwBgNVHR8EKTAnMCWgI6Ahhh9odHRw" |
| 427 |
"Oi8vcGtpLmdvb2dsZS5jb20vR0lBRzIuY3JsMA0GCSqGSIb3DQEBBQUAA4IBAQCa" |
| 428 |
"OXCBdoqUy5bxyq+Wrh1zsyyCFim1PH5VU2+yvDSWrgDY8ibRGJmfff3r4Lud5kal" |
| 429 |
"dKs9k8YlKD3ITG7P0YT/Rk8hLgfEuLcq5cc0xqmE42xJ+Eo2uzq9rYorc5emMCxf" |
| 430 |
"5L0TJOXZqHQpOEcuptZQ4OjdYMfSxk5UzueUhA3ogZKRcRkdB3WeWRp+nYRhx4St" |
| 431 |
"o2rt2A0MKmY9165GHUqMK9YaaXHDXqBu7Sefr1uSoAP9gyIJKeihMivsGqJ1TD6Z" |
| 432 |
"cc6LMe+dN2P8cZEQHtD1y296ul4Mivqk3jatUVL8/hCwgch9A8O4PGZq9WqBfEWm" |
| 433 |
"IyHh1dPtbg1lOXdYCWtjpAIEAKUDAgEUqQUCAwGJwKqBpwSBpBwUQvoeOk0Kg36S" |
| 434 |
"YTcLEkXqKwOBfF9vE4KX0NxeLwjcDTpsuh3qXEaZ992r1N38VDcyS6P7I6HBYN9B" |
| 435 |
"sNHM362zZnY27GpTw+Kwd751CLoXFPoaMOe57dbBpXoro6Pd3BTbf/Tzr88K06yE" |
| 436 |
"OTDKPNj3+inbMaVigtK4PLyPq+Topyzvx9USFgRvyuoxn0Hgb+R0A3j6SLRuyOdA" |
| 437 |
"i4gv7Y5oliyn"; |
| 438 |
|
| 439 |
// kCustomSession is a custom serialized SSL_SESSION generated by |
| 440 |
// filling in missing fields from |kOpenSSLSession|. This includes |
| 441 |
// providing |peer_sha256|, so |peer| is not serialized. |
| 442 |
static const char kCustomSession[] = |
| 443 |
"MIIBdgIBAQICAwMEAsAvBCAG5Q1ndq4Yfmbeo1zwLkNRKmCXGdNgWvGT3cskV0yQ" |
| 444 |
"kAQwJlrlzkAWBOWiLj/jJ76D7l+UXoizP2KI2C7I2FccqMmIfFmmkUy32nIJ0mZH" |
| 445 |
"IWoJoQYCBFRDO46iBAICASykAwQBAqUDAgEUphAEDnd3dy5nb29nbGUuY29tqAcE" |
| 446 |
"BXdvcmxkqQUCAwGJwKqBpwSBpBwUQvoeOk0Kg36SYTcLEkXqKwOBfF9vE4KX0Nxe" |
| 447 |
"LwjcDTpsuh3qXEaZ992r1N38VDcyS6P7I6HBYN9BsNHM362zZnY27GpTw+Kwd751" |
| 448 |
"CLoXFPoaMOe57dbBpXoro6Pd3BTbf/Tzr88K06yEOTDKPNj3+inbMaVigtK4PLyP" |
| 449 |
"q+Topyzvx9USFgRvyuoxn0Hgb+R0A3j6SLRuyOdAi4gv7Y5oliynrSIEIAYGBgYG" |
| 450 |
"BgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGrgMEAQevAwQBBLADBAEF"; |
| 451 |
|
| 452 |
// kBoringSSLSession is a serialized SSL_SESSION generated from bssl client. |
| 453 |
static const char kBoringSSLSession[] = |
| 454 |
"MIIRwQIBAQICAwMEAsAvBCDdoGxGK26mR+8lM0uq6+k9xYuxPnwAjpcF9n0Yli9R" |
| 455 |
"kQQwbyshfWhdi5XQ1++7n2L1qqrcVlmHBPpr6yknT/u4pUrpQB5FZ7vqvNn8MdHf" |
| 456 |
"9rWgoQYCBFXgs7uiBAICHCCjggR6MIIEdjCCA16gAwIBAgIIf+yfD7Y6UicwDQYJ" |
| 457 |
"KoZIhvcNAQELBQAwSTELMAkGA1UEBhMCVVMxEzARBgNVBAoTCkdvb2dsZSBJbmMx" |
| 458 |
"JTAjBgNVBAMTHEdvb2dsZSBJbnRlcm5ldCBBdXRob3JpdHkgRzIwHhcNMTUwODEy" |
| 459 |
"MTQ1MzE1WhcNMTUxMTEwMDAwMDAwWjBoMQswCQYDVQQGEwJVUzETMBEGA1UECAwK" |
| 460 |
"Q2FsaWZvcm5pYTEWMBQGA1UEBwwNTW91bnRhaW4gVmlldzETMBEGA1UECgwKR29v" |
| 461 |
"Z2xlIEluYzEXMBUGA1UEAwwOd3d3Lmdvb2dsZS5jb20wggEiMA0GCSqGSIb3DQEB" |
| 462 |
"AQUAA4IBDwAwggEKAoIBAQC0MeG5YGQ0t+IeJeoneP/PrhEaieibeKYkbKVLNZpo" |
| 463 |
"PLuBinvhkXZo3DC133NpCBpy6ZktBwamqyixAyuk/NU6OjgXqwwxfQ7di1AInLIU" |
| 464 |
"792c7hFyNXSUCG7At8Ifi3YwBX9Ba6u/1d6rWTGZJrdCq3QU11RkKYyTq2KT5mce" |
| 465 |
"Tv9iGKqSkSTlp8puy/9SZ/3DbU3U+BuqCFqeSlz7zjwFmk35acdCilpJlVDDN5C/" |
| 466 |
"RCh8/UKc8PaL+cxlt531qoTENvYrflBno14YEZlCBZsPiFeUSILpKEj3Ccwhy0eL" |
| 467 |
"EucWQ72YZU8mUzXBoXGn0zA0crFl5ci/2sTBBGZsylNBAgMBAAGjggFBMIIBPTAd" |
| 468 |
"BgNVHSUEFjAUBggrBgEFBQcDAQYIKwYBBQUHAwIwGQYDVR0RBBIwEIIOd3d3Lmdv" |
| 469 |
"b2dsZS5jb20waAYIKwYBBQUHAQEEXDBaMCsGCCsGAQUFBzAChh9odHRwOi8vcGtp" |
| 470 |
"Lmdvb2dsZS5jb20vR0lBRzIuY3J0MCsGCCsGAQUFBzABhh9odHRwOi8vY2xpZW50" |
| 471 |
"czEuZ29vZ2xlLmNvbS9vY3NwMB0GA1UdDgQWBBS/bzHxcE73Q4j3slC4BLbMtLjG" |
| 472 |
"GjAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFErdBhYbvPZotXb1gba7Yhq6WoEv" |
| 473 |
"MBcGA1UdIAQQMA4wDAYKKwYBBAHWeQIFATAwBgNVHR8EKTAnMCWgI6Ahhh9odHRw" |
| 474 |
"Oi8vcGtpLmdvb2dsZS5jb20vR0lBRzIuY3JsMA0GCSqGSIb3DQEBCwUAA4IBAQAb" |
| 475 |
"qdWPZEHk0X7iKPCTHL6S3w6q1eR67goxZGFSM1lk1hjwyu7XcLJuvALVV9uY3ovE" |
| 476 |
"kQZSHwT+pyOPWQhsSjO+1GyjvCvK/CAwiUmBX+bQRGaqHsRcio7xSbdVcajQ3bXd" |
| 477 |
"X+s0WdbOpn6MStKAiBVloPlSxEI8pxY6x/BBCnTIk/+DMB17uZlOjG3vbAnkDkP+" |
| 478 |
"n0OTucD9sHV7EVj9XUxi51nOfNBCN/s7lpUjDS/NJ4k3iwOtbCPswiot8vLO779a" |
| 479 |
"f07vR03r349Iz/KTzk95rlFtX0IU+KYNxFNsanIXZ+C9FYGRXkwhHcvFb4qMUB1y" |
| 480 |
"TTlM80jBMOwyjZXmjRAhpAIEAKUDAgEUqQUCAwGJwKqBpwSBpOgebbmn9NRUtMWH" |
| 481 |
"+eJpqA5JLMFSMCChOsvKey3toBaCNGU7HfAEiiXNuuAdCBoK262BjQc2YYfqFzqH" |
| 482 |
"zuppopXCvhohx7j/tnCNZIMgLYt/O9SXK2RYI5z8FhCCHvB4CbD5G0LGl5EFP27s" |
| 483 |
"Jb6S3aTTYPkQe8yZSlxevg6NDwmTogLO9F7UUkaYmVcMQhzssEE2ZRYNwSOU6KjE" |
| 484 |
"0Yj+8fAiBtbQriIEIN2L8ZlpaVrdN5KFNdvcmOxJu81P8q53X55xQyGTnGWwsgMC" |
| 485 |
"ARezggvvMIIEdjCCA16gAwIBAgIIf+yfD7Y6UicwDQYJKoZIhvcNAQELBQAwSTEL" |
| 486 |
"MAkGA1UEBhMCVVMxEzARBgNVBAoTCkdvb2dsZSBJbmMxJTAjBgNVBAMTHEdvb2ds" |
| 487 |
"ZSBJbnRlcm5ldCBBdXRob3JpdHkgRzIwHhcNMTUwODEyMTQ1MzE1WhcNMTUxMTEw" |
| 488 |
"MDAwMDAwWjBoMQswCQYDVQQGEwJVUzETMBEGA1UECAwKQ2FsaWZvcm5pYTEWMBQG" |
| 489 |
"A1UEBwwNTW91bnRhaW4gVmlldzETMBEGA1UECgwKR29vZ2xlIEluYzEXMBUGA1UE" |
| 490 |
"AwwOd3d3Lmdvb2dsZS5jb20wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIB" |
| 491 |
"AQC0MeG5YGQ0t+IeJeoneP/PrhEaieibeKYkbKVLNZpoPLuBinvhkXZo3DC133Np" |
| 492 |
"CBpy6ZktBwamqyixAyuk/NU6OjgXqwwxfQ7di1AInLIU792c7hFyNXSUCG7At8If" |
| 493 |
"i3YwBX9Ba6u/1d6rWTGZJrdCq3QU11RkKYyTq2KT5mceTv9iGKqSkSTlp8puy/9S" |
| 494 |
"Z/3DbU3U+BuqCFqeSlz7zjwFmk35acdCilpJlVDDN5C/RCh8/UKc8PaL+cxlt531" |
| 495 |
"qoTENvYrflBno14YEZlCBZsPiFeUSILpKEj3Ccwhy0eLEucWQ72YZU8mUzXBoXGn" |
| 496 |
"0zA0crFl5ci/2sTBBGZsylNBAgMBAAGjggFBMIIBPTAdBgNVHSUEFjAUBggrBgEF" |
| 497 |
"BQcDAQYIKwYBBQUHAwIwGQYDVR0RBBIwEIIOd3d3Lmdvb2dsZS5jb20waAYIKwYB" |
| 498 |
"BQUHAQEEXDBaMCsGCCsGAQUFBzAChh9odHRwOi8vcGtpLmdvb2dsZS5jb20vR0lB" |
| 499 |
"RzIuY3J0MCsGCCsGAQUFBzABhh9odHRwOi8vY2xpZW50czEuZ29vZ2xlLmNvbS9v" |
| 500 |
"Y3NwMB0GA1UdDgQWBBS/bzHxcE73Q4j3slC4BLbMtLjGGjAMBgNVHRMBAf8EAjAA" |
| 501 |
"MB8GA1UdIwQYMBaAFErdBhYbvPZotXb1gba7Yhq6WoEvMBcGA1UdIAQQMA4wDAYK" |
| 502 |
"KwYBBAHWeQIFATAwBgNVHR8EKTAnMCWgI6Ahhh9odHRwOi8vcGtpLmdvb2dsZS5j" |
| 503 |
"b20vR0lBRzIuY3JsMA0GCSqGSIb3DQEBCwUAA4IBAQAbqdWPZEHk0X7iKPCTHL6S" |
| 504 |
"3w6q1eR67goxZGFSM1lk1hjwyu7XcLJuvALVV9uY3ovEkQZSHwT+pyOPWQhsSjO+" |
| 505 |
"1GyjvCvK/CAwiUmBX+bQRGaqHsRcio7xSbdVcajQ3bXdX+s0WdbOpn6MStKAiBVl" |
| 506 |
"oPlSxEI8pxY6x/BBCnTIk/+DMB17uZlOjG3vbAnkDkP+n0OTucD9sHV7EVj9XUxi" |
| 507 |
"51nOfNBCN/s7lpUjDS/NJ4k3iwOtbCPswiot8vLO779af07vR03r349Iz/KTzk95" |
| 508 |
"rlFtX0IU+KYNxFNsanIXZ+C9FYGRXkwhHcvFb4qMUB1yTTlM80jBMOwyjZXmjRAh" |
| 509 |
"MIID8DCCAtigAwIBAgIDAjqDMA0GCSqGSIb3DQEBCwUAMEIxCzAJBgNVBAYTAlVT" |
| 510 |
"MRYwFAYDVQQKEw1HZW9UcnVzdCBJbmMuMRswGQYDVQQDExJHZW9UcnVzdCBHbG9i" |
| 511 |
"YWwgQ0EwHhcNMTMwNDA1MTUxNTU2WhcNMTYxMjMxMjM1OTU5WjBJMQswCQYDVQQG" |
| 512 |
"EwJVUzETMBEGA1UEChMKR29vZ2xlIEluYzElMCMGA1UEAxMcR29vZ2xlIEludGVy" |
| 513 |
"bmV0IEF1dGhvcml0eSBHMjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB" |
| 514 |
"AJwqBHdc2FCROgajguDYUEi8iT/xGXAaiEZ+4I/F8YnOIe5a/mENtzJEiaB0C1NP" |
| 515 |
"VaTOgmKV7utZX8bhBYASxF6UP7xbSDj0U/ck5vuR6RXEz/RTDfRK/J9U3n2+oGtv" |
| 516 |
"h8DQUB8oMANA2ghzUWx//zo8pzcGjr1LEQTrfSTe5vn8MXH7lNVg8y5Kr0LSy+rE" |
| 517 |
"ahqyzFPdFUuLH8gZYR/Nnag+YyuENWllhMgZxUYi+FOVvuOAShDGKuy6lyARxzmZ" |
| 518 |
"EASg8GF6lSWMTlJ14rbtCMoU/M4iarNOz0YDl5cDfsCx3nuvRTPPuj5xt970JSXC" |
| 519 |
"DTWJnZ37DhF5iR43xa+OcmkCAwEAAaOB5zCB5DAfBgNVHSMEGDAWgBTAephojYn7" |
| 520 |
"qwVkDBF9qn1luMrMTjAdBgNVHQ4EFgQUSt0GFhu89mi1dvWBtrtiGrpagS8wDgYD" |
| 521 |
"VR0PAQH/BAQDAgEGMC4GCCsGAQUFBwEBBCIwIDAeBggrBgEFBQcwAYYSaHR0cDov" |
| 522 |
"L2cuc3ltY2QuY29tMBIGA1UdEwEB/wQIMAYBAf8CAQAwNQYDVR0fBC4wLDAqoCig" |
| 523 |
"JoYkaHR0cDovL2cuc3ltY2IuY29tL2NybHMvZ3RnbG9iYWwuY3JsMBcGA1UdIAQQ" |
| 524 |
"MA4wDAYKKwYBBAHWeQIFATANBgkqhkiG9w0BAQsFAAOCAQEAqvqpIM1qZ4PtXtR+" |
| 525 |
"3h3Ef+AlBgDFJPupyC1tft6dgmUsgWM0Zj7pUsIItMsv91+ZOmqcUHqFBYx90SpI" |
| 526 |
"hNMJbHzCzTWf84LuUt5oX+QAihcglvcpjZpNy6jehsgNb1aHA30DP9z6eX0hGfnI" |
| 527 |
"Oi9RdozHQZJxjyXON/hKTAAj78Q1EK7gI4BzfE00LshukNYQHpmEcxpw8u1VDu4X" |
| 528 |
"Bupn7jLrLN1nBz/2i8Jw3lsA5rsb0zYaImxssDVCbJAJPZPpZAkiDoUGn8JzIdPm" |
| 529 |
"X4DkjYUiOnMDsWCOrmji9D6X52ASCWg23jrW4kOVWzeBkoEfu43XrVJkFleW2V40" |
| 530 |
"fsg12DCCA30wggLmoAMCAQICAxK75jANBgkqhkiG9w0BAQUFADBOMQswCQYDVQQG" |
| 531 |
"EwJVUzEQMA4GA1UEChMHRXF1aWZheDEtMCsGA1UECxMkRXF1aWZheCBTZWN1cmUg" |
| 532 |
"Q2VydGlmaWNhdGUgQXV0aG9yaXR5MB4XDTAyMDUyMTA0MDAwMFoXDTE4MDgyMTA0" |
| 533 |
"MDAwMFowQjELMAkGA1UEBhMCVVMxFjAUBgNVBAoTDUdlb1RydXN0IEluYy4xGzAZ" |
| 534 |
"BgNVBAMTEkdlb1RydXN0IEdsb2JhbCBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEP" |
| 535 |
"ADCCAQoCggEBANrMGGMw/fQXIxpWflvfPGw45HG3eJHUvKHYTPioQ7YD6U0hBwiI" |
| 536 |
"2lgvZjkpvQV4i5046AW3an5xpObEYKaw74DkiSgPniXW7YPzraaRx5jJQhg1FJ2t" |
| 537 |
"mEaSLk/K8YdDwRaVVy1Q74ktgHpXrfLuX2vSAI25FPgUFTXZwEaje3LIkb/JVSvN" |
| 538 |
"0Jc+nCZkzN/Ogxlxyk7m1NV7qRnNVd7I7NJeOFPlXE+MLf5QIzb8ZubLjqQ5GQC3" |
| 539 |
"lQI5kQsO/jgu0R0FmvZNPm8PBx2vLB6PYDni+jZTEznUXiYr2z2oFL0y6xgDKFIE" |
| 540 |
"ceWrMz3hOLsHNoRinHnqFjD0X8Ar6HFr5PkCAwEAAaOB8DCB7TAfBgNVHSMEGDAW" |
| 541 |
"gBRI5mj5K9KylddH2CMgEE8zmJCf1DAdBgNVHQ4EFgQUwHqYaI2J+6sFZAwRfap9" |
| 542 |
"ZbjKzE4wDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwOgYDVR0fBDMw" |
| 543 |
"MTAvoC2gK4YpaHR0cDovL2NybC5nZW90cnVzdC5jb20vY3Jscy9zZWN1cmVjYS5j" |
| 544 |
"cmwwTgYDVR0gBEcwRTBDBgRVHSAAMDswOQYIKwYBBQUHAgEWLWh0dHBzOi8vd3d3" |
| 545 |
"Lmdlb3RydXN0LmNvbS9yZXNvdXJjZXMvcmVwb3NpdG9yeTANBgkqhkiG9w0BAQUF" |
| 546 |
"AAOBgQB24RJuTksWEoYwBrKBCM/wCMfHcX5m7sLt1Dsf//DwyE7WQziwuTB9GNBV" |
| 547 |
"g6JqyzYRnOhIZqNtf7gT1Ef+i1pcc/yu2RsyGTirlzQUqpbS66McFAhJtrvlke+D" |
| 548 |
"NusdVm/K2rxzY5Dkf3s+Iss9B+1fOHSc4wNQTqGvmO5h8oQ/Eg=="; |
| 549 |
|
| 550 |
// kBadSessionExtraField is a custom serialized SSL_SESSION generated by replacing |
| 551 |
// the final (optional) element of |kCustomSession| with tag number 30. |
| 552 |
static const char kBadSessionExtraField[] = |
| 553 |
"MIIBdgIBAQICAwMEAsAvBCAG5Q1ndq4Yfmbeo1zwLkNRKmCXGdNgWvGT3cskV0yQ" |
| 554 |
"kAQwJlrlzkAWBOWiLj/jJ76D7l+UXoizP2KI2C7I2FccqMmIfFmmkUy32nIJ0mZH" |
| 555 |
"IWoJoQYCBFRDO46iBAICASykAwQBAqUDAgEUphAEDnd3dy5nb29nbGUuY29tqAcE" |
| 556 |
"BXdvcmxkqQUCAwGJwKqBpwSBpBwUQvoeOk0Kg36SYTcLEkXqKwOBfF9vE4KX0Nxe" |
| 557 |
"LwjcDTpsuh3qXEaZ992r1N38VDcyS6P7I6HBYN9BsNHM362zZnY27GpTw+Kwd751" |
| 558 |
"CLoXFPoaMOe57dbBpXoro6Pd3BTbf/Tzr88K06yEOTDKPNj3+inbMaVigtK4PLyP" |
| 559 |
"q+Topyzvx9USFgRvyuoxn0Hgb+R0A3j6SLRuyOdAi4gv7Y5oliynrSIEIAYGBgYG" |
| 560 |
"BgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGrgMEAQevAwQBBL4DBAEF"; |
| 561 |
|
| 562 |
// kBadSessionVersion is a custom serialized SSL_SESSION generated by replacing |
| 563 |
// the version of |kCustomSession| with 2. |
| 564 |
static const char kBadSessionVersion[] = |
| 565 |
"MIIBdgIBAgICAwMEAsAvBCAG5Q1ndq4Yfmbeo1zwLkNRKmCXGdNgWvGT3cskV0yQ" |
| 566 |
"kAQwJlrlzkAWBOWiLj/jJ76D7l+UXoizP2KI2C7I2FccqMmIfFmmkUy32nIJ0mZH" |
| 567 |
"IWoJoQYCBFRDO46iBAICASykAwQBAqUDAgEUphAEDnd3dy5nb29nbGUuY29tqAcE" |
| 568 |
"BXdvcmxkqQUCAwGJwKqBpwSBpBwUQvoeOk0Kg36SYTcLEkXqKwOBfF9vE4KX0Nxe" |
| 569 |
"LwjcDTpsuh3qXEaZ992r1N38VDcyS6P7I6HBYN9BsNHM362zZnY27GpTw+Kwd751" |
| 570 |
"CLoXFPoaMOe57dbBpXoro6Pd3BTbf/Tzr88K06yEOTDKPNj3+inbMaVigtK4PLyP" |
| 571 |
"q+Topyzvx9USFgRvyuoxn0Hgb+R0A3j6SLRuyOdAi4gv7Y5oliynrSIEIAYGBgYG" |
| 572 |
"BgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGrgMEAQevAwQBBLADBAEF"; |
| 573 |
|
| 574 |
// kBadSessionTrailingData is a custom serialized SSL_SESSION with trailing data |
| 575 |
// appended. |
| 576 |
static const char kBadSessionTrailingData[] = |
| 577 |
"MIIBdgIBAQICAwMEAsAvBCAG5Q1ndq4Yfmbeo1zwLkNRKmCXGdNgWvGT3cskV0yQ" |
| 578 |
"kAQwJlrlzkAWBOWiLj/jJ76D7l+UXoizP2KI2C7I2FccqMmIfFmmkUy32nIJ0mZH" |
| 579 |
"IWoJoQYCBFRDO46iBAICASykAwQBAqUDAgEUphAEDnd3dy5nb29nbGUuY29tqAcE" |
| 580 |
"BXdvcmxkqQUCAwGJwKqBpwSBpBwUQvoeOk0Kg36SYTcLEkXqKwOBfF9vE4KX0Nxe" |
| 581 |
"LwjcDTpsuh3qXEaZ992r1N38VDcyS6P7I6HBYN9BsNHM362zZnY27GpTw+Kwd751" |
| 582 |
"CLoXFPoaMOe57dbBpXoro6Pd3BTbf/Tzr88K06yEOTDKPNj3+inbMaVigtK4PLyP" |
| 583 |
"q+Topyzvx9USFgRvyuoxn0Hgb+R0A3j6SLRuyOdAi4gv7Y5oliynrSIEIAYGBgYG" |
| 584 |
"BgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGrgMEAQevAwQBBLADBAEFAAAA"; |
| 585 |
|
| 586 |
static bool DecodeBase64(std::vector<uint8_t> *out, const char *in) { |
| 587 |
size_t len; |
| 588 |
if (!EVP_DecodedLength(&len, strlen(in))) { |
| 589 |
fprintf(stderr, "EVP_DecodedLength failed\n"); |
| 590 |
return false; |
| 591 |
} |
| 592 |
|
| 593 |
out->resize(len); |
| 594 |
if (!EVP_DecodeBase64(out->data(), &len, len, (const uint8_t *)in, |
| 595 |
strlen(in))) { |
| 596 |
fprintf(stderr, "EVP_DecodeBase64 failed\n"); |
| 597 |
return false; |
| 598 |
} |
| 599 |
out->resize(len); |
| 600 |
return true; |
| 601 |
} |
| 602 |
|
| 603 |
static bool TestSSL_SESSIONEncoding(const char *input_b64) { |
| 604 |
const uint8_t *cptr; |
| 605 |
uint8_t *ptr; |
| 606 |
|
| 607 |
// Decode the input. |
| 608 |
std::vector<uint8_t> input; |
| 609 |
if (!DecodeBase64(&input, input_b64)) { |
| 610 |
return false; |
| 611 |
} |
| 612 |
|
| 613 |
// Verify the SSL_SESSION decodes. |
| 614 |
ScopedSSL_SESSION session(SSL_SESSION_from_bytes(input.data(), input.size())); |
| 615 |
if (!session) { |
| 616 |
fprintf(stderr, "SSL_SESSION_from_bytes failed\n"); |
| 617 |
return false; |
| 618 |
} |
| 619 |
|
| 620 |
// Verify the SSL_SESSION encoding round-trips. |
| 621 |
size_t encoded_len; |
| 622 |
ScopedOpenSSLBytes encoded; |
| 623 |
uint8_t *encoded_raw; |
| 624 |
if (!SSL_SESSION_to_bytes(session.get(), &encoded_raw, &encoded_len)) { |
| 625 |
fprintf(stderr, "SSL_SESSION_to_bytes failed\n"); |
| 626 |
return false; |
| 627 |
} |
| 628 |
encoded.reset(encoded_raw); |
| 629 |
if (encoded_len != input.size() || |
| 630 |
memcmp(input.data(), encoded.get(), input.size()) != 0) { |
| 631 |
fprintf(stderr, "SSL_SESSION_to_bytes did not round-trip\n"); |
| 632 |
hexdump(stderr, "Before: ", input.data(), input.size()); |
| 633 |
hexdump(stderr, "After: ", encoded_raw, encoded_len); |
| 634 |
return false; |
| 635 |
} |
| 636 |
|
| 637 |
// Verify the SSL_SESSION also decodes with the legacy API. |
| 638 |
cptr = input.data(); |
| 639 |
session.reset(d2i_SSL_SESSION(NULL, &cptr, input.size())); |
| 640 |
if (!session || cptr != input.data() + input.size()) { |
| 641 |
fprintf(stderr, "d2i_SSL_SESSION failed\n"); |
| 642 |
return false; |
| 643 |
} |
| 644 |
|
| 645 |
// Verify the SSL_SESSION encoding round-trips via the legacy API. |
| 646 |
int len = i2d_SSL_SESSION(session.get(), NULL); |
| 647 |
if (len < 0 || (size_t)len != input.size()) { |
| 648 |
fprintf(stderr, "i2d_SSL_SESSION(NULL) returned invalid length\n"); |
| 649 |
return false; |
| 650 |
} |
| 651 |
|
| 652 |
encoded.reset((uint8_t *)OPENSSL_malloc(input.size())); |
| 653 |
if (!encoded) { |
| 654 |
fprintf(stderr, "malloc failed\n"); |
| 655 |
return false; |
| 656 |
} |
| 657 |
|
| 658 |
ptr = encoded.get(); |
| 659 |
len = i2d_SSL_SESSION(session.get(), &ptr); |
| 660 |
if (len < 0 || (size_t)len != input.size()) { |
| 661 |
fprintf(stderr, "i2d_SSL_SESSION returned invalid length\n"); |
| 662 |
return false; |
| 663 |
} |
| 664 |
if (ptr != encoded.get() + input.size()) { |
| 665 |
fprintf(stderr, "i2d_SSL_SESSION did not advance ptr correctly\n"); |
| 666 |
return false; |
| 667 |
} |
| 668 |
if (memcmp(input.data(), encoded.get(), input.size()) != 0) { |
| 669 |
fprintf(stderr, "i2d_SSL_SESSION did not round-trip\n"); |
| 670 |
return false; |
| 671 |
} |
| 672 |
|
| 673 |
return true; |
| 674 |
} |
| 675 |
|
| 676 |
static bool TestBadSSL_SESSIONEncoding(const char *input_b64) { |
| 677 |
std::vector<uint8_t> input; |
| 678 |
if (!DecodeBase64(&input, input_b64)) { |
| 679 |
return false; |
| 680 |
} |
| 681 |
|
| 682 |
// Verify that the SSL_SESSION fails to decode. |
| 683 |
ScopedSSL_SESSION session(SSL_SESSION_from_bytes(input.data(), input.size())); |
| 684 |
if (session) { |
| 685 |
fprintf(stderr, "SSL_SESSION_from_bytes unexpectedly succeeded\n"); |
| 686 |
return false; |
| 687 |
} |
| 688 |
ERR_clear_error(); |
| 689 |
return true; |
| 690 |
} |
| 691 |
|
| 692 |
static bool TestDefaultVersion(uint16_t version, |
| 693 |
const SSL_METHOD *(*method)(void)) { |
| 694 |
ScopedSSL_CTX ctx(SSL_CTX_new(method())); |
| 695 |
if (!ctx) { |
| 696 |
return false; |
| 697 |
} |
| 698 |
// TODO(svaldez): Remove TLS1_2_VERSION fallback upon implementing TLS 1.3. |
| 699 |
return ctx->min_version == version && |
| 700 |
(ctx->max_version == version || |
| 701 |
(version == 0 && ctx->max_version == TLS1_2_VERSION)); |
| 702 |
} |
| 703 |
|
| 704 |
static bool CipherGetRFCName(std::string *out, uint16_t value) { |
| 705 |
const SSL_CIPHER *cipher = SSL_get_cipher_by_value(value); |
| 706 |
if (cipher == NULL) { |
| 707 |
return false; |
| 708 |
} |
| 709 |
ScopedOpenSSLString rfc_name(SSL_CIPHER_get_rfc_name(cipher)); |
| 710 |
if (!rfc_name) { |
| 711 |
return false; |
| 712 |
} |
| 713 |
out->assign(rfc_name.get()); |
| 714 |
return true; |
| 715 |
} |
| 716 |
|
| 717 |
typedef struct { |
| 718 |
int id; |
| 719 |
const char *rfc_name; |
| 720 |
} CIPHER_RFC_NAME_TEST; |
| 721 |
|
| 722 |
static const CIPHER_RFC_NAME_TEST kCipherRFCNameTests[] = { |
| 723 |
{ SSL3_CK_RSA_DES_192_CBC3_SHA, "TLS_RSA_WITH_3DES_EDE_CBC_SHA" }, |
| 724 |
{ SSL3_CK_RSA_RC4_128_MD5, "TLS_RSA_WITH_RC4_MD5" }, |
| 725 |
{ TLS1_CK_RSA_WITH_AES_128_SHA, "TLS_RSA_WITH_AES_128_CBC_SHA" }, |
| 726 |
{ TLS1_CK_DHE_RSA_WITH_AES_256_SHA, "TLS_DHE_RSA_WITH_AES_256_CBC_SHA" }, |
| 727 |
{ TLS1_CK_DHE_RSA_WITH_AES_256_SHA256, |
| 728 |
"TLS_DHE_RSA_WITH_AES_256_CBC_SHA256" }, |
| 729 |
{ TLS1_CK_ECDHE_RSA_WITH_AES_128_SHA256, |
| 730 |
"TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256" }, |
| 731 |
{ TLS1_CK_ECDHE_RSA_WITH_AES_256_SHA384, |
| 732 |
"TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384" }, |
| 733 |
{ TLS1_CK_ECDHE_RSA_WITH_AES_128_GCM_SHA256, |
| 734 |
"TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256" }, |
| 735 |
{ TLS1_CK_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, |
| 736 |
"TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256" }, |
| 737 |
{ TLS1_CK_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384, |
| 738 |
"TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384" }, |
| 739 |
{ TLS1_CK_PSK_WITH_RC4_128_SHA, "TLS_PSK_WITH_RC4_SHA" }, |
| 740 |
{ TLS1_CK_ECDHE_PSK_WITH_AES_128_CBC_SHA, |
| 741 |
"TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA" }, |
| 742 |
{ TLS1_CK_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256, |
| 743 |
"TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256" }, |
| 744 |
// These names are non-standard: |
| 745 |
{ TLS1_CK_ECDHE_RSA_CHACHA20_POLY1305_OLD, |
| 746 |
"TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256" }, |
| 747 |
{ TLS1_CK_ECDHE_ECDSA_CHACHA20_POLY1305_OLD, |
| 748 |
"TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256" }, |
| 749 |
}; |
| 750 |
|
| 751 |
static bool TestCipherGetRFCName(void) { |
| 752 |
for (size_t i = 0; |
| 753 |
i < sizeof(kCipherRFCNameTests) / sizeof(kCipherRFCNameTests[0]); i++) { |
| 754 |
const CIPHER_RFC_NAME_TEST *test = &kCipherRFCNameTests[i]; |
| 755 |
std::string rfc_name; |
| 756 |
if (!CipherGetRFCName(&rfc_name, test->id & 0xffff)) { |
| 757 |
fprintf(stderr, "SSL_CIPHER_get_rfc_name failed\n"); |
| 758 |
return false; |
| 759 |
} |
| 760 |
if (rfc_name != test->rfc_name) { |
| 761 |
fprintf(stderr, "SSL_CIPHER_get_rfc_name: got '%s', wanted '%s'\n", |
| 762 |
rfc_name.c_str(), test->rfc_name); |
| 763 |
return false; |
| 764 |
} |
| 765 |
} |
| 766 |
return true; |
| 767 |
} |
| 768 |
|
| 769 |
// CreateSessionWithTicket returns a sample |SSL_SESSION| with the ticket |
| 770 |
// replaced for one of length |ticket_len| or nullptr on failure. |
| 771 |
static ScopedSSL_SESSION CreateSessionWithTicket(size_t ticket_len) { |
| 772 |
std::vector<uint8_t> der; |
| 773 |
if (!DecodeBase64(&der, kOpenSSLSession)) { |
| 774 |
return nullptr; |
| 775 |
} |
| 776 |
ScopedSSL_SESSION session(SSL_SESSION_from_bytes(der.data(), der.size())); |
| 777 |
if (!session) { |
| 778 |
return nullptr; |
| 779 |
} |
| 780 |
|
| 781 |
// Swap out the ticket for a garbage one. |
| 782 |
OPENSSL_free(session->tlsext_tick); |
| 783 |
session->tlsext_tick = reinterpret_cast<uint8_t*>(OPENSSL_malloc(ticket_len)); |
| 784 |
if (session->tlsext_tick == nullptr) { |
| 785 |
return nullptr; |
| 786 |
} |
| 787 |
memset(session->tlsext_tick, 'a', ticket_len); |
| 788 |
session->tlsext_ticklen = ticket_len; |
| 789 |
|
| 790 |
// Fix up the timeout. |
| 791 |
session->time = time(NULL); |
| 792 |
return session; |
| 793 |
} |
| 794 |
|
| 795 |
// GetClientHelloLen creates a client SSL connection with a ticket of length |
| 796 |
// |ticket_len| and records the ClientHello. It returns the length of the |
| 797 |
// ClientHello, not including the record header, on success and zero on error. |
| 798 |
static size_t GetClientHelloLen(size_t ticket_len) { |
| 799 |
ScopedSSL_CTX ctx(SSL_CTX_new(TLS_method())); |
| 800 |
ScopedSSL_SESSION session = CreateSessionWithTicket(ticket_len); |
| 801 |
if (!ctx || !session) { |
| 802 |
return 0; |
| 803 |
} |
| 804 |
ScopedSSL ssl(SSL_new(ctx.get())); |
| 805 |
ScopedBIO bio(BIO_new(BIO_s_mem())); |
| 806 |
if (!ssl || !bio || !SSL_set_session(ssl.get(), session.get())) { |
| 807 |
return 0; |
| 808 |
} |
| 809 |
// Do not configure a reading BIO, but record what's written to a memory BIO. |
| 810 |
SSL_set_bio(ssl.get(), nullptr /* rbio */, BIO_up_ref(bio.get())); |
| 811 |
int ret = SSL_connect(ssl.get()); |
| 812 |
if (ret > 0) { |
| 813 |
// SSL_connect should fail without a BIO to write to. |
| 814 |
return 0; |
| 815 |
} |
| 816 |
ERR_clear_error(); |
| 817 |
|
| 818 |
const uint8_t *unused; |
| 819 |
size_t client_hello_len; |
| 820 |
if (!BIO_mem_contents(bio.get(), &unused, &client_hello_len) || |
| 821 |
client_hello_len <= SSL3_RT_HEADER_LENGTH) { |
| 822 |
return 0; |
| 823 |
} |
| 824 |
return client_hello_len - SSL3_RT_HEADER_LENGTH; |
| 825 |
} |
| 826 |
|
| 827 |
struct PaddingTest { |
| 828 |
size_t input_len, padded_len; |
| 829 |
}; |
| 830 |
|
| 831 |
static const PaddingTest kPaddingTests[] = { |
| 832 |
// ClientHellos of length below 0x100 do not require padding. |
| 833 |
{0xfe, 0xfe}, |
| 834 |
{0xff, 0xff}, |
| 835 |
// ClientHellos of length 0x100 through 0x1fb are padded up to 0x200. |
| 836 |
{0x100, 0x200}, |
| 837 |
{0x123, 0x200}, |
| 838 |
{0x1fb, 0x200}, |
| 839 |
// ClientHellos of length 0x1fc through 0x1ff get padded beyond 0x200. The |
| 840 |
// padding extension takes a minimum of four bytes plus one required content |
| 841 |
// byte. (To work around yet more server bugs, we avoid empty final |
| 842 |
// extensions.) |
| 843 |
{0x1fc, 0x201}, |
| 844 |
{0x1fd, 0x202}, |
| 845 |
{0x1fe, 0x203}, |
| 846 |
{0x1ff, 0x204}, |
| 847 |
// Finally, larger ClientHellos need no padding. |
| 848 |
{0x200, 0x200}, |
| 849 |
{0x201, 0x201}, |
| 850 |
}; |
| 851 |
|
| 852 |
static bool TestPaddingExtension() { |
| 853 |
// Sample a baseline length. |
| 854 |
size_t base_len = GetClientHelloLen(1); |
| 855 |
if (base_len == 0) { |
| 856 |
return false; |
| 857 |
} |
| 858 |
|
| 859 |
for (const PaddingTest &test : kPaddingTests) { |
| 860 |
if (base_len > test.input_len) { |
| 861 |
fprintf(stderr, "Baseline ClientHello too long.\n"); |
| 862 |
return false; |
| 863 |
} |
| 864 |
|
| 865 |
size_t padded_len = GetClientHelloLen(1 + test.input_len - base_len); |
| 866 |
if (padded_len != test.padded_len) { |
| 867 |
fprintf(stderr, "%u-byte ClientHello padded to %u bytes, not %u.\n", |
| 868 |
static_cast<unsigned>(test.input_len), |
| 869 |
static_cast<unsigned>(padded_len), |
| 870 |
static_cast<unsigned>(test.padded_len)); |
| 871 |
return false; |
| 872 |
} |
| 873 |
} |
| 874 |
return true; |
| 875 |
} |
| 876 |
|
| 877 |
// Test that |SSL_get_client_CA_list| echoes back the configured parameter even |
| 878 |
// before configuring as a server. |
| 879 |
static bool TestClientCAList() { |
| 880 |
ScopedSSL_CTX ctx(SSL_CTX_new(TLS_method())); |
| 881 |
if (!ctx) { |
| 882 |
return false; |
| 883 |
} |
| 884 |
ScopedSSL ssl(SSL_new(ctx.get())); |
| 885 |
if (!ssl) { |
| 886 |
return false; |
| 887 |
} |
| 888 |
|
| 889 |
STACK_OF(X509_NAME) *stack = sk_X509_NAME_new_null(); |
| 890 |
if (stack == nullptr) { |
| 891 |
return false; |
| 892 |
} |
| 893 |
// |SSL_set_client_CA_list| takes ownership. |
| 894 |
SSL_set_client_CA_list(ssl.get(), stack); |
| 895 |
|
| 896 |
return SSL_get_client_CA_list(ssl.get()) == stack; |
| 897 |
} |
| 898 |
|
| 899 |
static void AppendSession(SSL_SESSION *session, void *arg) { |
| 900 |
std::vector<SSL_SESSION*> *out = |
| 901 |
reinterpret_cast<std::vector<SSL_SESSION*>*>(arg); |
| 902 |
out->push_back(session); |
| 903 |
} |
| 904 |
|
| 905 |
// ExpectCache returns true if |ctx|'s session cache consists of |expected|, in |
| 906 |
// order. |
| 907 |
static bool ExpectCache(SSL_CTX *ctx, |
| 908 |
const std::vector<SSL_SESSION*> &expected) { |
| 909 |
// Check the linked list. |
| 910 |
SSL_SESSION *ptr = ctx->session_cache_head; |
| 911 |
for (SSL_SESSION *session : expected) { |
| 912 |
if (ptr != session) { |
| 913 |
return false; |
| 914 |
} |
| 915 |
// TODO(davidben): This is an absurd way to denote the end of the list. |
| 916 |
if (ptr->next == |
| 917 |
reinterpret_cast<SSL_SESSION *>(&ctx->session_cache_tail)) { |
| 918 |
ptr = nullptr; |
| 919 |
} else { |
| 920 |
ptr = ptr->next; |
| 921 |
} |
| 922 |
} |
| 923 |
if (ptr != nullptr) { |
| 924 |
return false; |
| 925 |
} |
| 926 |
|
| 927 |
// Check the hash table. |
| 928 |
std::vector<SSL_SESSION*> actual, expected_copy; |
| 929 |
lh_SSL_SESSION_doall_arg(SSL_CTX_sessions(ctx), AppendSession, &actual); |
| 930 |
expected_copy = expected; |
| 931 |
|
| 932 |
std::sort(actual.begin(), actual.end()); |
| 933 |
std::sort(expected_copy.begin(), expected_copy.end()); |
| 934 |
|
| 935 |
return actual == expected_copy; |
| 936 |
} |
| 937 |
|
| 938 |
static ScopedSSL_SESSION CreateTestSession(uint32_t number) { |
| 939 |
ScopedSSL_SESSION ret(SSL_SESSION_new()); |
| 940 |
if (!ret) { |
| 941 |
return nullptr; |
| 942 |
} |
| 943 |
|
| 944 |
ret->session_id_length = SSL3_SSL_SESSION_ID_LENGTH; |
| 945 |
memset(ret->session_id, 0, ret->session_id_length); |
| 946 |
memcpy(ret->session_id, &number, sizeof(number)); |
| 947 |
return ret; |
| 948 |
} |
| 949 |
|
| 950 |
// Test that the internal session cache behaves as expected. |
| 951 |
static bool TestInternalSessionCache() { |
| 952 |
ScopedSSL_CTX ctx(SSL_CTX_new(TLS_method())); |
| 953 |
if (!ctx) { |
| 954 |
return false; |
| 955 |
} |
| 956 |
|
| 957 |
// Prepare 10 test sessions. |
| 958 |
std::vector<ScopedSSL_SESSION> sessions; |
| 959 |
for (int i = 0; i < 10; i++) { |
| 960 |
ScopedSSL_SESSION session = CreateTestSession(i); |
| 961 |
if (!session) { |
| 962 |
return false; |
| 963 |
} |
| 964 |
sessions.push_back(std::move(session)); |
| 965 |
} |
| 966 |
|
| 967 |
SSL_CTX_sess_set_cache_size(ctx.get(), 5); |
| 968 |
|
| 969 |
// Insert all the test sessions. |
| 970 |
for (const auto &session : sessions) { |
| 971 |
if (!SSL_CTX_add_session(ctx.get(), session.get())) { |
| 972 |
return false; |
| 973 |
} |
| 974 |
} |
| 975 |
|
| 976 |
// Only the last five should be in the list. |
| 977 |
std::vector<SSL_SESSION*> expected = { |
| 978 |
sessions[9].get(), |
| 979 |
sessions[8].get(), |
| 980 |
sessions[7].get(), |
| 981 |
sessions[6].get(), |
| 982 |
sessions[5].get(), |
| 983 |
}; |
| 984 |
if (!ExpectCache(ctx.get(), expected)) { |
| 985 |
return false; |
| 986 |
} |
| 987 |
|
| 988 |
// Inserting an element already in the cache should fail. |
| 989 |
if (SSL_CTX_add_session(ctx.get(), sessions[7].get()) || |
| 990 |
!ExpectCache(ctx.get(), expected)) { |
| 991 |
return false; |
| 992 |
} |
| 993 |
|
| 994 |
// Although collisions should be impossible (256-bit session IDs), the cache |
| 995 |
// must handle them gracefully. |
| 996 |
ScopedSSL_SESSION collision(CreateTestSession(7)); |
| 997 |
if (!collision || !SSL_CTX_add_session(ctx.get(), collision.get())) { |
| 998 |
return false; |
| 999 |
} |
| 1000 |
expected = { |
| 1001 |
collision.get(), |
| 1002 |
sessions[9].get(), |
| 1003 |
sessions[8].get(), |
| 1004 |
sessions[6].get(), |
| 1005 |
sessions[5].get(), |
| 1006 |
}; |
| 1007 |
if (!ExpectCache(ctx.get(), expected)) { |
| 1008 |
return false; |
| 1009 |
} |
| 1010 |
|
| 1011 |
// Removing sessions behaves correctly. |
| 1012 |
if (!SSL_CTX_remove_session(ctx.get(), sessions[6].get())) { |
| 1013 |
return false; |
| 1014 |
} |
| 1015 |
expected = { |
| 1016 |
collision.get(), |
| 1017 |
sessions[9].get(), |
| 1018 |
sessions[8].get(), |
| 1019 |
sessions[5].get(), |
| 1020 |
}; |
| 1021 |
if (!ExpectCache(ctx.get(), expected)) { |
| 1022 |
return false; |
| 1023 |
} |
| 1024 |
|
| 1025 |
// Removing sessions requires an exact match. |
| 1026 |
if (SSL_CTX_remove_session(ctx.get(), sessions[0].get()) || |
| 1027 |
SSL_CTX_remove_session(ctx.get(), sessions[7].get()) || |
| 1028 |
!ExpectCache(ctx.get(), expected)) { |
| 1029 |
return false; |
| 1030 |
} |
| 1031 |
|
| 1032 |
return true; |
| 1033 |
} |
| 1034 |
|
| 1035 |
static uint16_t EpochFromSequence(uint64_t seq) { |
| 1036 |
return static_cast<uint16_t>(seq >> 48); |
| 1037 |
} |
| 1038 |
|
| 1039 |
static ScopedX509 GetTestCertificate() { |
| 1040 |
static const char kCertPEM[] = |
| 1041 |
"-----BEGIN CERTIFICATE-----\n" |
| 1042 |
"MIICWDCCAcGgAwIBAgIJAPuwTC6rEJsMMA0GCSqGSIb3DQEBBQUAMEUxCzAJBgNV\n" |
| 1043 |
"BAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEwHwYDVQQKDBhJbnRlcm5ldCBX\n" |
| 1044 |
"aWRnaXRzIFB0eSBMdGQwHhcNMTQwNDIzMjA1MDQwWhcNMTcwNDIyMjA1MDQwWjBF\n" |
| 1045 |
"MQswCQYDVQQGEwJBVTETMBEGA1UECAwKU29tZS1TdGF0ZTEhMB8GA1UECgwYSW50\n" |
| 1046 |
"ZXJuZXQgV2lkZ2l0cyBQdHkgTHRkMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKB\n" |
| 1047 |
"gQDYK8imMuRi/03z0K1Zi0WnvfFHvwlYeyK9Na6XJYaUoIDAtB92kWdGMdAQhLci\n" |
| 1048 |
"HnAjkXLI6W15OoV3gA/ElRZ1xUpxTMhjP6PyY5wqT5r6y8FxbiiFKKAnHmUcrgfV\n" |
| 1049 |
"W28tQ+0rkLGMryRtrukXOgXBv7gcrmU7G1jC2a7WqmeI8QIDAQABo1AwTjAdBgNV\n" |
| 1050 |
"HQ4EFgQUi3XVrMsIvg4fZbf6Vr5sp3Xaha8wHwYDVR0jBBgwFoAUi3XVrMsIvg4f\n" |
| 1051 |
"Zbf6Vr5sp3Xaha8wDAYDVR0TBAUwAwEB/zANBgkqhkiG9w0BAQUFAAOBgQA76Hht\n" |
| 1052 |
"ldY9avcTGSwbwoiuIqv0jTL1fHFnzy3RHMLDh+Lpvolc5DSrSJHCP5WuK0eeJXhr\n" |
| 1053 |
"T5oQpHL9z/cCDLAKCKRa4uV0fhEdOWBqyR9p8y5jJtye72t6CuFUV5iqcpF4BH4f\n" |
| 1054 |
"j2VNHwsSrJwkD4QUGlUtH7vwnQmyCFxZMmWAJg==\n" |
| 1055 |
"-----END CERTIFICATE-----\n"; |
| 1056 |
ScopedBIO bio(BIO_new_mem_buf(kCertPEM, strlen(kCertPEM))); |
| 1057 |
return ScopedX509(PEM_read_bio_X509(bio.get(), nullptr, nullptr, nullptr)); |
| 1058 |
} |
| 1059 |
|
| 1060 |
static ScopedEVP_PKEY GetTestKey() { |
| 1061 |
static const char kKeyPEM[] = |
| 1062 |
"-----BEGIN RSA PRIVATE KEY-----\n" |
| 1063 |
"MIICXgIBAAKBgQDYK8imMuRi/03z0K1Zi0WnvfFHvwlYeyK9Na6XJYaUoIDAtB92\n" |
| 1064 |
"kWdGMdAQhLciHnAjkXLI6W15OoV3gA/ElRZ1xUpxTMhjP6PyY5wqT5r6y8FxbiiF\n" |
| 1065 |
"KKAnHmUcrgfVW28tQ+0rkLGMryRtrukXOgXBv7gcrmU7G1jC2a7WqmeI8QIDAQAB\n" |
| 1066 |
"AoGBAIBy09Fd4DOq/Ijp8HeKuCMKTHqTW1xGHshLQ6jwVV2vWZIn9aIgmDsvkjCe\n" |
| 1067 |
"i6ssZvnbjVcwzSoByhjN8ZCf/i15HECWDFFh6gt0P5z0MnChwzZmvatV/FXCT0j+\n" |
| 1068 |
"WmGNB/gkehKjGXLLcjTb6dRYVJSCZhVuOLLcbWIV10gggJQBAkEA8S8sGe4ezyyZ\n" |
| 1069 |
"m4e9r95g6s43kPqtj5rewTsUxt+2n4eVodD+ZUlCULWVNAFLkYRTBCASlSrm9Xhj\n" |
| 1070 |
"QpmWAHJUkQJBAOVzQdFUaewLtdOJoPCtpYoY1zd22eae8TQEmpGOR11L6kbxLQsk\n" |
| 1071 |
"aMly/DOnOaa82tqAGTdqDEZgSNmCeKKknmECQAvpnY8GUOVAubGR6c+W90iBuQLj\n" |
| 1072 |
"LtFp/9ihd2w/PoDwrHZaoUYVcT4VSfJQog/k7kjE4MYXYWL8eEKg3WTWQNECQQDk\n" |
| 1073 |
"104Wi91Umd1PzF0ijd2jXOERJU1wEKe6XLkYYNHWQAe5l4J4MWj9OdxFXAxIuuR/\n" |
| 1074 |
"tfDwbqkta4xcux67//khAkEAvvRXLHTaa6VFzTaiiO8SaFsHV3lQyXOtMrBpB5jd\n" |
| 1075 |
"moZWgjHvB2W9Ckn7sDqsPB+U2tyX0joDdQEyuiMECDY8oQ==\n" |
| 1076 |
"-----END RSA PRIVATE KEY-----\n"; |
| 1077 |
ScopedBIO bio(BIO_new_mem_buf(kKeyPEM, strlen(kKeyPEM))); |
| 1078 |
return ScopedEVP_PKEY( |
| 1079 |
PEM_read_bio_PrivateKey(bio.get(), nullptr, nullptr, nullptr)); |
| 1080 |
} |
| 1081 |
|
| 1082 |
static bool ConnectClientAndServer(ScopedSSL *out_client, ScopedSSL *out_server, |
| 1083 |
SSL_CTX *client_ctx, SSL_CTX *server_ctx) { |
| 1084 |
ScopedSSL client(SSL_new(client_ctx)), server(SSL_new(server_ctx)); |
| 1085 |
if (!client || !server) { |
| 1086 |
return false; |
| 1087 |
} |
| 1088 |
SSL_set_connect_state(client.get()); |
| 1089 |
SSL_set_accept_state(server.get()); |
| 1090 |
|
| 1091 |
BIO *bio1, *bio2; |
| 1092 |
if (!BIO_new_bio_pair(&bio1, 0, &bio2, 0)) { |
| 1093 |
return false; |
| 1094 |
} |
| 1095 |
// SSL_set_bio takes ownership. |
| 1096 |
SSL_set_bio(client.get(), bio1, bio1); |
| 1097 |
SSL_set_bio(server.get(), bio2, bio2); |
| 1098 |
|
| 1099 |
// Drive both their handshakes to completion. |
| 1100 |
for (;;) { |
| 1101 |
int client_ret = SSL_do_handshake(client.get()); |
| 1102 |
int client_err = SSL_get_error(client.get(), client_ret); |
| 1103 |
if (client_err != SSL_ERROR_NONE && |
| 1104 |
client_err != SSL_ERROR_WANT_READ && |
| 1105 |
client_err != SSL_ERROR_WANT_WRITE) { |
| 1106 |
fprintf(stderr, "Client error: %d\n", client_err); |
| 1107 |
return false; |
| 1108 |
} |
| 1109 |
|
| 1110 |
int server_ret = SSL_do_handshake(server.get()); |
| 1111 |
int server_err = SSL_get_error(server.get(), server_ret); |
| 1112 |
if (server_err != SSL_ERROR_NONE && |
| 1113 |
server_err != SSL_ERROR_WANT_READ && |
| 1114 |
server_err != SSL_ERROR_WANT_WRITE) { |
| 1115 |
fprintf(stderr, "Server error: %d\n", server_err); |
| 1116 |
return false; |
| 1117 |
} |
| 1118 |
|
| 1119 |
if (client_ret == 1 && server_ret == 1) { |
| 1120 |
break; |
| 1121 |
} |
| 1122 |
} |
| 1123 |
|
| 1124 |
*out_client = std::move(client); |
| 1125 |
*out_server = std::move(server); |
| 1126 |
return true; |
| 1127 |
} |
| 1128 |
|
| 1129 |
static bool TestSequenceNumber(bool dtls) { |
| 1130 |
ScopedSSL_CTX client_ctx(SSL_CTX_new(dtls ? DTLS_method() : TLS_method())); |
| 1131 |
ScopedSSL_CTX server_ctx(SSL_CTX_new(dtls ? DTLS_method() : TLS_method())); |
| 1132 |
if (!client_ctx || !server_ctx) { |
| 1133 |
return false; |
| 1134 |
} |
| 1135 |
|
| 1136 |
ScopedX509 cert = GetTestCertificate(); |
| 1137 |
ScopedEVP_PKEY key = GetTestKey(); |
| 1138 |
if (!cert || !key || |
| 1139 |
!SSL_CTX_use_certificate(server_ctx.get(), cert.get()) || |
| 1140 |
!SSL_CTX_use_PrivateKey(server_ctx.get(), key.get())) { |
| 1141 |
return false; |
| 1142 |
} |
| 1143 |
|
| 1144 |
ScopedSSL client, server; |
| 1145 |
if (!ConnectClientAndServer(&client, &server, client_ctx.get(), |
| 1146 |
server_ctx.get())) { |
| 1147 |
return false; |
| 1148 |
} |
| 1149 |
|
| 1150 |
uint64_t client_read_seq = SSL_get_read_sequence(client.get()); |
| 1151 |
uint64_t client_write_seq = SSL_get_write_sequence(client.get()); |
| 1152 |
uint64_t server_read_seq = SSL_get_read_sequence(server.get()); |
| 1153 |
uint64_t server_write_seq = SSL_get_write_sequence(server.get()); |
| 1154 |
|
| 1155 |
if (dtls) { |
| 1156 |
// Both client and server must be at epoch 1. |
| 1157 |
if (EpochFromSequence(client_read_seq) != 1 || |
| 1158 |
EpochFromSequence(client_write_seq) != 1 || |
| 1159 |
EpochFromSequence(server_read_seq) != 1 || |
| 1160 |
EpochFromSequence(server_write_seq) != 1) { |
| 1161 |
fprintf(stderr, "Bad epochs.\n"); |
| 1162 |
return false; |
| 1163 |
} |
| 1164 |
|
| 1165 |
// The next record to be written should exceed the largest received. |
| 1166 |
if (client_write_seq <= server_read_seq || |
| 1167 |
server_write_seq <= client_read_seq) { |
| 1168 |
fprintf(stderr, "Inconsistent sequence numbers.\n"); |
| 1169 |
return false; |
| 1170 |
} |
| 1171 |
} else { |
| 1172 |
// The next record to be written should equal the next to be received. |
| 1173 |
if (client_write_seq != server_read_seq || |
| 1174 |
server_write_seq != client_write_seq) { |
| 1175 |
fprintf(stderr, "Inconsistent sequence numbers.\n"); |
| 1176 |
return false; |
| 1177 |
} |
| 1178 |
} |
| 1179 |
|
| 1180 |
// Send a record from client to server. |
| 1181 |
uint8_t byte = 0; |
| 1182 |
if (SSL_write(client.get(), &byte, 1) != 1 || |
| 1183 |
SSL_read(server.get(), &byte, 1) != 1) { |
| 1184 |
fprintf(stderr, "Could not send byte.\n"); |
| 1185 |
return false; |
| 1186 |
} |
| 1187 |
|
| 1188 |
// The client write and server read sequence numbers should have incremented. |
| 1189 |
if (client_write_seq + 1 != SSL_get_write_sequence(client.get()) || |
| 1190 |
server_read_seq + 1 != SSL_get_read_sequence(server.get())) { |
| 1191 |
fprintf(stderr, "Sequence numbers did not increment.\n");\ |
| 1192 |
return false; |
| 1193 |
} |
| 1194 |
|
| 1195 |
return true; |
| 1196 |
} |
| 1197 |
|
| 1198 |
static bool TestOneSidedShutdown() { |
| 1199 |
ScopedSSL_CTX client_ctx(SSL_CTX_new(TLS_method())); |
| 1200 |
ScopedSSL_CTX server_ctx(SSL_CTX_new(TLS_method())); |
| 1201 |
if (!client_ctx || !server_ctx) { |
| 1202 |
return false; |
| 1203 |
} |
| 1204 |
|
| 1205 |
ScopedX509 cert = GetTestCertificate(); |
| 1206 |
ScopedEVP_PKEY key = GetTestKey(); |
| 1207 |
if (!cert || !key || |
| 1208 |
!SSL_CTX_use_certificate(server_ctx.get(), cert.get()) || |
| 1209 |
!SSL_CTX_use_PrivateKey(server_ctx.get(), key.get())) { |
| 1210 |
return false; |
| 1211 |
} |
| 1212 |
|
| 1213 |
ScopedSSL client, server; |
| 1214 |
if (!ConnectClientAndServer(&client, &server, client_ctx.get(), |
| 1215 |
server_ctx.get())) { |
| 1216 |
return false; |
| 1217 |
} |
| 1218 |
|
| 1219 |
// Shut down half the connection. SSL_shutdown will return 0 to signal only |
| 1220 |
// one side has shut down. |
| 1221 |
if (SSL_shutdown(client.get()) != 0) { |
| 1222 |
fprintf(stderr, "Could not shutdown.\n"); |
| 1223 |
return false; |
| 1224 |
} |
| 1225 |
|
| 1226 |
// Reading from the server should consume the EOF. |
| 1227 |
uint8_t byte; |
| 1228 |
if (SSL_read(server.get(), &byte, 1) != 0 || |
| 1229 |
SSL_get_error(server.get(), 0) != SSL_ERROR_ZERO_RETURN) { |
| 1230 |
fprintf(stderr, "Connection was not shut down cleanly.\n"); |
| 1231 |
return false; |
| 1232 |
} |
| 1233 |
|
| 1234 |
// However, the server may continue to write data and then shut down the |
| 1235 |
// connection. |
| 1236 |
byte = 42; |
| 1237 |
if (SSL_write(server.get(), &byte, 1) != 1 || |
| 1238 |
SSL_read(client.get(), &byte, 1) != 1 || |
| 1239 |
byte != 42) { |
| 1240 |
fprintf(stderr, "Could not send byte.\n"); |
| 1241 |
return false; |
| 1242 |
} |
| 1243 |
|
| 1244 |
// The server may then shutdown the connection. |
| 1245 |
if (SSL_shutdown(server.get()) != 1 || |
| 1246 |
SSL_shutdown(client.get()) != 1) { |
| 1247 |
fprintf(stderr, "Could not complete shutdown.\n"); |
| 1248 |
return false; |
| 1249 |
} |
| 1250 |
|
| 1251 |
return true; |
| 1252 |
} |
| 1253 |
|
| 1254 |
static bool ExpectFDs(const SSL *ssl, int rfd, int wfd) { |
| 1255 |
if (SSL_get_rfd(ssl) != rfd || SSL_get_wfd(ssl) != wfd) { |
| 1256 |
fprintf(stderr, "Got fds %d and %d, wanted %d and %d.\n", SSL_get_rfd(ssl), |
| 1257 |
SSL_get_wfd(ssl), rfd, wfd); |
| 1258 |
return false; |
| 1259 |
} |
| 1260 |
|
| 1261 |
// The wrapper BIOs are always equal when fds are equal, even if set |
| 1262 |
// individually. |
| 1263 |
if (rfd == wfd && SSL_get_rbio(ssl) != SSL_get_wbio(ssl)) { |
| 1264 |
fprintf(stderr, "rbio and wbio did not match.\n"); |
| 1265 |
return false; |
| 1266 |
} |
| 1267 |
|
| 1268 |
return true; |
| 1269 |
} |
| 1270 |
|
| 1271 |
static bool TestSetFD() { |
| 1272 |
ScopedSSL_CTX ctx(SSL_CTX_new(TLS_method())); |
| 1273 |
if (!ctx) { |
| 1274 |
return false; |
| 1275 |
} |
| 1276 |
|
| 1277 |
// Test setting different read and write FDs. |
| 1278 |
ScopedSSL ssl(SSL_new(ctx.get())); |
| 1279 |
if (!ssl || |
| 1280 |
!SSL_set_rfd(ssl.get(), 1) || |
| 1281 |
!SSL_set_wfd(ssl.get(), 2) || |
| 1282 |
!ExpectFDs(ssl.get(), 1, 2)) { |
| 1283 |
return false; |
| 1284 |
} |
| 1285 |
|
| 1286 |
// Test setting the same FD. |
| 1287 |
ssl.reset(SSL_new(ctx.get())); |
| 1288 |
if (!ssl || |
| 1289 |
!SSL_set_fd(ssl.get(), 1) || |
| 1290 |
!ExpectFDs(ssl.get(), 1, 1)) { |
| 1291 |
return false; |
| 1292 |
} |
| 1293 |
|
| 1294 |
// Test setting the same FD one side at a time. |
| 1295 |
ssl.reset(SSL_new(ctx.get())); |
| 1296 |
if (!ssl || |
| 1297 |
!SSL_set_rfd(ssl.get(), 1) || |
| 1298 |
!SSL_set_wfd(ssl.get(), 1) || |
| 1299 |
!ExpectFDs(ssl.get(), 1, 1)) { |
| 1300 |
return false; |
| 1301 |
} |
| 1302 |
|
| 1303 |
// Test setting the same FD in the other order. |
| 1304 |
ssl.reset(SSL_new(ctx.get())); |
| 1305 |
if (!ssl || |
| 1306 |
!SSL_set_wfd(ssl.get(), 1) || |
| 1307 |
!SSL_set_rfd(ssl.get(), 1) || |
| 1308 |
!ExpectFDs(ssl.get(), 1, 1)) { |
| 1309 |
return false; |
| 1310 |
} |
| 1311 |
|
| 1312 |
// Test changing the read FD partway through. |
| 1313 |
ssl.reset(SSL_new(ctx.get())); |
| 1314 |
if (!ssl || |
| 1315 |
!SSL_set_fd(ssl.get(), 1) || |
| 1316 |
!SSL_set_rfd(ssl.get(), 2) || |
| 1317 |
!ExpectFDs(ssl.get(), 2, 1)) { |
| 1318 |
return false; |
| 1319 |
} |
| 1320 |
|
| 1321 |
// Test changing the write FD partway through. |
| 1322 |
ssl.reset(SSL_new(ctx.get())); |
| 1323 |
if (!ssl || |
| 1324 |
!SSL_set_fd(ssl.get(), 1) || |
| 1325 |
!SSL_set_wfd(ssl.get(), 2) || |
| 1326 |
!ExpectFDs(ssl.get(), 1, 2)) { |
| 1327 |
return false; |
| 1328 |
} |
| 1329 |
|
| 1330 |
// Test a no-op change to the read FD partway through. |
| 1331 |
ssl.reset(SSL_new(ctx.get())); |
| 1332 |
if (!ssl || |
| 1333 |
!SSL_set_fd(ssl.get(), 1) || |
| 1334 |
!SSL_set_rfd(ssl.get(), 1) || |
| 1335 |
!ExpectFDs(ssl.get(), 1, 1)) { |
| 1336 |
return false; |
| 1337 |
} |
| 1338 |
|
| 1339 |
// Test a no-op change to the write FD partway through. |
| 1340 |
ssl.reset(SSL_new(ctx.get())); |
| 1341 |
if (!ssl || |
| 1342 |
!SSL_set_fd(ssl.get(), 1) || |
| 1343 |
!SSL_set_wfd(ssl.get(), 1) || |
| 1344 |
!ExpectFDs(ssl.get(), 1, 1)) { |
| 1345 |
return false; |
| 1346 |
} |
| 1347 |
|
| 1348 |
// ASan builds will implicitly test that the internal |BIO| reference-counting |
| 1349 |
// is correct. |
| 1350 |
|
| 1351 |
return true; |
| 1352 |
} |
| 1353 |
|
| 1354 |
int main() { |
| 1355 |
CRYPTO_library_init(); |
| 1356 |
|
| 1357 |
if (!TestCipherRules() || |
| 1358 |
!TestSSL_SESSIONEncoding(kOpenSSLSession) || |
| 1359 |
!TestSSL_SESSIONEncoding(kCustomSession) || |
| 1360 |
!TestSSL_SESSIONEncoding(kBoringSSLSession) || |
| 1361 |
!TestBadSSL_SESSIONEncoding(kBadSessionExtraField) || |
| 1362 |
!TestBadSSL_SESSIONEncoding(kBadSessionVersion) || |
| 1363 |
!TestBadSSL_SESSIONEncoding(kBadSessionTrailingData) || |
| 1364 |
!TestDefaultVersion(0, &TLS_method) || |
| 1365 |
!TestDefaultVersion(SSL3_VERSION, &SSLv3_method) || |
| 1366 |
!TestDefaultVersion(TLS1_VERSION, &TLSv1_method) || |
| 1367 |
!TestDefaultVersion(TLS1_1_VERSION, &TLSv1_1_method) || |
| 1368 |
!TestDefaultVersion(TLS1_2_VERSION, &TLSv1_2_method) || |
| 1369 |
!TestDefaultVersion(0, &DTLS_method) || |
| 1370 |
!TestDefaultVersion(DTLS1_VERSION, &DTLSv1_method) || |
| 1371 |
!TestDefaultVersion(DTLS1_2_VERSION, &DTLSv1_2_method) || |
| 1372 |
!TestCipherGetRFCName() || |
| 1373 |
!TestPaddingExtension() || |
| 1374 |
!TestClientCAList() || |
| 1375 |
!TestInternalSessionCache() || |
| 1376 |
!TestSequenceNumber(false /* TLS */) || |
| 1377 |
!TestSequenceNumber(true /* DTLS */) || |
| 1378 |
!TestOneSidedShutdown() || |
| 1379 |
!TestSetFD()) { |
| 1380 |
ERR_print_errors_fp(stderr); |
| 1381 |
return 1; |
| 1382 |
} |
| 1383 |
|
| 1384 |
printf("PASS\n"); |
| 1385 |
return 0; |
| 1386 |
} |