1/* Written by Dr Stephen N Henson (steve@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@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@cryptsoft.com). This product includes software written by Tim
54 * Hudson (tjh@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
75int 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
96int 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
148static 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
164int 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_FOR_KEY_SIZE);
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
190int 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 CONSTTIME_DECLASSIFY(&valid_index, sizeof(valid_index));
237 CONSTTIME_DECLASSIFY(&zero_index, sizeof(zero_index));
238
239 if (!valid_index) {
240 OPENSSL_PUT_ERROR(RSA, RSA_R_PKCS_DECODING_ERROR);
241 return 0;
242 }
243
244 const size_t msg_len = from_len - zero_index;
245 if (msg_len > max_out) {
246 // This shouldn't happen because this function is always called with
247 // |max_out| as the key size and |from_len| is bounded by the key size.
248 OPENSSL_PUT_ERROR(RSA, RSA_R_PKCS_DECODING_ERROR);
249 return 0;
250 }
251
252 OPENSSL_memcpy(out, &from[zero_index], msg_len);
253 *out_len = msg_len;
254 return 1;
255}
256
257int RSA_padding_add_none(uint8_t *to, size_t to_len, const uint8_t *from,
258 size_t from_len) {
259 if (from_len > to_len) {
260 OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_LARGE_FOR_KEY_SIZE);
261 return 0;
262 }
263
264 if (from_len < to_len) {
265 OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_SMALL);
266 return 0;
267 }
268
269 OPENSSL_memcpy(to, from, from_len);
270 return 1;
271}
272
273static int PKCS1_MGF1(uint8_t *out, size_t len, const uint8_t *seed,
274 size_t seed_len, const EVP_MD *md) {
275 int ret = 0;
276 EVP_MD_CTX ctx;
277 EVP_MD_CTX_init(&ctx);
278
279 size_t md_len = EVP_MD_size(md);
280
281 for (uint32_t i = 0; len > 0; i++) {
282 uint8_t counter[4];
283 counter[0] = (uint8_t)(i >> 24);
284 counter[1] = (uint8_t)(i >> 16);
285 counter[2] = (uint8_t)(i >> 8);
286 counter[3] = (uint8_t)i;
287 if (!EVP_DigestInit_ex(&ctx, md, NULL) ||
288 !EVP_DigestUpdate(&ctx, seed, seed_len) ||
289 !EVP_DigestUpdate(&ctx, counter, sizeof(counter))) {
290 goto err;
291 }
292
293 if (md_len <= len) {
294 if (!EVP_DigestFinal_ex(&ctx, out, NULL)) {
295 goto err;
296 }
297 out += md_len;
298 len -= md_len;
299 } else {
300 uint8_t digest[EVP_MAX_MD_SIZE];
301 if (!EVP_DigestFinal_ex(&ctx, digest, NULL)) {
302 goto err;
303 }
304 OPENSSL_memcpy(out, digest, len);
305 len = 0;
306 }
307 }
308
309 ret = 1;
310
311err:
312 EVP_MD_CTX_cleanup(&ctx);
313 return ret;
314}
315
316int RSA_padding_add_PKCS1_OAEP_mgf1(uint8_t *to, size_t to_len,
317 const uint8_t *from, size_t from_len,
318 const uint8_t *param, size_t param_len,
319 const EVP_MD *md, const EVP_MD *mgf1md) {
320 if (md == NULL) {
321 md = EVP_sha1();
322 }
323 if (mgf1md == NULL) {
324 mgf1md = md;
325 }
326
327 size_t mdlen = EVP_MD_size(md);
328
329 if (to_len < 2 * mdlen + 2) {
330 OPENSSL_PUT_ERROR(RSA, RSA_R_KEY_SIZE_TOO_SMALL);
331 return 0;
332 }
333
334 size_t emlen = to_len - 1;
335 if (from_len > emlen - 2 * mdlen - 1) {
336 OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_LARGE_FOR_KEY_SIZE);
337 return 0;
338 }
339
340 if (emlen < 2 * mdlen + 1) {
341 OPENSSL_PUT_ERROR(RSA, RSA_R_KEY_SIZE_TOO_SMALL);
342 return 0;
343 }
344
345 to[0] = 0;
346 uint8_t *seed = to + 1;
347 uint8_t *db = to + mdlen + 1;
348
349 if (!EVP_Digest(param, param_len, db, NULL, md, NULL)) {
350 return 0;
351 }
352 OPENSSL_memset(db + mdlen, 0, emlen - from_len - 2 * mdlen - 1);
353 db[emlen - from_len - mdlen - 1] = 0x01;
354 OPENSSL_memcpy(db + emlen - from_len - mdlen, from, from_len);
355 if (!RAND_bytes(seed, mdlen)) {
356 return 0;
357 }
358
359 uint8_t *dbmask = OPENSSL_malloc(emlen - mdlen);
360 if (dbmask == NULL) {
361 OPENSSL_PUT_ERROR(RSA, ERR_R_MALLOC_FAILURE);
362 return 0;
363 }
364
365 int ret = 0;
366 if (!PKCS1_MGF1(dbmask, emlen - mdlen, seed, mdlen, mgf1md)) {
367 goto out;
368 }
369 for (size_t i = 0; i < emlen - mdlen; i++) {
370 db[i] ^= dbmask[i];
371 }
372
373 uint8_t seedmask[EVP_MAX_MD_SIZE];
374 if (!PKCS1_MGF1(seedmask, mdlen, db, emlen - mdlen, mgf1md)) {
375 goto out;
376 }
377 for (size_t i = 0; i < mdlen; i++) {
378 seed[i] ^= seedmask[i];
379 }
380 ret = 1;
381
382out:
383 OPENSSL_free(dbmask);
384 return ret;
385}
386
387int RSA_padding_check_PKCS1_OAEP_mgf1(uint8_t *out, size_t *out_len,
388 size_t max_out, const uint8_t *from,
389 size_t from_len, const uint8_t *param,
390 size_t param_len, const EVP_MD *md,
391 const EVP_MD *mgf1md) {
392 uint8_t *db = NULL;
393
394 if (md == NULL) {
395 md = EVP_sha1();
396 }
397 if (mgf1md == NULL) {
398 mgf1md = md;
399 }
400
401 size_t mdlen = EVP_MD_size(md);
402
403 // The encoded message is one byte smaller than the modulus to ensure that it
404 // doesn't end up greater than the modulus. Thus there's an extra "+1" here
405 // compared to https://tools.ietf.org/html/rfc2437#section-9.1.1.2.
406 if (from_len < 1 + 2*mdlen + 1) {
407 // 'from_len' is the length of the modulus, i.e. does not depend on the
408 // particular ciphertext.
409 goto decoding_err;
410 }
411
412 size_t dblen = from_len - mdlen - 1;
413 db = OPENSSL_malloc(dblen);
414 if (db == NULL) {
415 OPENSSL_PUT_ERROR(RSA, ERR_R_MALLOC_FAILURE);
416 goto err;
417 }
418
419 const uint8_t *maskedseed = from + 1;
420 const uint8_t *maskeddb = from + 1 + mdlen;
421
422 uint8_t seed[EVP_MAX_MD_SIZE];
423 if (!PKCS1_MGF1(seed, mdlen, maskeddb, dblen, mgf1md)) {
424 goto err;
425 }
426 for (size_t i = 0; i < mdlen; i++) {
427 seed[i] ^= maskedseed[i];
428 }
429
430 if (!PKCS1_MGF1(db, dblen, seed, mdlen, mgf1md)) {
431 goto err;
432 }
433 for (size_t i = 0; i < dblen; i++) {
434 db[i] ^= maskeddb[i];
435 }
436
437 uint8_t phash[EVP_MAX_MD_SIZE];
438 if (!EVP_Digest(param, param_len, phash, NULL, md, NULL)) {
439 goto err;
440 }
441
442 crypto_word_t bad = ~constant_time_is_zero_w(CRYPTO_memcmp(db, phash, mdlen));
443 bad |= ~constant_time_is_zero_w(from[0]);
444
445 crypto_word_t looking_for_one_byte = CONSTTIME_TRUE_W;
446 size_t one_index = 0;
447 for (size_t i = mdlen; i < dblen; i++) {
448 crypto_word_t equals1 = constant_time_eq_w(db[i], 1);
449 crypto_word_t equals0 = constant_time_eq_w(db[i], 0);
450 one_index =
451 constant_time_select_w(looking_for_one_byte & equals1, i, one_index);
452 looking_for_one_byte =
453 constant_time_select_w(equals1, 0, looking_for_one_byte);
454 bad |= looking_for_one_byte & ~equals0;
455 }
456
457 bad |= looking_for_one_byte;
458
459 if (bad) {
460 goto decoding_err;
461 }
462
463 one_index++;
464 size_t mlen = dblen - one_index;
465 if (max_out < mlen) {
466 OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_LARGE);
467 goto err;
468 }
469
470 OPENSSL_memcpy(out, db + one_index, mlen);
471 *out_len = mlen;
472 OPENSSL_free(db);
473 return 1;
474
475decoding_err:
476 // to avoid chosen ciphertext attacks, the error message should not reveal
477 // which kind of decoding error happened
478 OPENSSL_PUT_ERROR(RSA, RSA_R_OAEP_DECODING_ERROR);
479 err:
480 OPENSSL_free(db);
481 return 0;
482}
483
484static const uint8_t kPSSZeroes[] = {0, 0, 0, 0, 0, 0, 0, 0};
485
486int RSA_verify_PKCS1_PSS_mgf1(const RSA *rsa, const uint8_t *mHash,
487 const EVP_MD *Hash, const EVP_MD *mgf1Hash,
488 const uint8_t *EM, int sLen) {
489 int i;
490 int ret = 0;
491 int maskedDBLen, MSBits, emLen;
492 size_t hLen;
493 const uint8_t *H;
494 uint8_t *DB = NULL;
495 EVP_MD_CTX ctx;
496 uint8_t H_[EVP_MAX_MD_SIZE];
497 EVP_MD_CTX_init(&ctx);
498
499 if (mgf1Hash == NULL) {
500 mgf1Hash = Hash;
501 }
502
503 hLen = EVP_MD_size(Hash);
504
505 // Negative sLen has special meanings:
506 // -1 sLen == hLen
507 // -2 salt length is autorecovered from signature
508 // -N reserved
509 if (sLen == -1) {
510 sLen = hLen;
511 } else if (sLen == -2) {
512 sLen = -2;
513 } else if (sLen < -2) {
514 OPENSSL_PUT_ERROR(RSA, RSA_R_SLEN_CHECK_FAILED);
515 goto err;
516 }
517
518 MSBits = (BN_num_bits(rsa->n) - 1) & 0x7;
519 emLen = RSA_size(rsa);
520 if (EM[0] & (0xFF << MSBits)) {
521 OPENSSL_PUT_ERROR(RSA, RSA_R_FIRST_OCTET_INVALID);
522 goto err;
523 }
524 if (MSBits == 0) {
525 EM++;
526 emLen--;
527 }
528 if (emLen < (int)hLen + 2 || emLen < ((int)hLen + sLen + 2)) {
529 // sLen can be small negative
530 OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_LARGE);
531 goto err;
532 }
533 if (EM[emLen - 1] != 0xbc) {
534 OPENSSL_PUT_ERROR(RSA, RSA_R_LAST_OCTET_INVALID);
535 goto err;
536 }
537 maskedDBLen = emLen - hLen - 1;
538 H = EM + maskedDBLen;
539 DB = OPENSSL_malloc(maskedDBLen);
540 if (!DB) {
541 OPENSSL_PUT_ERROR(RSA, ERR_R_MALLOC_FAILURE);
542 goto err;
543 }
544 if (!PKCS1_MGF1(DB, maskedDBLen, H, hLen, mgf1Hash)) {
545 goto err;
546 }
547 for (i = 0; i < maskedDBLen; i++) {
548 DB[i] ^= EM[i];
549 }
550 if (MSBits) {
551 DB[0] &= 0xFF >> (8 - MSBits);
552 }
553 for (i = 0; DB[i] == 0 && i < (maskedDBLen - 1); i++) {
554 ;
555 }
556 if (DB[i++] != 0x1) {
557 OPENSSL_PUT_ERROR(RSA, RSA_R_SLEN_RECOVERY_FAILED);
558 goto err;
559 }
560 if (sLen >= 0 && (maskedDBLen - i) != sLen) {
561 OPENSSL_PUT_ERROR(RSA, RSA_R_SLEN_CHECK_FAILED);
562 goto err;
563 }
564 if (!EVP_DigestInit_ex(&ctx, Hash, NULL) ||
565 !EVP_DigestUpdate(&ctx, kPSSZeroes, sizeof(kPSSZeroes)) ||
566 !EVP_DigestUpdate(&ctx, mHash, hLen) ||
567 !EVP_DigestUpdate(&ctx, DB + i, maskedDBLen - i) ||
568 !EVP_DigestFinal_ex(&ctx, H_, NULL)) {
569 goto err;
570 }
571 if (OPENSSL_memcmp(H_, H, hLen)) {
572 OPENSSL_PUT_ERROR(RSA, RSA_R_BAD_SIGNATURE);
573 ret = 0;
574 } else {
575 ret = 1;
576 }
577
578err:
579 OPENSSL_free(DB);
580 EVP_MD_CTX_cleanup(&ctx);
581
582 return ret;
583}
584
585int RSA_padding_add_PKCS1_PSS_mgf1(const RSA *rsa, unsigned char *EM,
586 const unsigned char *mHash,
587 const EVP_MD *Hash, const EVP_MD *mgf1Hash,
588 int sLenRequested) {
589 int ret = 0;
590 size_t maskedDBLen, MSBits, emLen;
591 size_t hLen;
592 unsigned char *H, *salt = NULL, *p;
593
594 if (mgf1Hash == NULL) {
595 mgf1Hash = Hash;
596 }
597
598 hLen = EVP_MD_size(Hash);
599
600 if (BN_is_zero(rsa->n)) {
601 OPENSSL_PUT_ERROR(RSA, RSA_R_EMPTY_PUBLIC_KEY);
602 goto err;
603 }
604
605 MSBits = (BN_num_bits(rsa->n) - 1) & 0x7;
606 emLen = RSA_size(rsa);
607 if (MSBits == 0) {
608 assert(emLen >= 1);
609 *EM++ = 0;
610 emLen--;
611 }
612
613 if (emLen < hLen + 2) {
614 OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_LARGE_FOR_KEY_SIZE);
615 goto err;
616 }
617
618 // Negative sLenRequested has special meanings:
619 // -1 sLen == hLen
620 // -2 salt length is maximized
621 // -N reserved
622 size_t sLen;
623 if (sLenRequested == -1) {
624 sLen = hLen;
625 } else if (sLenRequested == -2) {
626 sLen = emLen - hLen - 2;
627 } else if (sLenRequested < 0) {
628 OPENSSL_PUT_ERROR(RSA, RSA_R_SLEN_CHECK_FAILED);
629 goto err;
630 } else {
631 sLen = (size_t)sLenRequested;
632 }
633
634 if (emLen - hLen - 2 < sLen) {
635 OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_LARGE_FOR_KEY_SIZE);
636 goto err;
637 }
638
639 if (sLen > 0) {
640 salt = OPENSSL_malloc(sLen);
641 if (!salt) {
642 OPENSSL_PUT_ERROR(RSA, ERR_R_MALLOC_FAILURE);
643 goto err;
644 }
645 if (!RAND_bytes(salt, sLen)) {
646 goto err;
647 }
648 }
649 maskedDBLen = emLen - hLen - 1;
650 H = EM + maskedDBLen;
651
652 EVP_MD_CTX ctx;
653 EVP_MD_CTX_init(&ctx);
654 int digest_ok = EVP_DigestInit_ex(&ctx, Hash, NULL) &&
655 EVP_DigestUpdate(&ctx, kPSSZeroes, sizeof(kPSSZeroes)) &&
656 EVP_DigestUpdate(&ctx, mHash, hLen) &&
657 EVP_DigestUpdate(&ctx, salt, sLen) &&
658 EVP_DigestFinal_ex(&ctx, H, NULL);
659 EVP_MD_CTX_cleanup(&ctx);
660 if (!digest_ok) {
661 goto err;
662 }
663
664 // Generate dbMask in place then perform XOR on it
665 if (!PKCS1_MGF1(EM, maskedDBLen, H, hLen, mgf1Hash)) {
666 goto err;
667 }
668
669 p = EM;
670
671 // Initial PS XORs with all zeroes which is a NOP so just update
672 // pointer. Note from a test above this value is guaranteed to
673 // be non-negative.
674 p += emLen - sLen - hLen - 2;
675 *p++ ^= 0x1;
676 if (sLen > 0) {
677 for (size_t i = 0; i < sLen; i++) {
678 *p++ ^= salt[i];
679 }
680 }
681 if (MSBits) {
682 EM[0] &= 0xFF >> (8 - MSBits);
683 }
684
685 // H is already in place so just set final 0xbc
686
687 EM[emLen - 1] = 0xbc;
688
689 ret = 1;
690
691err:
692 OPENSSL_free(salt);
693
694 return ret;
695}
696