1 /* 2 * Copyright 2016-2024 The OpenSSL Project Authors. All Rights Reserved. 3 * 4 * Licensed under the Apache License 2.0 (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/ocsp.h> 11 #include "../ssl_local.h" 12 #include "internal/cryptlib.h" 13 #include "statem_local.h" 14 15 EXT_RETURN tls_construct_ctos_renegotiate(SSL *s, WPACKET *pkt, 16 unsigned int context, X509 *x, 17 size_t chainidx) 18 { 19 /* Add RI if renegotiating */ 20 if (!s->renegotiate) 21 return EXT_RETURN_NOT_SENT; 22 23 if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_renegotiate) 24 || !WPACKET_start_sub_packet_u16(pkt) 25 || !WPACKET_sub_memcpy_u8(pkt, s->s3.previous_client_finished, 26 s->s3.previous_client_finished_len) 27 || !WPACKET_close(pkt)) { 28 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 29 return EXT_RETURN_FAIL; 30 } 31 32 return EXT_RETURN_SENT; 33 } 34 35 EXT_RETURN tls_construct_ctos_server_name(SSL *s, WPACKET *pkt, 36 unsigned int context, X509 *x, 37 size_t chainidx) 38 { 39 if (s->ext.hostname == NULL) 40 return EXT_RETURN_NOT_SENT; 41 42 /* Add TLS extension servername to the Client Hello message */ 43 if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_server_name) 44 /* Sub-packet for server_name extension */ 45 || !WPACKET_start_sub_packet_u16(pkt) 46 /* Sub-packet for servername list (always 1 hostname)*/ 47 || !WPACKET_start_sub_packet_u16(pkt) 48 || !WPACKET_put_bytes_u8(pkt, TLSEXT_NAMETYPE_host_name) 49 || !WPACKET_sub_memcpy_u16(pkt, s->ext.hostname, 50 strlen(s->ext.hostname)) 51 || !WPACKET_close(pkt) 52 || !WPACKET_close(pkt)) { 53 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 54 return EXT_RETURN_FAIL; 55 } 56 57 return EXT_RETURN_SENT; 58 } 59 60 /* Push a Max Fragment Len extension into ClientHello */ 61 EXT_RETURN tls_construct_ctos_maxfragmentlen(SSL *s, WPACKET *pkt, 62 unsigned int context, X509 *x, 63 size_t chainidx) 64 { 65 if (s->ext.max_fragment_len_mode == TLSEXT_max_fragment_length_DISABLED) 66 return EXT_RETURN_NOT_SENT; 67 68 /* Add Max Fragment Length extension if client enabled it. */ 69 /*- 70 * 4 bytes for this extension type and extension length 71 * 1 byte for the Max Fragment Length code value. 72 */ 73 if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_max_fragment_length) 74 /* Sub-packet for Max Fragment Length extension (1 byte) */ 75 || !WPACKET_start_sub_packet_u16(pkt) 76 || !WPACKET_put_bytes_u8(pkt, s->ext.max_fragment_len_mode) 77 || !WPACKET_close(pkt)) { 78 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 79 return EXT_RETURN_FAIL; 80 } 81 82 return EXT_RETURN_SENT; 83 } 84 85 #ifndef OPENSSL_NO_SRP 86 EXT_RETURN tls_construct_ctos_srp(SSL *s, WPACKET *pkt, unsigned int context, 87 X509 *x, size_t chainidx) 88 { 89 /* Add SRP username if there is one */ 90 if (s->srp_ctx.login == NULL) 91 return EXT_RETURN_NOT_SENT; 92 93 if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_srp) 94 /* Sub-packet for SRP extension */ 95 || !WPACKET_start_sub_packet_u16(pkt) 96 || !WPACKET_start_sub_packet_u8(pkt) 97 /* login must not be zero...internal error if so */ 98 || !WPACKET_set_flags(pkt, WPACKET_FLAGS_NON_ZERO_LENGTH) 99 || !WPACKET_memcpy(pkt, s->srp_ctx.login, 100 strlen(s->srp_ctx.login)) 101 || !WPACKET_close(pkt) 102 || !WPACKET_close(pkt)) { 103 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 104 return EXT_RETURN_FAIL; 105 } 106 107 return EXT_RETURN_SENT; 108 } 109 #endif 110 111 static int use_ecc(SSL *s, int min_version, int max_version) 112 { 113 int i, end, ret = 0; 114 unsigned long alg_k, alg_a; 115 STACK_OF(SSL_CIPHER) *cipher_stack = NULL; 116 const uint16_t *pgroups = NULL; 117 size_t num_groups, j; 118 119 /* See if we support any ECC ciphersuites */ 120 if (s->version == SSL3_VERSION) 121 return 0; 122 123 cipher_stack = SSL_get1_supported_ciphers(s); 124 end = sk_SSL_CIPHER_num(cipher_stack); 125 for (i = 0; i < end; i++) { 126 const SSL_CIPHER *c = sk_SSL_CIPHER_value(cipher_stack, i); 127 128 alg_k = c->algorithm_mkey; 129 alg_a = c->algorithm_auth; 130 if ((alg_k & (SSL_kECDHE | SSL_kECDHEPSK)) 131 || (alg_a & SSL_aECDSA) 132 || c->min_tls >= TLS1_3_VERSION) { 133 ret = 1; 134 break; 135 } 136 } 137 sk_SSL_CIPHER_free(cipher_stack); 138 if (!ret) 139 return 0; 140 141 /* Check we have at least one EC supported group */ 142 tls1_get_supported_groups(s, &pgroups, &num_groups); 143 for (j = 0; j < num_groups; j++) { 144 uint16_t ctmp = pgroups[j]; 145 146 if (tls_valid_group(s, ctmp, min_version, max_version, 1, NULL) 147 && tls_group_allowed(s, ctmp, SSL_SECOP_CURVE_SUPPORTED)) 148 return 1; 149 } 150 151 return 0; 152 } 153 154 EXT_RETURN tls_construct_ctos_ec_pt_formats(SSL *s, WPACKET *pkt, 155 unsigned int context, X509 *x, 156 size_t chainidx) 157 { 158 const unsigned char *pformats; 159 size_t num_formats; 160 int reason, min_version, max_version; 161 162 reason = ssl_get_min_max_version(s, &min_version, &max_version, NULL); 163 if (reason != 0) { 164 SSLfatal(s, SSL_AD_INTERNAL_ERROR, reason); 165 return EXT_RETURN_FAIL; 166 } 167 if (!use_ecc(s, min_version, max_version)) 168 return EXT_RETURN_NOT_SENT; 169 170 /* Add TLS extension ECPointFormats to the ClientHello message */ 171 tls1_get_formatlist(s, &pformats, &num_formats); 172 173 if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_ec_point_formats) 174 /* Sub-packet for formats extension */ 175 || !WPACKET_start_sub_packet_u16(pkt) 176 || !WPACKET_sub_memcpy_u8(pkt, pformats, num_formats) 177 || !WPACKET_close(pkt)) { 178 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 179 return EXT_RETURN_FAIL; 180 } 181 182 return EXT_RETURN_SENT; 183 } 184 185 EXT_RETURN tls_construct_ctos_supported_groups(SSL *s, WPACKET *pkt, 186 unsigned int context, X509 *x, 187 size_t chainidx) 188 { 189 const uint16_t *pgroups = NULL; 190 size_t num_groups = 0, i, tls13added = 0, added = 0; 191 int min_version, max_version, reason; 192 193 reason = ssl_get_min_max_version(s, &min_version, &max_version, NULL); 194 if (reason != 0) { 195 SSLfatal(s, SSL_AD_INTERNAL_ERROR, reason); 196 return EXT_RETURN_FAIL; 197 } 198 199 /* 200 * We only support EC groups in TLSv1.2 or below, and in DTLS. Therefore 201 * if we don't have EC support then we don't send this extension. 202 */ 203 if (!use_ecc(s, min_version, max_version) 204 && (SSL_IS_DTLS(s) || max_version < TLS1_3_VERSION)) 205 return EXT_RETURN_NOT_SENT; 206 207 /* 208 * Add TLS extension supported_groups to the ClientHello message 209 */ 210 tls1_get_supported_groups(s, &pgroups, &num_groups); 211 212 if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_supported_groups) 213 /* Sub-packet for supported_groups extension */ 214 || !WPACKET_start_sub_packet_u16(pkt) 215 || !WPACKET_start_sub_packet_u16(pkt) 216 || !WPACKET_set_flags(pkt, WPACKET_FLAGS_NON_ZERO_LENGTH)) { 217 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 218 return EXT_RETURN_FAIL; 219 } 220 /* Copy group ID if supported */ 221 for (i = 0; i < num_groups; i++) { 222 uint16_t ctmp = pgroups[i]; 223 int okfortls13; 224 225 if (tls_valid_group(s, ctmp, min_version, max_version, 0, &okfortls13) 226 && tls_group_allowed(s, ctmp, SSL_SECOP_CURVE_SUPPORTED)) { 227 if (!WPACKET_put_bytes_u16(pkt, ctmp)) { 228 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 229 return EXT_RETURN_FAIL; 230 } 231 if (okfortls13 && max_version == TLS1_3_VERSION) 232 tls13added++; 233 added++; 234 } 235 } 236 if (!WPACKET_close(pkt) || !WPACKET_close(pkt)) { 237 if (added == 0) 238 SSLfatal_data(s, SSL_AD_INTERNAL_ERROR, SSL_R_NO_SUITABLE_GROUPS, 239 "No groups enabled for max supported SSL/TLS version"); 240 else 241 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 242 return EXT_RETURN_FAIL; 243 } 244 245 if (tls13added == 0 && max_version == TLS1_3_VERSION) { 246 SSLfatal_data(s, SSL_AD_INTERNAL_ERROR, SSL_R_NO_SUITABLE_GROUPS, 247 "No groups enabled for max supported SSL/TLS version"); 248 return EXT_RETURN_FAIL; 249 } 250 251 return EXT_RETURN_SENT; 252 } 253 254 EXT_RETURN tls_construct_ctos_session_ticket(SSL *s, WPACKET *pkt, 255 unsigned int context, X509 *x, 256 size_t chainidx) 257 { 258 size_t ticklen; 259 260 if (!tls_use_ticket(s)) 261 return EXT_RETURN_NOT_SENT; 262 263 if (!s->new_session && s->session != NULL 264 && s->session->ext.tick != NULL 265 && s->session->ssl_version != TLS1_3_VERSION) { 266 ticklen = s->session->ext.ticklen; 267 } else if (s->session && s->ext.session_ticket != NULL 268 && s->ext.session_ticket->data != NULL) { 269 ticklen = s->ext.session_ticket->length; 270 s->session->ext.tick = OPENSSL_malloc(ticklen); 271 if (s->session->ext.tick == NULL) { 272 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 273 return EXT_RETURN_FAIL; 274 } 275 memcpy(s->session->ext.tick, 276 s->ext.session_ticket->data, ticklen); 277 s->session->ext.ticklen = ticklen; 278 } else { 279 ticklen = 0; 280 } 281 282 if (ticklen == 0 && s->ext.session_ticket != NULL && 283 s->ext.session_ticket->data == NULL) 284 return EXT_RETURN_NOT_SENT; 285 286 if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_session_ticket) 287 || !WPACKET_sub_memcpy_u16(pkt, s->session->ext.tick, ticklen)) { 288 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 289 return EXT_RETURN_FAIL; 290 } 291 292 return EXT_RETURN_SENT; 293 } 294 295 EXT_RETURN tls_construct_ctos_sig_algs(SSL *s, WPACKET *pkt, 296 unsigned int context, X509 *x, 297 size_t chainidx) 298 { 299 size_t salglen; 300 const uint16_t *salg; 301 302 if (!SSL_CLIENT_USE_SIGALGS(s)) 303 return EXT_RETURN_NOT_SENT; 304 305 salglen = tls12_get_psigalgs(s, 1, &salg); 306 if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_signature_algorithms) 307 /* Sub-packet for sig-algs extension */ 308 || !WPACKET_start_sub_packet_u16(pkt) 309 /* Sub-packet for the actual list */ 310 || !WPACKET_start_sub_packet_u16(pkt) 311 || !tls12_copy_sigalgs(s, pkt, salg, salglen) 312 || !WPACKET_close(pkt) 313 || !WPACKET_close(pkt)) { 314 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 315 return EXT_RETURN_FAIL; 316 } 317 318 return EXT_RETURN_SENT; 319 } 320 321 #ifndef OPENSSL_NO_OCSP 322 EXT_RETURN tls_construct_ctos_status_request(SSL *s, WPACKET *pkt, 323 unsigned int context, X509 *x, 324 size_t chainidx) 325 { 326 int i; 327 328 /* This extension isn't defined for client Certificates */ 329 if (x != NULL) 330 return EXT_RETURN_NOT_SENT; 331 332 if (s->ext.status_type != TLSEXT_STATUSTYPE_ocsp) 333 return EXT_RETURN_NOT_SENT; 334 335 if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_status_request) 336 /* Sub-packet for status request extension */ 337 || !WPACKET_start_sub_packet_u16(pkt) 338 || !WPACKET_put_bytes_u8(pkt, TLSEXT_STATUSTYPE_ocsp) 339 /* Sub-packet for the ids */ 340 || !WPACKET_start_sub_packet_u16(pkt)) { 341 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 342 return EXT_RETURN_FAIL; 343 } 344 for (i = 0; i < sk_OCSP_RESPID_num(s->ext.ocsp.ids); i++) { 345 unsigned char *idbytes; 346 OCSP_RESPID *id = sk_OCSP_RESPID_value(s->ext.ocsp.ids, i); 347 int idlen = i2d_OCSP_RESPID(id, NULL); 348 349 if (idlen <= 0 350 /* Sub-packet for an individual id */ 351 || !WPACKET_sub_allocate_bytes_u16(pkt, idlen, &idbytes) 352 || i2d_OCSP_RESPID(id, &idbytes) != idlen) { 353 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 354 return EXT_RETURN_FAIL; 355 } 356 } 357 if (!WPACKET_close(pkt) 358 || !WPACKET_start_sub_packet_u16(pkt)) { 359 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 360 return EXT_RETURN_FAIL; 361 } 362 if (s->ext.ocsp.exts) { 363 unsigned char *extbytes; 364 int extlen = i2d_X509_EXTENSIONS(s->ext.ocsp.exts, NULL); 365 366 if (extlen < 0) { 367 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 368 return EXT_RETURN_FAIL; 369 } 370 if (!WPACKET_allocate_bytes(pkt, extlen, &extbytes) 371 || i2d_X509_EXTENSIONS(s->ext.ocsp.exts, &extbytes) 372 != extlen) { 373 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 374 return EXT_RETURN_FAIL; 375 } 376 } 377 if (!WPACKET_close(pkt) || !WPACKET_close(pkt)) { 378 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 379 return EXT_RETURN_FAIL; 380 } 381 382 return EXT_RETURN_SENT; 383 } 384 #endif 385 386 #ifndef OPENSSL_NO_NEXTPROTONEG 387 EXT_RETURN tls_construct_ctos_npn(SSL *s, WPACKET *pkt, unsigned int context, 388 X509 *x, size_t chainidx) 389 { 390 if (s->ctx->ext.npn_select_cb == NULL || !SSL_IS_FIRST_HANDSHAKE(s)) 391 return EXT_RETURN_NOT_SENT; 392 393 /* 394 * The client advertises an empty extension to indicate its support 395 * for Next Protocol Negotiation 396 */ 397 if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_next_proto_neg) 398 || !WPACKET_put_bytes_u16(pkt, 0)) { 399 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 400 return EXT_RETURN_FAIL; 401 } 402 403 return EXT_RETURN_SENT; 404 } 405 #endif 406 407 EXT_RETURN tls_construct_ctos_alpn(SSL *s, WPACKET *pkt, unsigned int context, 408 X509 *x, size_t chainidx) 409 { 410 s->s3.alpn_sent = 0; 411 412 if (s->ext.alpn == NULL || !SSL_IS_FIRST_HANDSHAKE(s)) 413 return EXT_RETURN_NOT_SENT; 414 415 if (!WPACKET_put_bytes_u16(pkt, 416 TLSEXT_TYPE_application_layer_protocol_negotiation) 417 /* Sub-packet ALPN extension */ 418 || !WPACKET_start_sub_packet_u16(pkt) 419 || !WPACKET_sub_memcpy_u16(pkt, s->ext.alpn, s->ext.alpn_len) 420 || !WPACKET_close(pkt)) { 421 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 422 return EXT_RETURN_FAIL; 423 } 424 s->s3.alpn_sent = 1; 425 426 return EXT_RETURN_SENT; 427 } 428 429 430 #ifndef OPENSSL_NO_SRTP 431 EXT_RETURN tls_construct_ctos_use_srtp(SSL *s, WPACKET *pkt, 432 unsigned int context, X509 *x, 433 size_t chainidx) 434 { 435 STACK_OF(SRTP_PROTECTION_PROFILE) *clnt = SSL_get_srtp_profiles(s); 436 int i, end; 437 438 if (clnt == NULL) 439 return EXT_RETURN_NOT_SENT; 440 441 if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_use_srtp) 442 /* Sub-packet for SRTP extension */ 443 || !WPACKET_start_sub_packet_u16(pkt) 444 /* Sub-packet for the protection profile list */ 445 || !WPACKET_start_sub_packet_u16(pkt)) { 446 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 447 return EXT_RETURN_FAIL; 448 } 449 450 end = sk_SRTP_PROTECTION_PROFILE_num(clnt); 451 for (i = 0; i < end; i++) { 452 const SRTP_PROTECTION_PROFILE *prof = 453 sk_SRTP_PROTECTION_PROFILE_value(clnt, i); 454 455 if (prof == NULL || !WPACKET_put_bytes_u16(pkt, prof->id)) { 456 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 457 return EXT_RETURN_FAIL; 458 } 459 } 460 if (!WPACKET_close(pkt) 461 /* Add an empty use_mki value */ 462 || !WPACKET_put_bytes_u8(pkt, 0) 463 || !WPACKET_close(pkt)) { 464 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 465 return EXT_RETURN_FAIL; 466 } 467 468 return EXT_RETURN_SENT; 469 } 470 #endif 471 472 EXT_RETURN tls_construct_ctos_etm(SSL *s, WPACKET *pkt, unsigned int context, 473 X509 *x, size_t chainidx) 474 { 475 if (s->options & SSL_OP_NO_ENCRYPT_THEN_MAC) 476 return EXT_RETURN_NOT_SENT; 477 478 if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_encrypt_then_mac) 479 || !WPACKET_put_bytes_u16(pkt, 0)) { 480 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 481 return EXT_RETURN_FAIL; 482 } 483 484 return EXT_RETURN_SENT; 485 } 486 487 #ifndef OPENSSL_NO_CT 488 EXT_RETURN tls_construct_ctos_sct(SSL *s, WPACKET *pkt, unsigned int context, 489 X509 *x, size_t chainidx) 490 { 491 if (s->ct_validation_callback == NULL) 492 return EXT_RETURN_NOT_SENT; 493 494 /* Not defined for client Certificates */ 495 if (x != NULL) 496 return EXT_RETURN_NOT_SENT; 497 498 if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_signed_certificate_timestamp) 499 || !WPACKET_put_bytes_u16(pkt, 0)) { 500 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 501 return EXT_RETURN_FAIL; 502 } 503 504 return EXT_RETURN_SENT; 505 } 506 #endif 507 508 EXT_RETURN tls_construct_ctos_ems(SSL *s, WPACKET *pkt, unsigned int context, 509 X509 *x, size_t chainidx) 510 { 511 if (s->options & SSL_OP_NO_EXTENDED_MASTER_SECRET) 512 return EXT_RETURN_NOT_SENT; 513 514 if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_extended_master_secret) 515 || !WPACKET_put_bytes_u16(pkt, 0)) { 516 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 517 return EXT_RETURN_FAIL; 518 } 519 520 return EXT_RETURN_SENT; 521 } 522 523 EXT_RETURN tls_construct_ctos_supported_versions(SSL *s, WPACKET *pkt, 524 unsigned int context, X509 *x, 525 size_t chainidx) 526 { 527 int currv, min_version, max_version, reason; 528 529 reason = ssl_get_min_max_version(s, &min_version, &max_version, NULL); 530 if (reason != 0) { 531 SSLfatal(s, SSL_AD_INTERNAL_ERROR, reason); 532 return EXT_RETURN_FAIL; 533 } 534 535 /* 536 * Don't include this if we can't negotiate TLSv1.3. We can do a straight 537 * comparison here because we will never be called in DTLS. 538 */ 539 if (max_version < TLS1_3_VERSION) 540 return EXT_RETURN_NOT_SENT; 541 542 if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_supported_versions) 543 || !WPACKET_start_sub_packet_u16(pkt) 544 || !WPACKET_start_sub_packet_u8(pkt)) { 545 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 546 return EXT_RETURN_FAIL; 547 } 548 549 for (currv = max_version; currv >= min_version; currv--) { 550 if (!WPACKET_put_bytes_u16(pkt, currv)) { 551 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 552 return EXT_RETURN_FAIL; 553 } 554 } 555 if (!WPACKET_close(pkt) || !WPACKET_close(pkt)) { 556 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 557 return EXT_RETURN_FAIL; 558 } 559 560 return EXT_RETURN_SENT; 561 } 562 563 /* 564 * Construct a psk_kex_modes extension. 565 */ 566 EXT_RETURN tls_construct_ctos_psk_kex_modes(SSL *s, WPACKET *pkt, 567 unsigned int context, X509 *x, 568 size_t chainidx) 569 { 570 #ifndef OPENSSL_NO_TLS1_3 571 int nodhe = s->options & SSL_OP_ALLOW_NO_DHE_KEX; 572 573 if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_psk_kex_modes) 574 || !WPACKET_start_sub_packet_u16(pkt) 575 || !WPACKET_start_sub_packet_u8(pkt) 576 || !WPACKET_put_bytes_u8(pkt, TLSEXT_KEX_MODE_KE_DHE) 577 || (nodhe && !WPACKET_put_bytes_u8(pkt, TLSEXT_KEX_MODE_KE)) 578 || !WPACKET_close(pkt) 579 || !WPACKET_close(pkt)) { 580 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 581 return EXT_RETURN_FAIL; 582 } 583 584 s->ext.psk_kex_mode = TLSEXT_KEX_MODE_FLAG_KE_DHE; 585 if (nodhe) 586 s->ext.psk_kex_mode |= TLSEXT_KEX_MODE_FLAG_KE; 587 #endif 588 589 return EXT_RETURN_SENT; 590 } 591 592 #ifndef OPENSSL_NO_TLS1_3 593 static int add_key_share(SSL *s, WPACKET *pkt, unsigned int curve_id) 594 { 595 unsigned char *encoded_point = NULL; 596 EVP_PKEY *key_share_key = NULL; 597 size_t encodedlen; 598 599 if (s->s3.tmp.pkey != NULL) { 600 if (!ossl_assert(s->hello_retry_request == SSL_HRR_PENDING)) { 601 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 602 return 0; 603 } 604 /* 605 * Could happen if we got an HRR that wasn't requesting a new key_share 606 */ 607 key_share_key = s->s3.tmp.pkey; 608 } else { 609 key_share_key = ssl_generate_pkey_group(s, curve_id); 610 if (key_share_key == NULL) { 611 /* SSLfatal() already called */ 612 return 0; 613 } 614 } 615 616 /* Encode the public key. */ 617 encodedlen = EVP_PKEY_get1_encoded_public_key(key_share_key, 618 &encoded_point); 619 if (encodedlen == 0) { 620 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EC_LIB); 621 goto err; 622 } 623 624 /* Create KeyShareEntry */ 625 if (!WPACKET_put_bytes_u16(pkt, curve_id) 626 || !WPACKET_sub_memcpy_u16(pkt, encoded_point, encodedlen)) { 627 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 628 goto err; 629 } 630 631 /* 632 * When changing to send more than one key_share we're 633 * going to need to be able to save more than one EVP_PKEY. For now 634 * we reuse the existing tmp.pkey 635 */ 636 s->s3.tmp.pkey = key_share_key; 637 s->s3.group_id = curve_id; 638 OPENSSL_free(encoded_point); 639 640 return 1; 641 err: 642 if (s->s3.tmp.pkey == NULL) 643 EVP_PKEY_free(key_share_key); 644 OPENSSL_free(encoded_point); 645 return 0; 646 } 647 #endif 648 649 EXT_RETURN tls_construct_ctos_key_share(SSL *s, WPACKET *pkt, 650 unsigned int context, X509 *x, 651 size_t chainidx) 652 { 653 #ifndef OPENSSL_NO_TLS1_3 654 size_t i, num_groups = 0; 655 const uint16_t *pgroups = NULL; 656 uint16_t curve_id = 0; 657 658 /* key_share extension */ 659 if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_key_share) 660 /* Extension data sub-packet */ 661 || !WPACKET_start_sub_packet_u16(pkt) 662 /* KeyShare list sub-packet */ 663 || !WPACKET_start_sub_packet_u16(pkt)) { 664 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 665 return EXT_RETURN_FAIL; 666 } 667 668 tls1_get_supported_groups(s, &pgroups, &num_groups); 669 670 /* 671 * Make the number of key_shares sent configurable. For 672 * now, we just send one 673 */ 674 if (s->s3.group_id != 0) { 675 curve_id = s->s3.group_id; 676 } else { 677 for (i = 0; i < num_groups; i++) { 678 679 if (!tls_group_allowed(s, pgroups[i], SSL_SECOP_CURVE_SUPPORTED)) 680 continue; 681 682 if (!tls_valid_group(s, pgroups[i], TLS1_3_VERSION, TLS1_3_VERSION, 683 0, NULL)) 684 continue; 685 686 curve_id = pgroups[i]; 687 break; 688 } 689 } 690 691 if (curve_id == 0) { 692 SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_NO_SUITABLE_KEY_SHARE); 693 return EXT_RETURN_FAIL; 694 } 695 696 if (!add_key_share(s, pkt, curve_id)) { 697 /* SSLfatal() already called */ 698 return EXT_RETURN_FAIL; 699 } 700 701 if (!WPACKET_close(pkt) || !WPACKET_close(pkt)) { 702 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 703 return EXT_RETURN_FAIL; 704 } 705 return EXT_RETURN_SENT; 706 #else 707 return EXT_RETURN_NOT_SENT; 708 #endif 709 } 710 711 EXT_RETURN tls_construct_ctos_cookie(SSL *s, WPACKET *pkt, unsigned int context, 712 X509 *x, size_t chainidx) 713 { 714 EXT_RETURN ret = EXT_RETURN_FAIL; 715 716 /* Should only be set if we've had an HRR */ 717 if (s->ext.tls13_cookie_len == 0) 718 return EXT_RETURN_NOT_SENT; 719 720 if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_cookie) 721 /* Extension data sub-packet */ 722 || !WPACKET_start_sub_packet_u16(pkt) 723 || !WPACKET_sub_memcpy_u16(pkt, s->ext.tls13_cookie, 724 s->ext.tls13_cookie_len) 725 || !WPACKET_close(pkt)) { 726 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 727 goto end; 728 } 729 730 ret = EXT_RETURN_SENT; 731 end: 732 OPENSSL_free(s->ext.tls13_cookie); 733 s->ext.tls13_cookie = NULL; 734 s->ext.tls13_cookie_len = 0; 735 736 return ret; 737 } 738 739 EXT_RETURN tls_construct_ctos_early_data(SSL *s, WPACKET *pkt, 740 unsigned int context, X509 *x, 741 size_t chainidx) 742 { 743 #ifndef OPENSSL_NO_PSK 744 char identity[PSK_MAX_IDENTITY_LEN + 1]; 745 #endif /* OPENSSL_NO_PSK */ 746 const unsigned char *id = NULL; 747 size_t idlen = 0; 748 SSL_SESSION *psksess = NULL; 749 SSL_SESSION *edsess = NULL; 750 const EVP_MD *handmd = NULL; 751 752 if (s->hello_retry_request == SSL_HRR_PENDING) 753 handmd = ssl_handshake_md(s); 754 755 if (s->psk_use_session_cb != NULL 756 && (!s->psk_use_session_cb(s, handmd, &id, &idlen, &psksess) 757 || (psksess != NULL 758 && psksess->ssl_version != TLS1_3_VERSION))) { 759 SSL_SESSION_free(psksess); 760 SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_PSK); 761 return EXT_RETURN_FAIL; 762 } 763 764 #ifndef OPENSSL_NO_PSK 765 if (psksess == NULL && s->psk_client_callback != NULL) { 766 unsigned char psk[PSK_MAX_PSK_LEN]; 767 size_t psklen = 0; 768 769 memset(identity, 0, sizeof(identity)); 770 psklen = s->psk_client_callback(s, NULL, identity, sizeof(identity) - 1, 771 psk, sizeof(psk)); 772 773 if (psklen > PSK_MAX_PSK_LEN) { 774 SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, ERR_R_INTERNAL_ERROR); 775 return EXT_RETURN_FAIL; 776 } else if (psklen > 0) { 777 const unsigned char tls13_aes128gcmsha256_id[] = { 0x13, 0x01 }; 778 const SSL_CIPHER *cipher; 779 780 idlen = strlen(identity); 781 if (idlen > PSK_MAX_IDENTITY_LEN) { 782 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 783 return EXT_RETURN_FAIL; 784 } 785 id = (unsigned char *)identity; 786 787 /* 788 * We found a PSK using an old style callback. We don't know 789 * the digest so we default to SHA256 as per the TLSv1.3 spec 790 */ 791 cipher = SSL_CIPHER_find(s, tls13_aes128gcmsha256_id); 792 if (cipher == NULL) { 793 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 794 return EXT_RETURN_FAIL; 795 } 796 797 psksess = SSL_SESSION_new(); 798 if (psksess == NULL 799 || !SSL_SESSION_set1_master_key(psksess, psk, psklen) 800 || !SSL_SESSION_set_cipher(psksess, cipher) 801 || !SSL_SESSION_set_protocol_version(psksess, TLS1_3_VERSION)) { 802 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 803 OPENSSL_cleanse(psk, psklen); 804 return EXT_RETURN_FAIL; 805 } 806 OPENSSL_cleanse(psk, psklen); 807 } 808 } 809 #endif /* OPENSSL_NO_PSK */ 810 811 SSL_SESSION_free(s->psksession); 812 s->psksession = psksess; 813 if (psksess != NULL) { 814 OPENSSL_free(s->psksession_id); 815 s->psksession_id = OPENSSL_memdup(id, idlen); 816 if (s->psksession_id == NULL) { 817 s->psksession_id_len = 0; 818 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 819 return EXT_RETURN_FAIL; 820 } 821 s->psksession_id_len = idlen; 822 } 823 824 if (s->early_data_state != SSL_EARLY_DATA_CONNECTING 825 || (s->session->ext.max_early_data == 0 826 && (psksess == NULL || psksess->ext.max_early_data == 0))) { 827 s->max_early_data = 0; 828 return EXT_RETURN_NOT_SENT; 829 } 830 edsess = s->session->ext.max_early_data != 0 ? s->session : psksess; 831 s->max_early_data = edsess->ext.max_early_data; 832 833 if (edsess->ext.hostname != NULL) { 834 if (s->ext.hostname == NULL 835 || (s->ext.hostname != NULL 836 && strcmp(s->ext.hostname, edsess->ext.hostname) != 0)) { 837 SSLfatal(s, SSL_AD_INTERNAL_ERROR, 838 SSL_R_INCONSISTENT_EARLY_DATA_SNI); 839 return EXT_RETURN_FAIL; 840 } 841 } 842 843 if ((s->ext.alpn == NULL && edsess->ext.alpn_selected != NULL)) { 844 SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_INCONSISTENT_EARLY_DATA_ALPN); 845 return EXT_RETURN_FAIL; 846 } 847 848 /* 849 * Verify that we are offering an ALPN protocol consistent with the early 850 * data. 851 */ 852 if (edsess->ext.alpn_selected != NULL) { 853 PACKET prots, alpnpkt; 854 int found = 0; 855 856 if (!PACKET_buf_init(&prots, s->ext.alpn, s->ext.alpn_len)) { 857 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 858 return EXT_RETURN_FAIL; 859 } 860 while (PACKET_get_length_prefixed_1(&prots, &alpnpkt)) { 861 if (PACKET_equal(&alpnpkt, edsess->ext.alpn_selected, 862 edsess->ext.alpn_selected_len)) { 863 found = 1; 864 break; 865 } 866 } 867 if (!found) { 868 SSLfatal(s, SSL_AD_INTERNAL_ERROR, 869 SSL_R_INCONSISTENT_EARLY_DATA_ALPN); 870 return EXT_RETURN_FAIL; 871 } 872 } 873 874 if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_early_data) 875 || !WPACKET_start_sub_packet_u16(pkt) 876 || !WPACKET_close(pkt)) { 877 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 878 return EXT_RETURN_FAIL; 879 } 880 881 /* 882 * We set this to rejected here. Later, if the server acknowledges the 883 * extension, we set it to accepted. 884 */ 885 s->ext.early_data = SSL_EARLY_DATA_REJECTED; 886 s->ext.early_data_ok = 1; 887 888 return EXT_RETURN_SENT; 889 } 890 891 #define F5_WORKAROUND_MIN_MSG_LEN 0xff 892 #define F5_WORKAROUND_MAX_MSG_LEN 0x200 893 894 /* 895 * PSK pre binder overhead = 896 * 2 bytes for TLSEXT_TYPE_psk 897 * 2 bytes for extension length 898 * 2 bytes for identities list length 899 * 2 bytes for identity length 900 * 4 bytes for obfuscated_ticket_age 901 * 2 bytes for binder list length 902 * 1 byte for binder length 903 * The above excludes the number of bytes for the identity itself and the 904 * subsequent binder bytes 905 */ 906 #define PSK_PRE_BINDER_OVERHEAD (2 + 2 + 2 + 2 + 4 + 2 + 1) 907 908 EXT_RETURN tls_construct_ctos_padding(SSL *s, WPACKET *pkt, 909 unsigned int context, X509 *x, 910 size_t chainidx) 911 { 912 unsigned char *padbytes; 913 size_t hlen; 914 915 if ((s->options & SSL_OP_TLSEXT_PADDING) == 0) 916 return EXT_RETURN_NOT_SENT; 917 918 /* 919 * Add padding to workaround bugs in F5 terminators. See RFC7685. 920 * This code calculates the length of all extensions added so far but 921 * excludes the PSK extension (because that MUST be written last). Therefore 922 * this extension MUST always appear second to last. 923 */ 924 if (!WPACKET_get_total_written(pkt, &hlen)) { 925 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 926 return EXT_RETURN_FAIL; 927 } 928 929 /* 930 * If we're going to send a PSK then that will be written out after this 931 * extension, so we need to calculate how long it is going to be. 932 */ 933 if (s->session->ssl_version == TLS1_3_VERSION 934 && s->session->ext.ticklen != 0 935 && s->session->cipher != NULL) { 936 const EVP_MD *md = ssl_md(s->ctx, s->session->cipher->algorithm2); 937 938 if (md != NULL) { 939 /* 940 * Add the fixed PSK overhead, the identity length and the binder 941 * length. 942 */ 943 hlen += PSK_PRE_BINDER_OVERHEAD + s->session->ext.ticklen 944 + EVP_MD_get_size(md); 945 } 946 } 947 948 if (hlen > F5_WORKAROUND_MIN_MSG_LEN && hlen < F5_WORKAROUND_MAX_MSG_LEN) { 949 /* Calculate the amount of padding we need to add */ 950 hlen = F5_WORKAROUND_MAX_MSG_LEN - hlen; 951 952 /* 953 * Take off the size of extension header itself (2 bytes for type and 954 * 2 bytes for length bytes), but ensure that the extension is at least 955 * 1 byte long so as not to have an empty extension last (WebSphere 7.x, 956 * 8.x are intolerant of that condition) 957 */ 958 if (hlen > 4) 959 hlen -= 4; 960 else 961 hlen = 1; 962 963 if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_padding) 964 || !WPACKET_sub_allocate_bytes_u16(pkt, hlen, &padbytes)) { 965 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 966 return EXT_RETURN_FAIL; 967 } 968 memset(padbytes, 0, hlen); 969 } 970 971 return EXT_RETURN_SENT; 972 } 973 974 /* 975 * Construct the pre_shared_key extension 976 */ 977 EXT_RETURN tls_construct_ctos_psk(SSL *s, WPACKET *pkt, unsigned int context, 978 X509 *x, size_t chainidx) 979 { 980 #ifndef OPENSSL_NO_TLS1_3 981 uint32_t agesec, agems = 0; 982 size_t reshashsize = 0, pskhashsize = 0, binderoffset, msglen; 983 unsigned char *resbinder = NULL, *pskbinder = NULL, *msgstart = NULL; 984 const EVP_MD *handmd = NULL, *mdres = NULL, *mdpsk = NULL; 985 int dores = 0; 986 987 s->ext.tick_identity = 0; 988 989 /* 990 * Note: At this stage of the code we only support adding a single 991 * resumption PSK. If we add support for multiple PSKs then the length 992 * calculations in the padding extension will need to be adjusted. 993 */ 994 995 /* 996 * If this is an incompatible or new session then we have nothing to resume 997 * so don't add this extension. 998 */ 999 if (s->session->ssl_version != TLS1_3_VERSION 1000 || (s->session->ext.ticklen == 0 && s->psksession == NULL)) 1001 return EXT_RETURN_NOT_SENT; 1002 1003 if (s->hello_retry_request == SSL_HRR_PENDING) 1004 handmd = ssl_handshake_md(s); 1005 1006 if (s->session->ext.ticklen != 0) { 1007 /* Get the digest associated with the ciphersuite in the session */ 1008 if (s->session->cipher == NULL) { 1009 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 1010 return EXT_RETURN_FAIL; 1011 } 1012 mdres = ssl_md(s->ctx, s->session->cipher->algorithm2); 1013 if (mdres == NULL) { 1014 /* 1015 * Don't recognize this cipher so we can't use the session. 1016 * Ignore it 1017 */ 1018 goto dopsksess; 1019 } 1020 1021 if (s->hello_retry_request == SSL_HRR_PENDING && mdres != handmd) { 1022 /* 1023 * Selected ciphersuite hash does not match the hash for the session 1024 * so we can't use it. 1025 */ 1026 goto dopsksess; 1027 } 1028 1029 /* 1030 * Technically the C standard just says time() returns a time_t and says 1031 * nothing about the encoding of that type. In practice most 1032 * implementations follow POSIX which holds it as an integral type in 1033 * seconds since epoch. We've already made the assumption that we can do 1034 * this in multiple places in the code, so portability shouldn't be an 1035 * issue. 1036 */ 1037 agesec = (uint32_t)(time(NULL) - s->session->time); 1038 /* 1039 * We calculate the age in seconds but the server may work in ms. Due to 1040 * rounding errors we could overestimate the age by up to 1s. It is 1041 * better to underestimate it. Otherwise, if the RTT is very short, when 1042 * the server calculates the age reported by the client it could be 1043 * bigger than the age calculated on the server - which should never 1044 * happen. 1045 */ 1046 if (agesec > 0) 1047 agesec--; 1048 1049 if (s->session->ext.tick_lifetime_hint < agesec) { 1050 /* Ticket is too old. Ignore it. */ 1051 goto dopsksess; 1052 } 1053 1054 /* 1055 * Calculate age in ms. We're just doing it to nearest second. Should be 1056 * good enough. 1057 */ 1058 agems = agesec * (uint32_t)1000; 1059 1060 if (agesec != 0 && agems / (uint32_t)1000 != agesec) { 1061 /* 1062 * Overflow. Shouldn't happen unless this is a *really* old session. 1063 * If so we just ignore it. 1064 */ 1065 goto dopsksess; 1066 } 1067 1068 /* 1069 * Obfuscate the age. Overflow here is fine, this addition is supposed 1070 * to be mod 2^32. 1071 */ 1072 agems += s->session->ext.tick_age_add; 1073 1074 reshashsize = EVP_MD_get_size(mdres); 1075 s->ext.tick_identity++; 1076 dores = 1; 1077 } 1078 1079 dopsksess: 1080 if (!dores && s->psksession == NULL) 1081 return EXT_RETURN_NOT_SENT; 1082 1083 if (s->psksession != NULL) { 1084 mdpsk = ssl_md(s->ctx, s->psksession->cipher->algorithm2); 1085 if (mdpsk == NULL) { 1086 /* 1087 * Don't recognize this cipher so we can't use the session. 1088 * If this happens it's an application bug. 1089 */ 1090 SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_PSK); 1091 return EXT_RETURN_FAIL; 1092 } 1093 1094 if (s->hello_retry_request == SSL_HRR_PENDING && mdpsk != handmd) { 1095 /* 1096 * Selected ciphersuite hash does not match the hash for the PSK 1097 * session. This is an application bug. 1098 */ 1099 SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_PSK); 1100 return EXT_RETURN_FAIL; 1101 } 1102 1103 pskhashsize = EVP_MD_get_size(mdpsk); 1104 } 1105 1106 /* Create the extension, but skip over the binder for now */ 1107 if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_psk) 1108 || !WPACKET_start_sub_packet_u16(pkt) 1109 || !WPACKET_start_sub_packet_u16(pkt)) { 1110 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 1111 return EXT_RETURN_FAIL; 1112 } 1113 1114 if (dores) { 1115 if (!WPACKET_sub_memcpy_u16(pkt, s->session->ext.tick, 1116 s->session->ext.ticklen) 1117 || !WPACKET_put_bytes_u32(pkt, agems)) { 1118 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 1119 return EXT_RETURN_FAIL; 1120 } 1121 } 1122 1123 if (s->psksession != NULL) { 1124 if (!WPACKET_sub_memcpy_u16(pkt, s->psksession_id, 1125 s->psksession_id_len) 1126 || !WPACKET_put_bytes_u32(pkt, 0)) { 1127 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 1128 return EXT_RETURN_FAIL; 1129 } 1130 s->ext.tick_identity++; 1131 } 1132 1133 if (!WPACKET_close(pkt) 1134 || !WPACKET_get_total_written(pkt, &binderoffset) 1135 || !WPACKET_start_sub_packet_u16(pkt) 1136 || (dores 1137 && !WPACKET_sub_allocate_bytes_u8(pkt, reshashsize, &resbinder)) 1138 || (s->psksession != NULL 1139 && !WPACKET_sub_allocate_bytes_u8(pkt, pskhashsize, &pskbinder)) 1140 || !WPACKET_close(pkt) 1141 || !WPACKET_close(pkt) 1142 || !WPACKET_get_total_written(pkt, &msglen) 1143 /* 1144 * We need to fill in all the sub-packet lengths now so we can 1145 * calculate the HMAC of the message up to the binders 1146 */ 1147 || !WPACKET_fill_lengths(pkt)) { 1148 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 1149 return EXT_RETURN_FAIL; 1150 } 1151 1152 msgstart = WPACKET_get_curr(pkt) - msglen; 1153 1154 if (dores 1155 && tls_psk_do_binder(s, mdres, msgstart, binderoffset, NULL, 1156 resbinder, s->session, 1, 0) != 1) { 1157 /* SSLfatal() already called */ 1158 return EXT_RETURN_FAIL; 1159 } 1160 1161 if (s->psksession != NULL 1162 && tls_psk_do_binder(s, mdpsk, msgstart, binderoffset, NULL, 1163 pskbinder, s->psksession, 1, 1) != 1) { 1164 /* SSLfatal() already called */ 1165 return EXT_RETURN_FAIL; 1166 } 1167 1168 return EXT_RETURN_SENT; 1169 #else 1170 return EXT_RETURN_NOT_SENT; 1171 #endif 1172 } 1173 1174 EXT_RETURN tls_construct_ctos_post_handshake_auth(SSL *s, WPACKET *pkt, 1175 ossl_unused unsigned int context, 1176 ossl_unused X509 *x, 1177 ossl_unused size_t chainidx) 1178 { 1179 #ifndef OPENSSL_NO_TLS1_3 1180 if (!s->pha_enabled) 1181 return EXT_RETURN_NOT_SENT; 1182 1183 /* construct extension - 0 length, no contents */ 1184 if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_post_handshake_auth) 1185 || !WPACKET_start_sub_packet_u16(pkt) 1186 || !WPACKET_close(pkt)) { 1187 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 1188 return EXT_RETURN_FAIL; 1189 } 1190 1191 s->post_handshake_auth = SSL_PHA_EXT_SENT; 1192 1193 return EXT_RETURN_SENT; 1194 #else 1195 return EXT_RETURN_NOT_SENT; 1196 #endif 1197 } 1198 1199 1200 /* 1201 * Parse the server's renegotiation binding and abort if it's not right 1202 */ 1203 int tls_parse_stoc_renegotiate(SSL *s, PACKET *pkt, unsigned int context, 1204 X509 *x, size_t chainidx) 1205 { 1206 size_t expected_len = s->s3.previous_client_finished_len 1207 + s->s3.previous_server_finished_len; 1208 size_t ilen; 1209 const unsigned char *data; 1210 1211 /* Check for logic errors */ 1212 if (!ossl_assert(expected_len == 0 1213 || s->s3.previous_client_finished_len != 0) 1214 || !ossl_assert(expected_len == 0 1215 || s->s3.previous_server_finished_len != 0)) { 1216 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 1217 return 0; 1218 } 1219 1220 /* Parse the length byte */ 1221 if (!PACKET_get_1_len(pkt, &ilen)) { 1222 SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_RENEGOTIATION_ENCODING_ERR); 1223 return 0; 1224 } 1225 1226 /* Consistency check */ 1227 if (PACKET_remaining(pkt) != ilen) { 1228 SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_RENEGOTIATION_ENCODING_ERR); 1229 return 0; 1230 } 1231 1232 /* Check that the extension matches */ 1233 if (ilen != expected_len) { 1234 SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_RENEGOTIATION_MISMATCH); 1235 return 0; 1236 } 1237 1238 if (!PACKET_get_bytes(pkt, &data, s->s3.previous_client_finished_len) 1239 || memcmp(data, s->s3.previous_client_finished, 1240 s->s3.previous_client_finished_len) != 0) { 1241 SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_RENEGOTIATION_MISMATCH); 1242 return 0; 1243 } 1244 1245 if (!PACKET_get_bytes(pkt, &data, s->s3.previous_server_finished_len) 1246 || memcmp(data, s->s3.previous_server_finished, 1247 s->s3.previous_server_finished_len) != 0) { 1248 SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_RENEGOTIATION_MISMATCH); 1249 return 0; 1250 } 1251 s->s3.send_connection_binding = 1; 1252 1253 return 1; 1254 } 1255 1256 /* Parse the server's max fragment len extension packet */ 1257 int tls_parse_stoc_maxfragmentlen(SSL *s, PACKET *pkt, unsigned int context, 1258 X509 *x, size_t chainidx) 1259 { 1260 unsigned int value; 1261 1262 if (PACKET_remaining(pkt) != 1 || !PACKET_get_1(pkt, &value)) { 1263 SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); 1264 return 0; 1265 } 1266 1267 /* |value| should contains a valid max-fragment-length code. */ 1268 if (!IS_MAX_FRAGMENT_LENGTH_EXT_VALID(value)) { 1269 SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, 1270 SSL_R_SSL3_EXT_INVALID_MAX_FRAGMENT_LENGTH); 1271 return 0; 1272 } 1273 1274 /* Must be the same value as client-configured one who was sent to server */ 1275 /*- 1276 * RFC 6066: if a client receives a maximum fragment length negotiation 1277 * response that differs from the length it requested, ... 1278 * It must abort with SSL_AD_ILLEGAL_PARAMETER alert 1279 */ 1280 if (value != s->ext.max_fragment_len_mode) { 1281 SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, 1282 SSL_R_SSL3_EXT_INVALID_MAX_FRAGMENT_LENGTH); 1283 return 0; 1284 } 1285 1286 /* 1287 * Maximum Fragment Length Negotiation succeeded. 1288 * The negotiated Maximum Fragment Length is binding now. 1289 */ 1290 s->session->ext.max_fragment_len_mode = value; 1291 1292 return 1; 1293 } 1294 1295 int tls_parse_stoc_server_name(SSL *s, PACKET *pkt, unsigned int context, 1296 X509 *x, size_t chainidx) 1297 { 1298 if (s->ext.hostname == NULL) { 1299 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 1300 return 0; 1301 } 1302 1303 if (PACKET_remaining(pkt) > 0) { 1304 SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); 1305 return 0; 1306 } 1307 1308 if (!s->hit) { 1309 if (s->session->ext.hostname != NULL) { 1310 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 1311 return 0; 1312 } 1313 s->session->ext.hostname = OPENSSL_strdup(s->ext.hostname); 1314 if (s->session->ext.hostname == NULL) { 1315 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 1316 return 0; 1317 } 1318 } 1319 1320 return 1; 1321 } 1322 1323 int tls_parse_stoc_ec_pt_formats(SSL *s, PACKET *pkt, unsigned int context, 1324 X509 *x, size_t chainidx) 1325 { 1326 size_t ecpointformats_len; 1327 PACKET ecptformatlist; 1328 1329 if (!PACKET_as_length_prefixed_1(pkt, &ecptformatlist)) { 1330 SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); 1331 return 0; 1332 } 1333 if (!s->hit) { 1334 ecpointformats_len = PACKET_remaining(&ecptformatlist); 1335 if (ecpointformats_len == 0) { 1336 SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_LENGTH); 1337 return 0; 1338 } 1339 1340 s->ext.peer_ecpointformats_len = 0; 1341 OPENSSL_free(s->ext.peer_ecpointformats); 1342 s->ext.peer_ecpointformats = OPENSSL_malloc(ecpointformats_len); 1343 if (s->ext.peer_ecpointformats == NULL) { 1344 s->ext.peer_ecpointformats_len = 0; 1345 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 1346 return 0; 1347 } 1348 1349 s->ext.peer_ecpointformats_len = ecpointformats_len; 1350 1351 if (!PACKET_copy_bytes(&ecptformatlist, 1352 s->ext.peer_ecpointformats, 1353 ecpointformats_len)) { 1354 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 1355 return 0; 1356 } 1357 } 1358 1359 return 1; 1360 } 1361 1362 int tls_parse_stoc_session_ticket(SSL *s, PACKET *pkt, unsigned int context, 1363 X509 *x, size_t chainidx) 1364 { 1365 if (s->ext.session_ticket_cb != NULL && 1366 !s->ext.session_ticket_cb(s, PACKET_data(pkt), 1367 PACKET_remaining(pkt), 1368 s->ext.session_ticket_cb_arg)) { 1369 SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_BAD_EXTENSION); 1370 return 0; 1371 } 1372 1373 if (!tls_use_ticket(s)) { 1374 SSLfatal(s, SSL_AD_UNSUPPORTED_EXTENSION, SSL_R_BAD_EXTENSION); 1375 return 0; 1376 } 1377 if (PACKET_remaining(pkt) > 0) { 1378 SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); 1379 return 0; 1380 } 1381 1382 s->ext.ticket_expected = 1; 1383 1384 return 1; 1385 } 1386 1387 #ifndef OPENSSL_NO_OCSP 1388 int tls_parse_stoc_status_request(SSL *s, PACKET *pkt, unsigned int context, 1389 X509 *x, size_t chainidx) 1390 { 1391 if (context == SSL_EXT_TLS1_3_CERTIFICATE_REQUEST) { 1392 /* We ignore this if the server sends a CertificateRequest */ 1393 return 1; 1394 } 1395 1396 /* 1397 * MUST only be sent if we've requested a status 1398 * request message. In TLS <= 1.2 it must also be empty. 1399 */ 1400 if (s->ext.status_type != TLSEXT_STATUSTYPE_ocsp) { 1401 SSLfatal(s, SSL_AD_UNSUPPORTED_EXTENSION, SSL_R_BAD_EXTENSION); 1402 return 0; 1403 } 1404 if (!SSL_IS_TLS13(s) && PACKET_remaining(pkt) > 0) { 1405 SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); 1406 return 0; 1407 } 1408 1409 if (SSL_IS_TLS13(s)) { 1410 /* We only know how to handle this if it's for the first Certificate in 1411 * the chain. We ignore any other responses. 1412 */ 1413 if (chainidx != 0) 1414 return 1; 1415 1416 /* SSLfatal() already called */ 1417 return tls_process_cert_status_body(s, pkt); 1418 } 1419 1420 /* Set flag to expect CertificateStatus message */ 1421 s->ext.status_expected = 1; 1422 1423 return 1; 1424 } 1425 #endif 1426 1427 1428 #ifndef OPENSSL_NO_CT 1429 int tls_parse_stoc_sct(SSL *s, PACKET *pkt, unsigned int context, X509 *x, 1430 size_t chainidx) 1431 { 1432 if (context == SSL_EXT_TLS1_3_CERTIFICATE_REQUEST) { 1433 /* We ignore this if the server sends it in a CertificateRequest */ 1434 return 1; 1435 } 1436 1437 /* 1438 * Only take it if we asked for it - i.e if there is no CT validation 1439 * callback set, then a custom extension MAY be processing it, so we 1440 * need to let control continue to flow to that. 1441 */ 1442 if (s->ct_validation_callback != NULL) { 1443 size_t size = PACKET_remaining(pkt); 1444 1445 /* Simply copy it off for later processing */ 1446 OPENSSL_free(s->ext.scts); 1447 s->ext.scts = NULL; 1448 1449 s->ext.scts_len = (uint16_t)size; 1450 if (size > 0) { 1451 s->ext.scts = OPENSSL_malloc(size); 1452 if (s->ext.scts == NULL) { 1453 s->ext.scts_len = 0; 1454 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE); 1455 return 0; 1456 } 1457 if (!PACKET_copy_bytes(pkt, s->ext.scts, size)) { 1458 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 1459 return 0; 1460 } 1461 } 1462 } else { 1463 ENDPOINT role = (context & SSL_EXT_TLS1_2_SERVER_HELLO) != 0 1464 ? ENDPOINT_CLIENT : ENDPOINT_BOTH; 1465 1466 /* 1467 * If we didn't ask for it then there must be a custom extension, 1468 * otherwise this is unsolicited. 1469 */ 1470 if (custom_ext_find(&s->cert->custext, role, 1471 TLSEXT_TYPE_signed_certificate_timestamp, 1472 NULL) == NULL) { 1473 SSLfatal(s, TLS1_AD_UNSUPPORTED_EXTENSION, SSL_R_BAD_EXTENSION); 1474 return 0; 1475 } 1476 1477 if (!custom_ext_parse(s, context, 1478 TLSEXT_TYPE_signed_certificate_timestamp, 1479 PACKET_data(pkt), PACKET_remaining(pkt), 1480 x, chainidx)) { 1481 /* SSLfatal already called */ 1482 return 0; 1483 } 1484 } 1485 1486 return 1; 1487 } 1488 #endif 1489 1490 1491 #ifndef OPENSSL_NO_NEXTPROTONEG 1492 /* 1493 * ssl_next_proto_validate validates a Next Protocol Negotiation block. No 1494 * elements of zero length are allowed and the set of elements must exactly 1495 * fill the length of the block. Returns 1 on success or 0 on failure. 1496 */ 1497 static int ssl_next_proto_validate(SSL *s, PACKET *pkt) 1498 { 1499 PACKET tmp_protocol; 1500 1501 while (PACKET_remaining(pkt)) { 1502 if (!PACKET_get_length_prefixed_1(pkt, &tmp_protocol) 1503 || PACKET_remaining(&tmp_protocol) == 0) { 1504 SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); 1505 return 0; 1506 } 1507 } 1508 1509 return 1; 1510 } 1511 1512 int tls_parse_stoc_npn(SSL *s, PACKET *pkt, unsigned int context, X509 *x, 1513 size_t chainidx) 1514 { 1515 unsigned char *selected; 1516 unsigned char selected_len; 1517 PACKET tmppkt; 1518 1519 /* Check if we are in a renegotiation. If so ignore this extension */ 1520 if (!SSL_IS_FIRST_HANDSHAKE(s)) 1521 return 1; 1522 1523 /* We must have requested it. */ 1524 if (s->ctx->ext.npn_select_cb == NULL) { 1525 SSLfatal(s, SSL_AD_UNSUPPORTED_EXTENSION, SSL_R_BAD_EXTENSION); 1526 return 0; 1527 } 1528 1529 /* The data must be valid */ 1530 tmppkt = *pkt; 1531 if (!ssl_next_proto_validate(s, &tmppkt)) { 1532 /* SSLfatal() already called */ 1533 return 0; 1534 } 1535 if (s->ctx->ext.npn_select_cb(s, &selected, &selected_len, 1536 PACKET_data(pkt), 1537 PACKET_remaining(pkt), 1538 s->ctx->ext.npn_select_cb_arg) != 1539 SSL_TLSEXT_ERR_OK 1540 || selected_len == 0) { 1541 SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_BAD_EXTENSION); 1542 return 0; 1543 } 1544 1545 /* 1546 * Could be non-NULL if server has sent multiple NPN extensions in 1547 * a single Serverhello 1548 */ 1549 OPENSSL_free(s->ext.npn); 1550 s->ext.npn = OPENSSL_malloc(selected_len); 1551 if (s->ext.npn == NULL) { 1552 s->ext.npn_len = 0; 1553 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 1554 return 0; 1555 } 1556 1557 memcpy(s->ext.npn, selected, selected_len); 1558 s->ext.npn_len = selected_len; 1559 s->s3.npn_seen = 1; 1560 1561 return 1; 1562 } 1563 #endif 1564 1565 int tls_parse_stoc_alpn(SSL *s, PACKET *pkt, unsigned int context, X509 *x, 1566 size_t chainidx) 1567 { 1568 size_t len; 1569 PACKET confpkt, protpkt; 1570 int valid = 0; 1571 1572 /* We must have requested it. */ 1573 if (!s->s3.alpn_sent) { 1574 SSLfatal(s, SSL_AD_UNSUPPORTED_EXTENSION, SSL_R_BAD_EXTENSION); 1575 return 0; 1576 } 1577 /*- 1578 * The extension data consists of: 1579 * uint16 list_length 1580 * uint8 proto_length; 1581 * uint8 proto[proto_length]; 1582 */ 1583 if (!PACKET_get_net_2_len(pkt, &len) 1584 || PACKET_remaining(pkt) != len || !PACKET_get_1_len(pkt, &len) 1585 || PACKET_remaining(pkt) != len) { 1586 SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); 1587 return 0; 1588 } 1589 1590 /* It must be a protocol that we sent */ 1591 if (!PACKET_buf_init(&confpkt, s->ext.alpn, s->ext.alpn_len)) { 1592 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 1593 return 0; 1594 } 1595 while (PACKET_get_length_prefixed_1(&confpkt, &protpkt)) { 1596 if (PACKET_remaining(&protpkt) != len) 1597 continue; 1598 if (memcmp(PACKET_data(pkt), PACKET_data(&protpkt), len) == 0) { 1599 /* Valid protocol found */ 1600 valid = 1; 1601 break; 1602 } 1603 } 1604 1605 if (!valid) { 1606 /* The protocol sent from the server does not match one we advertised */ 1607 SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); 1608 return 0; 1609 } 1610 1611 OPENSSL_free(s->s3.alpn_selected); 1612 s->s3.alpn_selected = OPENSSL_malloc(len); 1613 if (s->s3.alpn_selected == NULL) { 1614 s->s3.alpn_selected_len = 0; 1615 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 1616 return 0; 1617 } 1618 if (!PACKET_copy_bytes(pkt, s->s3.alpn_selected, len)) { 1619 SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); 1620 return 0; 1621 } 1622 s->s3.alpn_selected_len = len; 1623 1624 if (s->session->ext.alpn_selected == NULL 1625 || s->session->ext.alpn_selected_len != len 1626 || memcmp(s->session->ext.alpn_selected, s->s3.alpn_selected, len) 1627 != 0) { 1628 /* ALPN not consistent with the old session so cannot use early_data */ 1629 s->ext.early_data_ok = 0; 1630 } 1631 if (!s->hit) { 1632 /* 1633 * This is a new session and so alpn_selected should have been 1634 * initialised to NULL. We should update it with the selected ALPN. 1635 */ 1636 if (!ossl_assert(s->session->ext.alpn_selected == NULL)) { 1637 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 1638 return 0; 1639 } 1640 s->session->ext.alpn_selected = 1641 OPENSSL_memdup(s->s3.alpn_selected, s->s3.alpn_selected_len); 1642 if (s->session->ext.alpn_selected == NULL) { 1643 s->session->ext.alpn_selected_len = 0; 1644 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 1645 return 0; 1646 } 1647 s->session->ext.alpn_selected_len = s->s3.alpn_selected_len; 1648 } 1649 1650 return 1; 1651 } 1652 1653 #ifndef OPENSSL_NO_SRTP 1654 int tls_parse_stoc_use_srtp(SSL *s, PACKET *pkt, unsigned int context, X509 *x, 1655 size_t chainidx) 1656 { 1657 unsigned int id, ct, mki; 1658 int i; 1659 STACK_OF(SRTP_PROTECTION_PROFILE) *clnt; 1660 SRTP_PROTECTION_PROFILE *prof; 1661 1662 if (!PACKET_get_net_2(pkt, &ct) || ct != 2 1663 || !PACKET_get_net_2(pkt, &id) 1664 || !PACKET_get_1(pkt, &mki) 1665 || PACKET_remaining(pkt) != 0) { 1666 SSLfatal(s, SSL_AD_DECODE_ERROR, 1667 SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST); 1668 return 0; 1669 } 1670 1671 if (mki != 0) { 1672 /* Must be no MKI, since we never offer one */ 1673 SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_SRTP_MKI_VALUE); 1674 return 0; 1675 } 1676 1677 /* Throw an error if the server gave us an unsolicited extension */ 1678 clnt = SSL_get_srtp_profiles(s); 1679 if (clnt == NULL) { 1680 SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_NO_SRTP_PROFILES); 1681 return 0; 1682 } 1683 1684 /* 1685 * Check to see if the server gave us something we support (and 1686 * presumably offered) 1687 */ 1688 for (i = 0; i < sk_SRTP_PROTECTION_PROFILE_num(clnt); i++) { 1689 prof = sk_SRTP_PROTECTION_PROFILE_value(clnt, i); 1690 1691 if (prof->id == id) { 1692 s->srtp_profile = prof; 1693 return 1; 1694 } 1695 } 1696 1697 SSLfatal(s, SSL_AD_DECODE_ERROR, 1698 SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST); 1699 return 0; 1700 } 1701 #endif 1702 1703 int tls_parse_stoc_etm(SSL *s, PACKET *pkt, unsigned int context, X509 *x, 1704 size_t chainidx) 1705 { 1706 /* Ignore if inappropriate ciphersuite */ 1707 if (!(s->options & SSL_OP_NO_ENCRYPT_THEN_MAC) 1708 && s->s3.tmp.new_cipher->algorithm_mac != SSL_AEAD 1709 && s->s3.tmp.new_cipher->algorithm_enc != SSL_RC4 1710 && s->s3.tmp.new_cipher->algorithm_enc != SSL_eGOST2814789CNT 1711 && s->s3.tmp.new_cipher->algorithm_enc != SSL_eGOST2814789CNT12 1712 && s->s3.tmp.new_cipher->algorithm_enc != SSL_MAGMA 1713 && s->s3.tmp.new_cipher->algorithm_enc != SSL_KUZNYECHIK) 1714 s->ext.use_etm = 1; 1715 1716 return 1; 1717 } 1718 1719 int tls_parse_stoc_ems(SSL *s, PACKET *pkt, unsigned int context, X509 *x, 1720 size_t chainidx) 1721 { 1722 if (s->options & SSL_OP_NO_EXTENDED_MASTER_SECRET) 1723 return 1; 1724 s->s3.flags |= TLS1_FLAGS_RECEIVED_EXTMS; 1725 if (!s->hit) 1726 s->session->flags |= SSL_SESS_FLAG_EXTMS; 1727 1728 return 1; 1729 } 1730 1731 int tls_parse_stoc_supported_versions(SSL *s, PACKET *pkt, unsigned int context, 1732 X509 *x, size_t chainidx) 1733 { 1734 unsigned int version; 1735 1736 if (!PACKET_get_net_2(pkt, &version) 1737 || PACKET_remaining(pkt) != 0) { 1738 SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); 1739 return 0; 1740 } 1741 1742 /* 1743 * The only protocol version we support which is valid in this extension in 1744 * a ServerHello is TLSv1.3 therefore we shouldn't be getting anything else. 1745 */ 1746 if (version != TLS1_3_VERSION) { 1747 SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, 1748 SSL_R_BAD_PROTOCOL_VERSION_NUMBER); 1749 return 0; 1750 } 1751 1752 /* We ignore this extension for HRRs except to sanity check it */ 1753 if (context == SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST) 1754 return 1; 1755 1756 /* We just set it here. We validate it in ssl_choose_client_version */ 1757 s->version = version; 1758 1759 return 1; 1760 } 1761 1762 int tls_parse_stoc_key_share(SSL *s, PACKET *pkt, unsigned int context, X509 *x, 1763 size_t chainidx) 1764 { 1765 #ifndef OPENSSL_NO_TLS1_3 1766 unsigned int group_id; 1767 PACKET encoded_pt; 1768 EVP_PKEY *ckey = s->s3.tmp.pkey, *skey = NULL; 1769 const TLS_GROUP_INFO *ginf = NULL; 1770 1771 /* Sanity check */ 1772 if (ckey == NULL || s->s3.peer_tmp != NULL) { 1773 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 1774 return 0; 1775 } 1776 1777 if (!PACKET_get_net_2(pkt, &group_id)) { 1778 SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); 1779 return 0; 1780 } 1781 1782 if ((context & SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST) != 0) { 1783 const uint16_t *pgroups = NULL; 1784 size_t i, num_groups; 1785 1786 if (PACKET_remaining(pkt) != 0) { 1787 SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); 1788 return 0; 1789 } 1790 1791 /* 1792 * It is an error if the HelloRetryRequest wants a key_share that we 1793 * already sent in the first ClientHello 1794 */ 1795 if (group_id == s->s3.group_id) { 1796 SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_KEY_SHARE); 1797 return 0; 1798 } 1799 1800 /* Validate the selected group is one we support */ 1801 tls1_get_supported_groups(s, &pgroups, &num_groups); 1802 for (i = 0; i < num_groups; i++) { 1803 if (group_id == pgroups[i]) 1804 break; 1805 } 1806 if (i >= num_groups 1807 || !tls_group_allowed(s, group_id, SSL_SECOP_CURVE_SUPPORTED) 1808 || !tls_valid_group(s, group_id, TLS1_3_VERSION, TLS1_3_VERSION, 1809 0, NULL)) { 1810 SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_KEY_SHARE); 1811 return 0; 1812 } 1813 1814 s->s3.group_id = group_id; 1815 EVP_PKEY_free(s->s3.tmp.pkey); 1816 s->s3.tmp.pkey = NULL; 1817 return 1; 1818 } 1819 1820 if (group_id != s->s3.group_id) { 1821 /* 1822 * This isn't for the group that we sent in the original 1823 * key_share! 1824 */ 1825 SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_KEY_SHARE); 1826 return 0; 1827 } 1828 /* Retain this group in the SSL_SESSION */ 1829 if (!s->hit) { 1830 s->session->kex_group = group_id; 1831 } else if (group_id != s->session->kex_group) { 1832 /* 1833 * If this is a resumption but changed what group was used, we need 1834 * to record the new group in the session, but the session is not 1835 * a new session and could be in use by other threads. So, make 1836 * a copy of the session to record the new information so that it's 1837 * useful for any sessions resumed from tickets issued on this 1838 * connection. 1839 */ 1840 SSL_SESSION *new_sess; 1841 1842 if ((new_sess = ssl_session_dup(s->session, 0)) == NULL) { 1843 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE); 1844 return 0; 1845 } 1846 SSL_SESSION_free(s->session); 1847 s->session = new_sess; 1848 s->session->kex_group = group_id; 1849 } 1850 1851 if ((ginf = tls1_group_id_lookup(s->ctx, group_id)) == NULL) { 1852 SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_KEY_SHARE); 1853 return 0; 1854 } 1855 1856 if (!PACKET_as_length_prefixed_2(pkt, &encoded_pt) 1857 || PACKET_remaining(&encoded_pt) == 0) { 1858 SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); 1859 return 0; 1860 } 1861 1862 if (!ginf->is_kem) { 1863 /* Regular KEX */ 1864 skey = EVP_PKEY_new(); 1865 if (skey == NULL || EVP_PKEY_copy_parameters(skey, ckey) <= 0) { 1866 SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_COPY_PARAMETERS_FAILED); 1867 EVP_PKEY_free(skey); 1868 return 0; 1869 } 1870 1871 if (tls13_set_encoded_pub_key(skey, PACKET_data(&encoded_pt), 1872 PACKET_remaining(&encoded_pt)) <= 0) { 1873 SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_ECPOINT); 1874 EVP_PKEY_free(skey); 1875 return 0; 1876 } 1877 1878 if (ssl_derive(s, ckey, skey, 1) == 0) { 1879 /* SSLfatal() already called */ 1880 EVP_PKEY_free(skey); 1881 return 0; 1882 } 1883 s->s3.peer_tmp = skey; 1884 } else { 1885 /* KEM Mode */ 1886 const unsigned char *ct = PACKET_data(&encoded_pt); 1887 size_t ctlen = PACKET_remaining(&encoded_pt); 1888 1889 if (ssl_decapsulate(s, ckey, ct, ctlen, 1) == 0) { 1890 /* SSLfatal() already called */ 1891 return 0; 1892 } 1893 } 1894 s->s3.did_kex = 1; 1895 #endif 1896 1897 return 1; 1898 } 1899 1900 int tls_parse_stoc_cookie(SSL *s, PACKET *pkt, unsigned int context, X509 *x, 1901 size_t chainidx) 1902 { 1903 PACKET cookie; 1904 1905 if (!PACKET_as_length_prefixed_2(pkt, &cookie) 1906 || !PACKET_memdup(&cookie, &s->ext.tls13_cookie, 1907 &s->ext.tls13_cookie_len)) { 1908 SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); 1909 return 0; 1910 } 1911 1912 return 1; 1913 } 1914 1915 int tls_parse_stoc_early_data(SSL *s, PACKET *pkt, unsigned int context, 1916 X509 *x, size_t chainidx) 1917 { 1918 if (context == SSL_EXT_TLS1_3_NEW_SESSION_TICKET) { 1919 unsigned long max_early_data; 1920 1921 if (!PACKET_get_net_4(pkt, &max_early_data) 1922 || PACKET_remaining(pkt) != 0) { 1923 SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_INVALID_MAX_EARLY_DATA); 1924 return 0; 1925 } 1926 1927 s->session->ext.max_early_data = max_early_data; 1928 1929 return 1; 1930 } 1931 1932 if (PACKET_remaining(pkt) != 0) { 1933 SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); 1934 return 0; 1935 } 1936 1937 if (!s->ext.early_data_ok 1938 || !s->hit) { 1939 /* 1940 * If we get here then we didn't send early data, or we didn't resume 1941 * using the first identity, or the SNI/ALPN is not consistent so the 1942 * server should not be accepting it. 1943 */ 1944 SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_EXTENSION); 1945 return 0; 1946 } 1947 1948 s->ext.early_data = SSL_EARLY_DATA_ACCEPTED; 1949 1950 return 1; 1951 } 1952 1953 int tls_parse_stoc_psk(SSL *s, PACKET *pkt, unsigned int context, X509 *x, 1954 size_t chainidx) 1955 { 1956 #ifndef OPENSSL_NO_TLS1_3 1957 unsigned int identity; 1958 1959 if (!PACKET_get_net_2(pkt, &identity) || PACKET_remaining(pkt) != 0) { 1960 SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); 1961 return 0; 1962 } 1963 1964 if (identity >= (unsigned int)s->ext.tick_identity) { 1965 SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_PSK_IDENTITY); 1966 return 0; 1967 } 1968 1969 /* 1970 * Session resumption tickets are always sent before PSK tickets. If the 1971 * ticket index is 0 then it must be for a session resumption ticket if we 1972 * sent two tickets, or if we didn't send a PSK ticket. 1973 */ 1974 if (identity == 0 && (s->psksession == NULL || s->ext.tick_identity == 2)) { 1975 s->hit = 1; 1976 SSL_SESSION_free(s->psksession); 1977 s->psksession = NULL; 1978 return 1; 1979 } 1980 1981 if (s->psksession == NULL) { 1982 /* Should never happen */ 1983 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); 1984 return 0; 1985 } 1986 1987 /* 1988 * If we used the external PSK for sending early_data then s->early_secret 1989 * is already set up, so don't overwrite it. Otherwise we copy the 1990 * early_secret across that we generated earlier. 1991 */ 1992 if ((s->early_data_state != SSL_EARLY_DATA_WRITE_RETRY 1993 && s->early_data_state != SSL_EARLY_DATA_FINISHED_WRITING) 1994 || s->session->ext.max_early_data > 0 1995 || s->psksession->ext.max_early_data == 0) 1996 memcpy(s->early_secret, s->psksession->early_secret, EVP_MAX_MD_SIZE); 1997 1998 SSL_SESSION_free(s->session); 1999 s->session = s->psksession; 2000 s->psksession = NULL; 2001 s->hit = 1; 2002 /* Early data is only allowed if we used the first ticket */ 2003 if (identity != 0) 2004 s->ext.early_data_ok = 0; 2005 #endif 2006 2007 return 1; 2008 } 2009