1 /* Written by Dr Stephen N Henson (steve (at) openssl.org) for the OpenSSL 2 * project 2005. 3 */ 4 /* ==================================================================== 5 * Copyright (c) 2005 The OpenSSL Project. All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in 16 * the documentation and/or other materials provided with the 17 * distribution. 18 * 19 * 3. All advertising materials mentioning features or use of this 20 * software must display the following acknowledgment: 21 * "This product includes software developed by the OpenSSL Project 22 * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" 23 * 24 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to 25 * endorse or promote products derived from this software without 26 * prior written permission. For written permission, please contact 27 * licensing (at) OpenSSL.org. 28 * 29 * 5. Products derived from this software may not be called "OpenSSL" 30 * nor may "OpenSSL" appear in their names without prior written 31 * permission of the OpenSSL Project. 32 * 33 * 6. Redistributions of any form whatsoever must retain the following 34 * acknowledgment: 35 * "This product includes software developed by the OpenSSL Project 36 * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" 37 * 38 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY 39 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 40 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 41 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR 42 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 43 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 44 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 45 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 46 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 47 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 48 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 49 * OF THE POSSIBILITY OF SUCH DAMAGE. 50 * ==================================================================== 51 * 52 * This product includes cryptographic software written by Eric Young 53 * (eay (at) cryptsoft.com). This product includes software written by Tim 54 * Hudson (tjh (at) cryptsoft.com). */ 55 56 #include <openssl/rsa.h> 57 58 #include <assert.h> 59 #include <limits.h> 60 #include <string.h> 61 62 #include <openssl/bn.h> 63 #include <openssl/digest.h> 64 #include <openssl/err.h> 65 #include <openssl/mem.h> 66 #include <openssl/rand.h> 67 #include <openssl/sha.h> 68 69 #include "internal.h" 70 #include "../../internal.h" 71 72 73 #define RSA_PKCS1_PADDING_SIZE 11 74 75 int RSA_padding_add_PKCS1_type_1(uint8_t *to, size_t to_len, 76 const uint8_t *from, size_t from_len) { 77 // See RFC 8017, section 9.2. 78 if (to_len < RSA_PKCS1_PADDING_SIZE) { 79 OPENSSL_PUT_ERROR(RSA, RSA_R_KEY_SIZE_TOO_SMALL); 80 return 0; 81 } 82 83 if (from_len > to_len - RSA_PKCS1_PADDING_SIZE) { 84 OPENSSL_PUT_ERROR(RSA, RSA_R_DIGEST_TOO_BIG_FOR_RSA_KEY); 85 return 0; 86 } 87 88 to[0] = 0; 89 to[1] = 1; 90 OPENSSL_memset(to + 2, 0xff, to_len - 3 - from_len); 91 to[to_len - from_len - 1] = 0; 92 OPENSSL_memcpy(to + to_len - from_len, from, from_len); 93 return 1; 94 } 95 96 int RSA_padding_check_PKCS1_type_1(uint8_t *out, size_t *out_len, 97 size_t max_out, const uint8_t *from, 98 size_t from_len) { 99 // See RFC 8017, section 9.2. This is part of signature verification and thus 100 // does not need to run in constant-time. 101 if (from_len < 2) { 102 OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_SMALL); 103 return 0; 104 } 105 106 // Check the header. 107 if (from[0] != 0 || from[1] != 1) { 108 OPENSSL_PUT_ERROR(RSA, RSA_R_BLOCK_TYPE_IS_NOT_01); 109 return 0; 110 } 111 112 // Scan over padded data, looking for the 00. 113 size_t pad; 114 for (pad = 2 /* header */; pad < from_len; pad++) { 115 if (from[pad] == 0x00) { 116 break; 117 } 118 119 if (from[pad] != 0xff) { 120 OPENSSL_PUT_ERROR(RSA, RSA_R_BAD_FIXED_HEADER_DECRYPT); 121 return 0; 122 } 123 } 124 125 if (pad == from_len) { 126 OPENSSL_PUT_ERROR(RSA, RSA_R_NULL_BEFORE_BLOCK_MISSING); 127 return 0; 128 } 129 130 if (pad < 2 /* header */ + 8) { 131 OPENSSL_PUT_ERROR(RSA, RSA_R_BAD_PAD_BYTE_COUNT); 132 return 0; 133 } 134 135 // Skip over the 00. 136 pad++; 137 138 if (from_len - pad > max_out) { 139 OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_LARGE); 140 return 0; 141 } 142 143 OPENSSL_memcpy(out, from + pad, from_len - pad); 144 *out_len = from_len - pad; 145 return 1; 146 } 147 148 static int rand_nonzero(uint8_t *out, size_t len) { 149 if (!RAND_bytes(out, len)) { 150 return 0; 151 } 152 153 for (size_t i = 0; i < len; i++) { 154 while (out[i] == 0) { 155 if (!RAND_bytes(out + i, 1)) { 156 return 0; 157 } 158 } 159 } 160 161 return 1; 162 } 163 164 int RSA_padding_add_PKCS1_type_2(uint8_t *to, size_t to_len, 165 const uint8_t *from, size_t from_len) { 166 // See RFC 8017, section 7.2.1. 167 if (to_len < RSA_PKCS1_PADDING_SIZE) { 168 OPENSSL_PUT_ERROR(RSA, RSA_R_KEY_SIZE_TOO_SMALL); 169 return 0; 170 } 171 172 if (from_len > to_len - RSA_PKCS1_PADDING_SIZE) { 173 OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_LARGE); 174 return 0; 175 } 176 177 to[0] = 0; 178 to[1] = 2; 179 180 size_t padding_len = to_len - 3 - from_len; 181 if (!rand_nonzero(to + 2, padding_len)) { 182 return 0; 183 } 184 185 to[2 + padding_len] = 0; 186 OPENSSL_memcpy(to + to_len - from_len, from, from_len); 187 return 1; 188 } 189 190 int RSA_padding_check_PKCS1_type_2(uint8_t *out, size_t *out_len, 191 size_t max_out, const uint8_t *from, 192 size_t from_len) { 193 if (from_len == 0) { 194 OPENSSL_PUT_ERROR(RSA, RSA_R_EMPTY_PUBLIC_KEY); 195 return 0; 196 } 197 198 // PKCS#1 v1.5 decryption. See "PKCS #1 v2.2: RSA Cryptography 199 // Standard", section 7.2.2. 200 if (from_len < RSA_PKCS1_PADDING_SIZE) { 201 // |from| is zero-padded to the size of the RSA modulus, a public value, so 202 // this can be rejected in non-constant time. 203 OPENSSL_PUT_ERROR(RSA, RSA_R_KEY_SIZE_TOO_SMALL); 204 return 0; 205 } 206 207 crypto_word_t first_byte_is_zero = constant_time_eq_w(from[0], 0); 208 crypto_word_t second_byte_is_two = constant_time_eq_w(from[1], 2); 209 210 crypto_word_t zero_index = 0, looking_for_index = CONSTTIME_TRUE_W; 211 for (size_t i = 2; i < from_len; i++) { 212 crypto_word_t equals0 = constant_time_is_zero_w(from[i]); 213 zero_index = 214 constant_time_select_w(looking_for_index & equals0, i, zero_index); 215 looking_for_index = constant_time_select_w(equals0, 0, looking_for_index); 216 } 217 218 // The input must begin with 00 02. 219 crypto_word_t valid_index = first_byte_is_zero; 220 valid_index &= second_byte_is_two; 221 222 // We must have found the end of PS. 223 valid_index &= ~looking_for_index; 224 225 // PS must be at least 8 bytes long, and it starts two bytes into |from|. 226 valid_index &= constant_time_ge_w(zero_index, 2 + 8); 227 228 // Skip the zero byte. 229 zero_index++; 230 231 // NOTE: Although this logic attempts to be constant time, the API contracts 232 // of this function and |RSA_decrypt| with |RSA_PKCS1_PADDING| make it 233 // impossible to completely avoid Bleichenbacher's attack. Consumers should 234 // use |RSA_PADDING_NONE| and perform the padding check in constant-time 235 // combined with a swap to a random session key or other mitigation. 236 if (!valid_index) { 237 OPENSSL_PUT_ERROR(RSA, RSA_R_PKCS_DECODING_ERROR); 238 return 0; 239 } 240 241 const size_t msg_len = from_len - zero_index; 242 if (msg_len > max_out) { 243 // This shouldn't happen because this function is always called with 244 // |max_out| as the key size and |from_len| is bounded by the key size. 245 OPENSSL_PUT_ERROR(RSA, RSA_R_PKCS_DECODING_ERROR); 246 return 0; 247 } 248 249 OPENSSL_memcpy(out, &from[zero_index], msg_len); 250 *out_len = msg_len; 251 return 1; 252 } 253 254 int RSA_padding_add_none(uint8_t *to, size_t to_len, const uint8_t *from, 255 size_t from_len) { 256 if (from_len > to_len) { 257 OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_LARGE); 258 return 0; 259 } 260 261 if (from_len < to_len) { 262 OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_SMALL); 263 return 0; 264 } 265 266 OPENSSL_memcpy(to, from, from_len); 267 return 1; 268 } 269 270 static int PKCS1_MGF1(uint8_t *out, size_t len, const uint8_t *seed, 271 size_t seed_len, const EVP_MD *md) { 272 int ret = 0; 273 EVP_MD_CTX ctx; 274 EVP_MD_CTX_init(&ctx); 275 276 size_t md_len = EVP_MD_size(md); 277 278 for (uint32_t i = 0; len > 0; i++) { 279 uint8_t counter[4]; 280 counter[0] = (uint8_t)(i >> 24); 281 counter[1] = (uint8_t)(i >> 16); 282 counter[2] = (uint8_t)(i >> 8); 283 counter[3] = (uint8_t)i; 284 if (!EVP_DigestInit_ex(&ctx, md, NULL) || 285 !EVP_DigestUpdate(&ctx, seed, seed_len) || 286 !EVP_DigestUpdate(&ctx, counter, sizeof(counter))) { 287 goto err; 288 } 289 290 if (md_len <= len) { 291 if (!EVP_DigestFinal_ex(&ctx, out, NULL)) { 292 goto err; 293 } 294 out += md_len; 295 len -= md_len; 296 } else { 297 uint8_t digest[EVP_MAX_MD_SIZE]; 298 if (!EVP_DigestFinal_ex(&ctx, digest, NULL)) { 299 goto err; 300 } 301 OPENSSL_memcpy(out, digest, len); 302 len = 0; 303 } 304 } 305 306 ret = 1; 307 308 err: 309 EVP_MD_CTX_cleanup(&ctx); 310 return ret; 311 } 312 313 int RSA_padding_add_PKCS1_OAEP_mgf1(uint8_t *to, size_t to_len, 314 const uint8_t *from, size_t from_len, 315 const uint8_t *param, size_t param_len, 316 const EVP_MD *md, const EVP_MD *mgf1md) { 317 if (md == NULL) { 318 md = EVP_sha1(); 319 } 320 if (mgf1md == NULL) { 321 mgf1md = md; 322 } 323 324 size_t mdlen = EVP_MD_size(md); 325 326 if (to_len < 2 * mdlen + 2) { 327 OPENSSL_PUT_ERROR(RSA, RSA_R_KEY_SIZE_TOO_SMALL); 328 return 0; 329 } 330 331 size_t emlen = to_len - 1; 332 if (from_len > emlen - 2 * mdlen - 1) { 333 OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_LARGE); 334 return 0; 335 } 336 337 if (emlen < 2 * mdlen + 1) { 338 OPENSSL_PUT_ERROR(RSA, RSA_R_KEY_SIZE_TOO_SMALL); 339 return 0; 340 } 341 342 to[0] = 0; 343 uint8_t *seed = to + 1; 344 uint8_t *db = to + mdlen + 1; 345 346 if (!EVP_Digest(param, param_len, db, NULL, md, NULL)) { 347 return 0; 348 } 349 OPENSSL_memset(db + mdlen, 0, emlen - from_len - 2 * mdlen - 1); 350 db[emlen - from_len - mdlen - 1] = 0x01; 351 OPENSSL_memcpy(db + emlen - from_len - mdlen, from, from_len); 352 if (!RAND_bytes(seed, mdlen)) { 353 return 0; 354 } 355 356 uint8_t *dbmask = OPENSSL_malloc(emlen - mdlen); 357 if (dbmask == NULL) { 358 OPENSSL_PUT_ERROR(RSA, ERR_R_MALLOC_FAILURE); 359 return 0; 360 } 361 362 int ret = 0; 363 if (!PKCS1_MGF1(dbmask, emlen - mdlen, seed, mdlen, mgf1md)) { 364 goto out; 365 } 366 for (size_t i = 0; i < emlen - mdlen; i++) { 367 db[i] ^= dbmask[i]; 368 } 369 370 uint8_t seedmask[EVP_MAX_MD_SIZE]; 371 if (!PKCS1_MGF1(seedmask, mdlen, db, emlen - mdlen, mgf1md)) { 372 goto out; 373 } 374 for (size_t i = 0; i < mdlen; i++) { 375 seed[i] ^= seedmask[i]; 376 } 377 ret = 1; 378 379 out: 380 OPENSSL_free(dbmask); 381 return ret; 382 } 383 384 int RSA_padding_check_PKCS1_OAEP_mgf1(uint8_t *out, size_t *out_len, 385 size_t max_out, const uint8_t *from, 386 size_t from_len, const uint8_t *param, 387 size_t param_len, const EVP_MD *md, 388 const EVP_MD *mgf1md) { 389 uint8_t *db = NULL; 390 391 if (md == NULL) { 392 md = EVP_sha1(); 393 } 394 if (mgf1md == NULL) { 395 mgf1md = md; 396 } 397 398 size_t mdlen = EVP_MD_size(md); 399 400 // The encoded message is one byte smaller than the modulus to ensure that it 401 // doesn't end up greater than the modulus. Thus there's an extra "+1" here 402 // compared to https://tools.ietf.org/html/rfc2437#section-9.1.1.2. 403 if (from_len < 1 + 2*mdlen + 1) { 404 // 'from_len' is the length of the modulus, i.e. does not depend on the 405 // particular ciphertext. 406 goto decoding_err; 407 } 408 409 size_t dblen = from_len - mdlen - 1; 410 db = OPENSSL_malloc(dblen); 411 if (db == NULL) { 412 OPENSSL_PUT_ERROR(RSA, ERR_R_MALLOC_FAILURE); 413 goto err; 414 } 415 416 const uint8_t *maskedseed = from + 1; 417 const uint8_t *maskeddb = from + 1 + mdlen; 418 419 uint8_t seed[EVP_MAX_MD_SIZE]; 420 if (!PKCS1_MGF1(seed, mdlen, maskeddb, dblen, mgf1md)) { 421 goto err; 422 } 423 for (size_t i = 0; i < mdlen; i++) { 424 seed[i] ^= maskedseed[i]; 425 } 426 427 if (!PKCS1_MGF1(db, dblen, seed, mdlen, mgf1md)) { 428 goto err; 429 } 430 for (size_t i = 0; i < dblen; i++) { 431 db[i] ^= maskeddb[i]; 432 } 433 434 uint8_t phash[EVP_MAX_MD_SIZE]; 435 if (!EVP_Digest(param, param_len, phash, NULL, md, NULL)) { 436 goto err; 437 } 438 439 crypto_word_t bad = ~constant_time_is_zero_w(CRYPTO_memcmp(db, phash, mdlen)); 440 bad |= ~constant_time_is_zero_w(from[0]); 441 442 crypto_word_t looking_for_one_byte = CONSTTIME_TRUE_W; 443 size_t one_index = 0; 444 for (size_t i = mdlen; i < dblen; i++) { 445 crypto_word_t equals1 = constant_time_eq_w(db[i], 1); 446 crypto_word_t equals0 = constant_time_eq_w(db[i], 0); 447 one_index = 448 constant_time_select_w(looking_for_one_byte & equals1, i, one_index); 449 looking_for_one_byte = 450 constant_time_select_w(equals1, 0, looking_for_one_byte); 451 bad |= looking_for_one_byte & ~equals0; 452 } 453 454 bad |= looking_for_one_byte; 455 456 if (bad) { 457 goto decoding_err; 458 } 459 460 one_index++; 461 size_t mlen = dblen - one_index; 462 if (max_out < mlen) { 463 OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_LARGE); 464 goto err; 465 } 466 467 OPENSSL_memcpy(out, db + one_index, mlen); 468 *out_len = mlen; 469 OPENSSL_free(db); 470 return 1; 471 472 decoding_err: 473 // to avoid chosen ciphertext attacks, the error message should not reveal 474 // which kind of decoding error happened 475 OPENSSL_PUT_ERROR(RSA, RSA_R_OAEP_DECODING_ERROR); 476 err: 477 OPENSSL_free(db); 478 return 0; 479 } 480 481 static const uint8_t kPSSZeroes[] = {0, 0, 0, 0, 0, 0, 0, 0}; 482 483 int RSA_verify_PKCS1_PSS_mgf1(RSA *rsa, const uint8_t *mHash, 484 const EVP_MD *Hash, const EVP_MD *mgf1Hash, 485 const uint8_t *EM, int sLen) { 486 int i; 487 int ret = 0; 488 int maskedDBLen, MSBits, emLen; 489 size_t hLen; 490 const uint8_t *H; 491 uint8_t *DB = NULL; 492 EVP_MD_CTX ctx; 493 uint8_t H_[EVP_MAX_MD_SIZE]; 494 EVP_MD_CTX_init(&ctx); 495 496 if (mgf1Hash == NULL) { 497 mgf1Hash = Hash; 498 } 499 500 hLen = EVP_MD_size(Hash); 501 502 // Negative sLen has special meanings: 503 // -1 sLen == hLen 504 // -2 salt length is autorecovered from signature 505 // -N reserved 506 if (sLen == -1) { 507 sLen = hLen; 508 } else if (sLen == -2) { 509 sLen = -2; 510 } else if (sLen < -2) { 511 OPENSSL_PUT_ERROR(RSA, RSA_R_SLEN_CHECK_FAILED); 512 goto err; 513 } 514 515 MSBits = (BN_num_bits(rsa->n) - 1) & 0x7; 516 emLen = RSA_size(rsa); 517 if (EM[0] & (0xFF << MSBits)) { 518 OPENSSL_PUT_ERROR(RSA, RSA_R_FIRST_OCTET_INVALID); 519 goto err; 520 } 521 if (MSBits == 0) { 522 EM++; 523 emLen--; 524 } 525 if (emLen < (int)hLen + 2 || emLen < ((int)hLen + sLen + 2)) { 526 // sLen can be small negative 527 OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_LARGE); 528 goto err; 529 } 530 if (EM[emLen - 1] != 0xbc) { 531 OPENSSL_PUT_ERROR(RSA, RSA_R_LAST_OCTET_INVALID); 532 goto err; 533 } 534 maskedDBLen = emLen - hLen - 1; 535 H = EM + maskedDBLen; 536 DB = OPENSSL_malloc(maskedDBLen); 537 if (!DB) { 538 OPENSSL_PUT_ERROR(RSA, ERR_R_MALLOC_FAILURE); 539 goto err; 540 } 541 if (!PKCS1_MGF1(DB, maskedDBLen, H, hLen, mgf1Hash)) { 542 goto err; 543 } 544 for (i = 0; i < maskedDBLen; i++) { 545 DB[i] ^= EM[i]; 546 } 547 if (MSBits) { 548 DB[0] &= 0xFF >> (8 - MSBits); 549 } 550 for (i = 0; DB[i] == 0 && i < (maskedDBLen - 1); i++) { 551 ; 552 } 553 if (DB[i++] != 0x1) { 554 OPENSSL_PUT_ERROR(RSA, RSA_R_SLEN_RECOVERY_FAILED); 555 goto err; 556 } 557 if (sLen >= 0 && (maskedDBLen - i) != sLen) { 558 OPENSSL_PUT_ERROR(RSA, RSA_R_SLEN_CHECK_FAILED); 559 goto err; 560 } 561 if (!EVP_DigestInit_ex(&ctx, Hash, NULL) || 562 !EVP_DigestUpdate(&ctx, kPSSZeroes, sizeof(kPSSZeroes)) || 563 !EVP_DigestUpdate(&ctx, mHash, hLen) || 564 !EVP_DigestUpdate(&ctx, DB + i, maskedDBLen - i) || 565 !EVP_DigestFinal_ex(&ctx, H_, NULL)) { 566 goto err; 567 } 568 if (OPENSSL_memcmp(H_, H, hLen)) { 569 OPENSSL_PUT_ERROR(RSA, RSA_R_BAD_SIGNATURE); 570 ret = 0; 571 } else { 572 ret = 1; 573 } 574 575 err: 576 OPENSSL_free(DB); 577 EVP_MD_CTX_cleanup(&ctx); 578 579 return ret; 580 } 581 582 int RSA_padding_add_PKCS1_PSS_mgf1(RSA *rsa, unsigned char *EM, 583 const unsigned char *mHash, 584 const EVP_MD *Hash, const EVP_MD *mgf1Hash, 585 int sLenRequested) { 586 int ret = 0; 587 size_t maskedDBLen, MSBits, emLen; 588 size_t hLen; 589 unsigned char *H, *salt = NULL, *p; 590 591 if (mgf1Hash == NULL) { 592 mgf1Hash = Hash; 593 } 594 595 hLen = EVP_MD_size(Hash); 596 597 if (BN_is_zero(rsa->n)) { 598 OPENSSL_PUT_ERROR(RSA, RSA_R_EMPTY_PUBLIC_KEY); 599 goto err; 600 } 601 602 MSBits = (BN_num_bits(rsa->n) - 1) & 0x7; 603 emLen = RSA_size(rsa); 604 if (MSBits == 0) { 605 assert(emLen >= 1); 606 *EM++ = 0; 607 emLen--; 608 } 609 610 if (emLen < hLen + 2) { 611 OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_LARGE); 612 goto err; 613 } 614 615 // Negative sLenRequested has special meanings: 616 // -1 sLen == hLen 617 // -2 salt length is maximized 618 // -N reserved 619 size_t sLen; 620 if (sLenRequested == -1) { 621 sLen = hLen; 622 } else if (sLenRequested == -2) { 623 sLen = emLen - hLen - 2; 624 } else if (sLenRequested < 0) { 625 OPENSSL_PUT_ERROR(RSA, RSA_R_SLEN_CHECK_FAILED); 626 goto err; 627 } else { 628 sLen = (size_t)sLenRequested; 629 } 630 631 if (emLen - hLen - 2 < sLen) { 632 OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_LARGE); 633 goto err; 634 } 635 636 if (sLen > 0) { 637 salt = OPENSSL_malloc(sLen); 638 if (!salt) { 639 OPENSSL_PUT_ERROR(RSA, ERR_R_MALLOC_FAILURE); 640 goto err; 641 } 642 if (!RAND_bytes(salt, sLen)) { 643 goto err; 644 } 645 } 646 maskedDBLen = emLen - hLen - 1; 647 H = EM + maskedDBLen; 648 649 EVP_MD_CTX ctx; 650 EVP_MD_CTX_init(&ctx); 651 int digest_ok = EVP_DigestInit_ex(&ctx, Hash, NULL) && 652 EVP_DigestUpdate(&ctx, kPSSZeroes, sizeof(kPSSZeroes)) && 653 EVP_DigestUpdate(&ctx, mHash, hLen) && 654 EVP_DigestUpdate(&ctx, salt, sLen) && 655 EVP_DigestFinal_ex(&ctx, H, NULL); 656 EVP_MD_CTX_cleanup(&ctx); 657 if (!digest_ok) { 658 goto err; 659 } 660 661 // Generate dbMask in place then perform XOR on it 662 if (!PKCS1_MGF1(EM, maskedDBLen, H, hLen, mgf1Hash)) { 663 goto err; 664 } 665 666 p = EM; 667 668 // Initial PS XORs with all zeroes which is a NOP so just update 669 // pointer. Note from a test above this value is guaranteed to 670 // be non-negative. 671 p += emLen - sLen - hLen - 2; 672 *p++ ^= 0x1; 673 if (sLen > 0) { 674 for (size_t i = 0; i < sLen; i++) { 675 *p++ ^= salt[i]; 676 } 677 } 678 if (MSBits) { 679 EM[0] &= 0xFF >> (8 - MSBits); 680 } 681 682 // H is already in place so just set final 0xbc 683 684 EM[emLen - 1] = 0xbc; 685 686 ret = 1; 687 688 err: 689 OPENSSL_free(salt); 690 691 return ret; 692 } 693
