1/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) 2 * All rights reserved. 3 * 4 * This package is an SSL implementation written 5 * by Eric Young (eay@cryptsoft.com). 6 * The implementation was written so as to conform with Netscapes SSL. 7 * 8 * This library is free for commercial and non-commercial use as long as 9 * the following conditions are aheared to. The following conditions 10 * apply to all code found in this distribution, be it the RC4, RSA, 11 * lhash, DES, etc., code; not just the SSL code. The SSL documentation 12 * included with this distribution is covered by the same copyright terms 13 * except that the holder is Tim Hudson (tjh@cryptsoft.com). 14 * 15 * Copyright remains Eric Young's, and as such any Copyright notices in 16 * the code are not to be removed. 17 * If this package is used in a product, Eric Young should be given attribution 18 * as the author of the parts of the library used. 19 * This can be in the form of a textual message at program startup or 20 * in documentation (online or textual) provided with the package. 21 * 22 * Redistribution and use in source and binary forms, with or without 23 * modification, are permitted provided that the following conditions 24 * are met: 25 * 1. Redistributions of source code must retain the copyright 26 * notice, this list of conditions and the following disclaimer. 27 * 2. Redistributions in binary form must reproduce the above copyright 28 * notice, this list of conditions and the following disclaimer in the 29 * documentation and/or other materials provided with the distribution. 30 * 3. All advertising materials mentioning features or use of this software 31 * must display the following acknowledgement: 32 * "This product includes cryptographic software written by 33 * Eric Young (eay@cryptsoft.com)" 34 * The word 'cryptographic' can be left out if the rouines from the library 35 * being used are not cryptographic related :-). 36 * 4. If you include any Windows specific code (or a derivative thereof) from 37 * the apps directory (application code) you must include an acknowledgement: 38 * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" 39 * 40 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND 41 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 42 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 43 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 44 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 45 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 46 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 47 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 48 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 49 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 50 * SUCH DAMAGE. 51 * 52 * The licence and distribution terms for any publically available version or 53 * derivative of this code cannot be changed. i.e. this code cannot simply be 54 * copied and put under another distribution licence 55 * [including the GNU Public Licence.] 56 */ 57/* ==================================================================== 58 * Copyright 2005 Nokia. All rights reserved. 59 * 60 * The portions of the attached software ("Contribution") is developed by 61 * Nokia Corporation and is licensed pursuant to the OpenSSL open source 62 * license. 63 * 64 * The Contribution, originally written by Mika Kousa and Pasi Eronen of 65 * Nokia Corporation, consists of the "PSK" (Pre-Shared Key) ciphersuites 66 * support (see RFC 4279) to OpenSSL. 67 * 68 * No patent licenses or other rights except those expressly stated in 69 * the OpenSSL open source license shall be deemed granted or received 70 * expressly, by implication, estoppel, or otherwise. 71 * 72 * No assurances are provided by Nokia that the Contribution does not 73 * infringe the patent or other intellectual property rights of any third 74 * party or that the license provides you with all the necessary rights 75 * to make use of the Contribution. 76 * 77 * THE SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND. IN 78 * ADDITION TO THE DISCLAIMERS INCLUDED IN THE LICENSE, NOKIA 79 * SPECIFICALLY DISCLAIMS ANY LIABILITY FOR CLAIMS BROUGHT BY YOU OR ANY 80 * OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS OR 81 * OTHERWISE. */ 82 83#include <openssl/ssl.h> 84 85#include <limits.h> 86#include <string.h> 87 88#include <openssl/bytestring.h> 89#include <openssl/err.h> 90#include <openssl/mem.h> 91#include <openssl/x509.h> 92 93#include "internal.h" 94 95 96/* An SSL_SESSION is serialized as the following ASN.1 structure: 97 * 98 * SSLSession ::= SEQUENCE { 99 * version INTEGER (1), -- ignored 100 * sslVersion INTEGER, -- protocol version number 101 * cipher OCTET STRING, -- two bytes long 102 * sessionID OCTET STRING, 103 * masterKey OCTET STRING, 104 * time [1] INTEGER OPTIONAL, -- seconds since UNIX epoch 105 * timeout [2] INTEGER OPTIONAL, -- in seconds 106 * peer [3] Certificate OPTIONAL, 107 * sessionIDContext [4] OCTET STRING OPTIONAL, 108 * verifyResult [5] INTEGER OPTIONAL, -- one of X509_V_* codes 109 * hostName [6] OCTET STRING OPTIONAL, 110 * -- from server_name extension 111 * pskIdentity [8] OCTET STRING OPTIONAL, 112 * ticketLifetimeHint [9] INTEGER OPTIONAL, -- client-only 113 * ticket [10] OCTET STRING OPTIONAL, -- client-only 114 * peerSHA256 [13] OCTET STRING OPTIONAL, 115 * originalHandshakeHash [14] OCTET STRING OPTIONAL, 116 * signedCertTimestampList [15] OCTET STRING OPTIONAL, 117 * -- contents of SCT extension 118 * ocspResponse [16] OCTET STRING OPTIONAL, 119 * -- stapled OCSP response from the server 120 * extendedMasterSecret [17] BOOLEAN OPTIONAL, 121 * keyExchangeInfo [18] INTEGER OPTIONAL, 122 * certChain [19] SEQUENCE OF Certificate OPTIONAL, 123 * } 124 * 125 * Note: historically this serialization has included other optional 126 * fields. Their presense is currently treated as a parse error: 127 * 128 * keyArg [0] IMPLICIT OCTET STRING OPTIONAL, 129 * pskIdentityHint [7] OCTET STRING OPTIONAL, 130 * compressionMethod [11] OCTET STRING OPTIONAL, 131 * srpUsername [12] OCTET STRING OPTIONAL, */ 132 133static const unsigned kVersion = 1; 134 135static const int kTimeTag = 136 CBS_ASN1_CONSTRUCTED | CBS_ASN1_CONTEXT_SPECIFIC | 1; 137static const int kTimeoutTag = 138 CBS_ASN1_CONSTRUCTED | CBS_ASN1_CONTEXT_SPECIFIC | 2; 139static const int kPeerTag = 140 CBS_ASN1_CONSTRUCTED | CBS_ASN1_CONTEXT_SPECIFIC | 3; 141static const int kSessionIDContextTag = 142 CBS_ASN1_CONSTRUCTED | CBS_ASN1_CONTEXT_SPECIFIC | 4; 143static const int kVerifyResultTag = 144 CBS_ASN1_CONSTRUCTED | CBS_ASN1_CONTEXT_SPECIFIC | 5; 145static const int kHostNameTag = 146 CBS_ASN1_CONSTRUCTED | CBS_ASN1_CONTEXT_SPECIFIC | 6; 147static const int kPSKIdentityTag = 148 CBS_ASN1_CONSTRUCTED | CBS_ASN1_CONTEXT_SPECIFIC | 8; 149static const int kTicketLifetimeHintTag = 150 CBS_ASN1_CONSTRUCTED | CBS_ASN1_CONTEXT_SPECIFIC | 9; 151static const int kTicketTag = 152 CBS_ASN1_CONSTRUCTED | CBS_ASN1_CONTEXT_SPECIFIC | 10; 153static const int kPeerSHA256Tag = 154 CBS_ASN1_CONSTRUCTED | CBS_ASN1_CONTEXT_SPECIFIC | 13; 155static const int kOriginalHandshakeHashTag = 156 CBS_ASN1_CONSTRUCTED | CBS_ASN1_CONTEXT_SPECIFIC | 14; 157static const int kSignedCertTimestampListTag = 158 CBS_ASN1_CONSTRUCTED | CBS_ASN1_CONTEXT_SPECIFIC | 15; 159static const int kOCSPResponseTag = 160 CBS_ASN1_CONSTRUCTED | CBS_ASN1_CONTEXT_SPECIFIC | 16; 161static const int kExtendedMasterSecretTag = 162 CBS_ASN1_CONSTRUCTED | CBS_ASN1_CONTEXT_SPECIFIC | 17; 163static const int kKeyExchangeInfoTag = 164 CBS_ASN1_CONSTRUCTED | CBS_ASN1_CONTEXT_SPECIFIC | 18; 165static const int kCertChainTag = 166 CBS_ASN1_CONSTRUCTED | CBS_ASN1_CONTEXT_SPECIFIC | 19; 167 168static int add_X509(CBB *cbb, X509 *x509) { 169 int len = i2d_X509(x509, NULL); 170 if (len < 0) { 171 return 0; 172 } 173 uint8_t *buf; 174 if (!CBB_add_space(cbb, &buf, len)) { 175 OPENSSL_PUT_ERROR(SSL, ERR_R_MALLOC_FAILURE); 176 return 0; 177 } 178 if (buf != NULL && i2d_X509(x509, &buf) < 0) { 179 return 0; 180 } 181 return 1; 182} 183 184static int SSL_SESSION_to_bytes_full(const SSL_SESSION *in, uint8_t **out_data, 185 size_t *out_len, int for_ticket) { 186 CBB cbb, session, child, child2; 187 188 if (in == NULL || in->cipher == NULL) { 189 return 0; 190 } 191 192 CBB_zero(&cbb); 193 if (!CBB_init(&cbb, 0) || 194 !CBB_add_asn1(&cbb, &session, CBS_ASN1_SEQUENCE) || 195 !CBB_add_asn1_uint64(&session, kVersion) || 196 !CBB_add_asn1_uint64(&session, in->ssl_version) || 197 !CBB_add_asn1(&session, &child, CBS_ASN1_OCTETSTRING) || 198 !CBB_add_u16(&child, (uint16_t)(in->cipher->id & 0xffff)) || 199 !CBB_add_asn1(&session, &child, CBS_ASN1_OCTETSTRING) || 200 /* The session ID is irrelevant for a session ticket. */ 201 !CBB_add_bytes(&child, in->session_id, 202 for_ticket ? 0 : in->session_id_length) || 203 !CBB_add_asn1(&session, &child, CBS_ASN1_OCTETSTRING) || 204 !CBB_add_bytes(&child, in->master_key, in->master_key_length)) { 205 OPENSSL_PUT_ERROR(SSL, ERR_R_MALLOC_FAILURE); 206 goto err; 207 } 208 209 if (in->time != 0) { 210 if (!CBB_add_asn1(&session, &child, kTimeTag) || 211 !CBB_add_asn1_uint64(&child, in->time)) { 212 OPENSSL_PUT_ERROR(SSL, ERR_R_MALLOC_FAILURE); 213 goto err; 214 } 215 } 216 217 if (in->timeout != 0) { 218 if (!CBB_add_asn1(&session, &child, kTimeoutTag) || 219 !CBB_add_asn1_uint64(&child, in->timeout)) { 220 OPENSSL_PUT_ERROR(SSL, ERR_R_MALLOC_FAILURE); 221 goto err; 222 } 223 } 224 225 /* The peer certificate is only serialized if the SHA-256 isn't 226 * serialized instead. */ 227 if (in->peer && !in->peer_sha256_valid) { 228 if (!CBB_add_asn1(&session, &child, kPeerTag)) { 229 OPENSSL_PUT_ERROR(SSL, ERR_R_MALLOC_FAILURE); 230 goto err; 231 } 232 if (!add_X509(&child, in->peer)) { 233 goto err; 234 } 235 } 236 237 /* Although it is OPTIONAL and usually empty, OpenSSL has 238 * historically always encoded the sid_ctx. */ 239 if (!CBB_add_asn1(&session, &child, kSessionIDContextTag) || 240 !CBB_add_asn1(&child, &child2, CBS_ASN1_OCTETSTRING) || 241 !CBB_add_bytes(&child2, in->sid_ctx, in->sid_ctx_length)) { 242 OPENSSL_PUT_ERROR(SSL, ERR_R_MALLOC_FAILURE); 243 goto err; 244 } 245 246 if (in->verify_result != X509_V_OK) { 247 if (!CBB_add_asn1(&session, &child, kVerifyResultTag) || 248 !CBB_add_asn1_uint64(&child, in->verify_result)) { 249 OPENSSL_PUT_ERROR(SSL, ERR_R_MALLOC_FAILURE); 250 goto err; 251 } 252 } 253 254 if (in->tlsext_hostname) { 255 if (!CBB_add_asn1(&session, &child, kHostNameTag) || 256 !CBB_add_asn1(&child, &child2, CBS_ASN1_OCTETSTRING) || 257 !CBB_add_bytes(&child2, (const uint8_t *)in->tlsext_hostname, 258 strlen(in->tlsext_hostname))) { 259 OPENSSL_PUT_ERROR(SSL, ERR_R_MALLOC_FAILURE); 260 goto err; 261 } 262 } 263 264 if (in->psk_identity) { 265 if (!CBB_add_asn1(&session, &child, kPSKIdentityTag) || 266 !CBB_add_asn1(&child, &child2, CBS_ASN1_OCTETSTRING) || 267 !CBB_add_bytes(&child2, (const uint8_t *)in->psk_identity, 268 strlen(in->psk_identity))) { 269 OPENSSL_PUT_ERROR(SSL, ERR_R_MALLOC_FAILURE); 270 goto err; 271 } 272 } 273 274 if (in->tlsext_tick_lifetime_hint > 0) { 275 if (!CBB_add_asn1(&session, &child, kTicketLifetimeHintTag) || 276 !CBB_add_asn1_uint64(&child, in->tlsext_tick_lifetime_hint)) { 277 OPENSSL_PUT_ERROR(SSL, ERR_R_MALLOC_FAILURE); 278 goto err; 279 } 280 } 281 282 if (in->tlsext_tick && !for_ticket) { 283 if (!CBB_add_asn1(&session, &child, kTicketTag) || 284 !CBB_add_asn1(&child, &child2, CBS_ASN1_OCTETSTRING) || 285 !CBB_add_bytes(&child2, in->tlsext_tick, in->tlsext_ticklen)) { 286 OPENSSL_PUT_ERROR(SSL, ERR_R_MALLOC_FAILURE); 287 goto err; 288 } 289 } 290 291 if (in->peer_sha256_valid) { 292 if (!CBB_add_asn1(&session, &child, kPeerSHA256Tag) || 293 !CBB_add_asn1(&child, &child2, CBS_ASN1_OCTETSTRING) || 294 !CBB_add_bytes(&child2, in->peer_sha256, sizeof(in->peer_sha256))) { 295 OPENSSL_PUT_ERROR(SSL, ERR_R_MALLOC_FAILURE); 296 goto err; 297 } 298 } 299 300 if (in->original_handshake_hash_len > 0) { 301 if (!CBB_add_asn1(&session, &child, kOriginalHandshakeHashTag) || 302 !CBB_add_asn1(&child, &child2, CBS_ASN1_OCTETSTRING) || 303 !CBB_add_bytes(&child2, in->original_handshake_hash, 304 in->original_handshake_hash_len)) { 305 OPENSSL_PUT_ERROR(SSL, ERR_R_MALLOC_FAILURE); 306 goto err; 307 } 308 } 309 310 if (in->tlsext_signed_cert_timestamp_list_length > 0) { 311 if (!CBB_add_asn1(&session, &child, kSignedCertTimestampListTag) || 312 !CBB_add_asn1(&child, &child2, CBS_ASN1_OCTETSTRING) || 313 !CBB_add_bytes(&child2, in->tlsext_signed_cert_timestamp_list, 314 in->tlsext_signed_cert_timestamp_list_length)) { 315 OPENSSL_PUT_ERROR(SSL, ERR_R_MALLOC_FAILURE); 316 goto err; 317 } 318 } 319 320 if (in->ocsp_response_length > 0) { 321 if (!CBB_add_asn1(&session, &child, kOCSPResponseTag) || 322 !CBB_add_asn1(&child, &child2, CBS_ASN1_OCTETSTRING) || 323 !CBB_add_bytes(&child2, in->ocsp_response, in->ocsp_response_length)) { 324 OPENSSL_PUT_ERROR(SSL, ERR_R_MALLOC_FAILURE); 325 goto err; 326 } 327 } 328 329 if (in->extended_master_secret) { 330 if (!CBB_add_asn1(&session, &child, kExtendedMasterSecretTag) || 331 !CBB_add_asn1(&child, &child2, CBS_ASN1_BOOLEAN) || 332 !CBB_add_u8(&child2, 0xff)) { 333 OPENSSL_PUT_ERROR(SSL, ERR_R_MALLOC_FAILURE); 334 goto err; 335 } 336 } 337 338 if (in->key_exchange_info > 0 && 339 (!CBB_add_asn1(&session, &child, kKeyExchangeInfoTag) || 340 !CBB_add_asn1_uint64(&child, in->key_exchange_info))) { 341 OPENSSL_PUT_ERROR(SSL, ERR_R_MALLOC_FAILURE); 342 goto err; 343 } 344 345 /* The certificate chain is only serialized if the leaf's SHA-256 isn't 346 * serialized instead. */ 347 if (in->cert_chain != NULL && !in->peer_sha256_valid) { 348 if (!CBB_add_asn1(&session, &child, kCertChainTag)) { 349 OPENSSL_PUT_ERROR(SSL, ERR_R_MALLOC_FAILURE); 350 goto err; 351 } 352 size_t i; 353 for (i = 0; i < sk_X509_num(in->cert_chain); i++) { 354 if (!add_X509(&child, sk_X509_value(in->cert_chain, i))) { 355 goto err; 356 } 357 } 358 } 359 360 if (!CBB_finish(&cbb, out_data, out_len)) { 361 OPENSSL_PUT_ERROR(SSL, ERR_R_MALLOC_FAILURE); 362 goto err; 363 } 364 return 1; 365 366 err: 367 CBB_cleanup(&cbb); 368 return 0; 369} 370 371int SSL_SESSION_to_bytes(const SSL_SESSION *in, uint8_t **out_data, 372 size_t *out_len) { 373 return SSL_SESSION_to_bytes_full(in, out_data, out_len, 0); 374} 375 376int SSL_SESSION_to_bytes_for_ticket(const SSL_SESSION *in, uint8_t **out_data, 377 size_t *out_len) { 378 return SSL_SESSION_to_bytes_full(in, out_data, out_len, 1); 379} 380 381int i2d_SSL_SESSION(SSL_SESSION *in, uint8_t **pp) { 382 uint8_t *out; 383 size_t len; 384 385 if (!SSL_SESSION_to_bytes(in, &out, &len)) { 386 return -1; 387 } 388 389 if (len > INT_MAX) { 390 OPENSSL_free(out); 391 OPENSSL_PUT_ERROR(SSL, ERR_R_OVERFLOW); 392 return -1; 393 } 394 395 if (pp) { 396 memcpy(*pp, out, len); 397 *pp += len; 398 } 399 OPENSSL_free(out); 400 401 return len; 402} 403 404/* SSL_SESSION_parse_string gets an optional ASN.1 OCTET STRING 405 * explicitly tagged with |tag| from |cbs| and saves it in |*out|. On 406 * entry, if |*out| is not NULL, it frees the existing contents. If 407 * the element was not found, it sets |*out| to NULL. It returns one 408 * on success, whether or not the element was found, and zero on 409 * decode error. */ 410static int SSL_SESSION_parse_string(CBS *cbs, char **out, unsigned tag) { 411 CBS value; 412 int present; 413 if (!CBS_get_optional_asn1_octet_string(cbs, &value, &present, tag)) { 414 OPENSSL_PUT_ERROR(SSL, SSL_R_INVALID_SSL_SESSION); 415 return 0; 416 } 417 if (present) { 418 if (CBS_contains_zero_byte(&value)) { 419 OPENSSL_PUT_ERROR(SSL, SSL_R_INVALID_SSL_SESSION); 420 return 0; 421 } 422 if (!CBS_strdup(&value, out)) { 423 OPENSSL_PUT_ERROR(SSL, ERR_R_MALLOC_FAILURE); 424 return 0; 425 } 426 } else { 427 OPENSSL_free(*out); 428 *out = NULL; 429 } 430 return 1; 431} 432 433/* SSL_SESSION_parse_string gets an optional ASN.1 OCTET STRING 434 * explicitly tagged with |tag| from |cbs| and stows it in |*out_ptr| 435 * and |*out_len|. If |*out_ptr| is not NULL, it frees the existing 436 * contents. On entry, if the element was not found, it sets 437 * |*out_ptr| to NULL. It returns one on success, whether or not the 438 * element was found, and zero on decode error. */ 439static int SSL_SESSION_parse_octet_string(CBS *cbs, uint8_t **out_ptr, 440 size_t *out_len, unsigned tag) { 441 CBS value; 442 if (!CBS_get_optional_asn1_octet_string(cbs, &value, NULL, tag)) { 443 OPENSSL_PUT_ERROR(SSL, SSL_R_INVALID_SSL_SESSION); 444 return 0; 445 } 446 if (!CBS_stow(&value, out_ptr, out_len)) { 447 OPENSSL_PUT_ERROR(SSL, ERR_R_MALLOC_FAILURE); 448 return 0; 449 } 450 return 1; 451} 452 453/* SSL_SESSION_parse_bounded_octet_string parses an optional ASN.1 OCTET STRING 454 * explicitly tagged with |tag| of size at most |max_out|. */ 455static int SSL_SESSION_parse_bounded_octet_string( 456 CBS *cbs, uint8_t *out, unsigned *out_len, unsigned max_out, unsigned tag) { 457 CBS value; 458 if (!CBS_get_optional_asn1_octet_string(cbs, &value, NULL, tag) || 459 CBS_len(&value) > max_out) { 460 OPENSSL_PUT_ERROR(SSL, SSL_R_INVALID_SSL_SESSION); 461 return 0; 462 } 463 memcpy(out, CBS_data(&value), CBS_len(&value)); 464 *out_len = (unsigned)CBS_len(&value); 465 return 1; 466} 467 468static int SSL_SESSION_parse_long(CBS *cbs, long *out, unsigned tag, 469 long default_value) { 470 uint64_t value; 471 if (!CBS_get_optional_asn1_uint64(cbs, &value, tag, 472 (uint64_t)default_value) || 473 value > LONG_MAX) { 474 OPENSSL_PUT_ERROR(SSL, SSL_R_INVALID_SSL_SESSION); 475 return 0; 476 } 477 *out = (long)value; 478 return 1; 479} 480 481static int SSL_SESSION_parse_u32(CBS *cbs, uint32_t *out, unsigned tag, 482 uint32_t default_value) { 483 uint64_t value; 484 if (!CBS_get_optional_asn1_uint64(cbs, &value, tag, 485 (uint64_t)default_value) || 486 value > 0xffffffff) { 487 OPENSSL_PUT_ERROR(SSL, SSL_R_INVALID_SSL_SESSION); 488 return 0; 489 } 490 *out = (uint32_t)value; 491 return 1; 492} 493 494static X509 *parse_x509(CBS *cbs) { 495 if (CBS_len(cbs) > LONG_MAX) { 496 OPENSSL_PUT_ERROR(SSL, SSL_R_INVALID_SSL_SESSION); 497 return NULL; 498 } 499 const uint8_t *ptr = CBS_data(cbs); 500 X509 *ret = d2i_X509(NULL, &ptr, (long)CBS_len(cbs)); 501 if (ret == NULL) { 502 return NULL; 503 } 504 CBS_skip(cbs, ptr - CBS_data(cbs)); 505 return ret; 506} 507 508static SSL_SESSION *SSL_SESSION_parse(CBS *cbs) { 509 SSL_SESSION *ret = SSL_SESSION_new(); 510 if (ret == NULL) { 511 goto err; 512 } 513 514 CBS session; 515 uint64_t version, ssl_version; 516 if (!CBS_get_asn1(cbs, &session, CBS_ASN1_SEQUENCE) || 517 !CBS_get_asn1_uint64(&session, &version) || 518 version != kVersion || 519 !CBS_get_asn1_uint64(&session, &ssl_version)) { 520 OPENSSL_PUT_ERROR(SSL, SSL_R_INVALID_SSL_SESSION); 521 goto err; 522 } 523 /* Only support SSLv3/TLS and DTLS. */ 524 if ((ssl_version >> 8) != SSL3_VERSION_MAJOR && 525 (ssl_version >> 8) != (DTLS1_VERSION >> 8)) { 526 OPENSSL_PUT_ERROR(SSL, SSL_R_UNKNOWN_SSL_VERSION); 527 goto err; 528 } 529 ret->ssl_version = ssl_version; 530 531 CBS cipher; 532 uint16_t cipher_value; 533 if (!CBS_get_asn1(&session, &cipher, CBS_ASN1_OCTETSTRING) || 534 !CBS_get_u16(&cipher, &cipher_value) || 535 CBS_len(&cipher) != 0) { 536 OPENSSL_PUT_ERROR(SSL, SSL_R_INVALID_SSL_SESSION); 537 goto err; 538 } 539 ret->cipher = SSL_get_cipher_by_value(cipher_value); 540 if (ret->cipher == NULL) { 541 OPENSSL_PUT_ERROR(SSL, SSL_R_UNSUPPORTED_CIPHER); 542 goto err; 543 } 544 545 CBS session_id, master_key; 546 if (!CBS_get_asn1(&session, &session_id, CBS_ASN1_OCTETSTRING) || 547 CBS_len(&session_id) > SSL3_MAX_SSL_SESSION_ID_LENGTH || 548 !CBS_get_asn1(&session, &master_key, CBS_ASN1_OCTETSTRING) || 549 CBS_len(&master_key) > SSL_MAX_MASTER_KEY_LENGTH) { 550 OPENSSL_PUT_ERROR(SSL, SSL_R_INVALID_SSL_SESSION); 551 goto err; 552 } 553 memcpy(ret->session_id, CBS_data(&session_id), CBS_len(&session_id)); 554 ret->session_id_length = CBS_len(&session_id); 555 memcpy(ret->master_key, CBS_data(&master_key), CBS_len(&master_key)); 556 ret->master_key_length = CBS_len(&master_key); 557 558 if (!SSL_SESSION_parse_long(&session, &ret->time, kTimeTag, time(NULL)) || 559 !SSL_SESSION_parse_long(&session, &ret->timeout, kTimeoutTag, 3)) { 560 OPENSSL_PUT_ERROR(SSL, SSL_R_INVALID_SSL_SESSION); 561 goto err; 562 } 563 564 CBS peer; 565 int has_peer; 566 if (!CBS_get_optional_asn1(&session, &peer, &has_peer, kPeerTag)) { 567 OPENSSL_PUT_ERROR(SSL, SSL_R_INVALID_SSL_SESSION); 568 goto err; 569 } 570 X509_free(ret->peer); 571 ret->peer = NULL; 572 if (has_peer) { 573 ret->peer = parse_x509(&peer); 574 if (ret->peer == NULL) { 575 goto err; 576 } 577 if (CBS_len(&peer) != 0) { 578 OPENSSL_PUT_ERROR(SSL, SSL_R_INVALID_SSL_SESSION); 579 goto err; 580 } 581 } 582 583 if (!SSL_SESSION_parse_bounded_octet_string( 584 &session, ret->sid_ctx, &ret->sid_ctx_length, sizeof(ret->sid_ctx), 585 kSessionIDContextTag) || 586 !SSL_SESSION_parse_long(&session, &ret->verify_result, kVerifyResultTag, 587 X509_V_OK) || 588 !SSL_SESSION_parse_string(&session, &ret->tlsext_hostname, 589 kHostNameTag) || 590 !SSL_SESSION_parse_string(&session, &ret->psk_identity, 591 kPSKIdentityTag) || 592 !SSL_SESSION_parse_u32(&session, &ret->tlsext_tick_lifetime_hint, 593 kTicketLifetimeHintTag, 0) || 594 !SSL_SESSION_parse_octet_string(&session, &ret->tlsext_tick, 595 &ret->tlsext_ticklen, kTicketTag)) { 596 goto err; 597 } 598 599 if (CBS_peek_asn1_tag(&session, kPeerSHA256Tag)) { 600 CBS child, peer_sha256; 601 if (!CBS_get_asn1(&session, &child, kPeerSHA256Tag) || 602 !CBS_get_asn1(&child, &peer_sha256, CBS_ASN1_OCTETSTRING) || 603 CBS_len(&peer_sha256) != sizeof(ret->peer_sha256) || 604 CBS_len(&child) != 0) { 605 OPENSSL_PUT_ERROR(SSL, SSL_R_INVALID_SSL_SESSION); 606 goto err; 607 } 608 memcpy(ret->peer_sha256, CBS_data(&peer_sha256), sizeof(ret->peer_sha256)); 609 ret->peer_sha256_valid = 1; 610 } else { 611 ret->peer_sha256_valid = 0; 612 } 613 614 if (!SSL_SESSION_parse_bounded_octet_string( 615 &session, ret->original_handshake_hash, 616 &ret->original_handshake_hash_len, 617 sizeof(ret->original_handshake_hash), kOriginalHandshakeHashTag) || 618 !SSL_SESSION_parse_octet_string( 619 &session, &ret->tlsext_signed_cert_timestamp_list, 620 &ret->tlsext_signed_cert_timestamp_list_length, 621 kSignedCertTimestampListTag) || 622 !SSL_SESSION_parse_octet_string( 623 &session, &ret->ocsp_response, &ret->ocsp_response_length, 624 kOCSPResponseTag)) { 625 goto err; 626 } 627 628 int extended_master_secret; 629 if (!CBS_get_optional_asn1_bool(&session, &extended_master_secret, 630 kExtendedMasterSecretTag, 631 0 /* default to false */)) { 632 OPENSSL_PUT_ERROR(SSL, SSL_R_INVALID_SSL_SESSION); 633 goto err; 634 } 635 ret->extended_master_secret = !!extended_master_secret; 636 637 if (!SSL_SESSION_parse_u32(&session, &ret->key_exchange_info, 638 kKeyExchangeInfoTag, 0)) { 639 OPENSSL_PUT_ERROR(SSL, SSL_R_INVALID_SSL_SESSION); 640 goto err; 641 } 642 643 CBS cert_chain; 644 int has_cert_chain; 645 if (!CBS_get_optional_asn1(&session, &cert_chain, &has_cert_chain, 646 kCertChainTag)) { 647 OPENSSL_PUT_ERROR(SSL, SSL_R_INVALID_SSL_SESSION); 648 goto err; 649 } 650 sk_X509_pop_free(ret->cert_chain, X509_free); 651 ret->cert_chain = NULL; 652 if (has_cert_chain) { 653 ret->cert_chain = sk_X509_new_null(); 654 if (ret->cert_chain == NULL) { 655 OPENSSL_PUT_ERROR(SSL, ERR_R_MALLOC_FAILURE); 656 goto err; 657 } 658 while (CBS_len(&cert_chain) > 0) { 659 X509 *x509 = parse_x509(&cert_chain); 660 if (x509 == NULL) { 661 goto err; 662 } 663 if (!sk_X509_push(ret->cert_chain, x509)) { 664 OPENSSL_PUT_ERROR(SSL, ERR_R_MALLOC_FAILURE); 665 X509_free(x509); 666 goto err; 667 } 668 } 669 } 670 671 if (CBS_len(&session) != 0) { 672 OPENSSL_PUT_ERROR(SSL, SSL_R_INVALID_SSL_SESSION); 673 goto err; 674 } 675 676 return ret; 677 678err: 679 SSL_SESSION_free(ret); 680 return NULL; 681} 682 683SSL_SESSION *SSL_SESSION_from_bytes(const uint8_t *in, size_t in_len) { 684 CBS cbs; 685 CBS_init(&cbs, in, in_len); 686 SSL_SESSION *ret = SSL_SESSION_parse(&cbs); 687 if (ret == NULL) { 688 return NULL; 689 } 690 if (CBS_len(&cbs) != 0) { 691 OPENSSL_PUT_ERROR(SSL, SSL_R_INVALID_SSL_SESSION); 692 SSL_SESSION_free(ret); 693 return NULL; 694 } 695 return ret; 696} 697 698SSL_SESSION *d2i_SSL_SESSION(SSL_SESSION **a, const uint8_t **pp, long length) { 699 if (length < 0) { 700 OPENSSL_PUT_ERROR(SSL, ERR_R_INTERNAL_ERROR); 701 return NULL; 702 } 703 704 CBS cbs; 705 CBS_init(&cbs, *pp, length); 706 707 SSL_SESSION *ret = SSL_SESSION_parse(&cbs); 708 if (ret == NULL) { 709 return NULL; 710 } 711 712 if (a) { 713 SSL_SESSION_free(*a); 714 *a = ret; 715 } 716 *pp = CBS_data(&cbs); 717 return ret; 718} 719