crypto/fipsmodule/rsa/padding.c - boringssl - Git at Google

 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 2005.
  */
 /* ====================================================================
  * Copyright (c) 2005 The OpenSSL Project.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  *
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in
  *    the documentation and/or other materials provided with the
  *    distribution.
  *
  * 3. All advertising materials mentioning features or use of this
  *    software must display the following acknowledgment:
  *    "This product includes software developed by the OpenSSL Project
  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
  *
  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  *    endorse or promote products derived from this software without
  *    prior written permission. For written permission, please contact
  *    licensing@OpenSSL.org.
  *
  * 5. Products derived from this software may not be called "OpenSSL"
  *    nor may "OpenSSL" appear in their names without prior written
  *    permission of the OpenSSL Project.
  *
  * 6. Redistributions of any form whatsoever must retain the following
  *    acknowledgment:
  *    "This product includes software developed by the OpenSSL Project
  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
  *
  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  * OF THE POSSIBILITY OF SUCH DAMAGE.
  * ====================================================================
  *
  * This product includes cryptographic software written by Eric Young
  * (eay@cryptsoft.com).  This product includes software written by Tim
  * Hudson (tjh@cryptsoft.com). */

 #include <openssl/rsa.h>

 #include <assert.h>
 #include <limits.h>
 #include <string.h>

 #include <openssl/bn.h>
 #include <openssl/digest.h>
 #include <openssl/err.h>
 #include <openssl/mem.h>
 #include <openssl/rand.h>
 #include <openssl/sha.h>

 #include "internal.h"
 #include "../../internal.h"


 #define RSA_PKCS1_PADDING_SIZE 11

 int RSA_padding_add_PKCS1_type_1(uint8_t *to, size_t to_len,
                                  const uint8_t *from, size_t from_len) {
   // See RFC 8017, section 9.2.
   if (to_len < RSA_PKCS1_PADDING_SIZE) {
     OPENSSL_PUT_ERROR(RSA, RSA_R_KEY_SIZE_TOO_SMALL);
     return 0;
   }

   if (from_len > to_len - RSA_PKCS1_PADDING_SIZE) {
     OPENSSL_PUT_ERROR(RSA, RSA_R_DIGEST_TOO_BIG_FOR_RSA_KEY);
     return 0;
   }

   to[0] = 0;
   to[1] = 1;
   OPENSSL_memset(to + 2, 0xff, to_len - 3 - from_len);
   to[to_len - from_len - 1] = 0;
   OPENSSL_memcpy(to + to_len - from_len, from, from_len);
   return 1;
 }

 int RSA_padding_check_PKCS1_type_1(uint8_t *out, size_t *out_len,
                                    size_t max_out, const uint8_t *from,
                                    size_t from_len) {
   // See RFC 8017, section 9.2. This is part of signature verification and thus
   // does not need to run in constant-time.
   if (from_len < 2) {
     OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_SMALL);
     return 0;
   }

   // Check the header.
   if (from[0] != 0 || from[1] != 1) {
     OPENSSL_PUT_ERROR(RSA, RSA_R_BLOCK_TYPE_IS_NOT_01);
     return 0;
   }

   // Scan over padded data, looking for the 00.
   size_t pad;
   for (pad = 2 /* header */; pad < from_len; pad++) {
     if (from[pad] == 0x00) {
       break;
     }

     if (from[pad] != 0xff) {
       OPENSSL_PUT_ERROR(RSA, RSA_R_BAD_FIXED_HEADER_DECRYPT);
       return 0;
     }
   }

   if (pad == from_len) {
     OPENSSL_PUT_ERROR(RSA, RSA_R_NULL_BEFORE_BLOCK_MISSING);
     return 0;
   }

   if (pad < 2 /* header */ + 8) {
     OPENSSL_PUT_ERROR(RSA, RSA_R_BAD_PAD_BYTE_COUNT);
     return 0;
   }

   // Skip over the 00.
   pad++;

   if (from_len - pad > max_out) {
     OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_LARGE);
     return 0;
   }

   OPENSSL_memcpy(out, from + pad, from_len - pad);
   *out_len = from_len - pad;
   return 1;
 }

 static int rand_nonzero(uint8_t *out, size_t len) {
   if (!RAND_bytes(out, len)) {
     return 0;
   }

   for (size_t i = 0; i < len; i++) {
     while (out[i] == 0) {
       if (!RAND_bytes(out + i, 1)) {
         return 0;
       }
     }
   }

   return 1;
 }

 int RSA_padding_add_PKCS1_type_2(uint8_t *to, size_t to_len,
                                  const uint8_t *from, size_t from_len) {
   // See RFC 8017, section 7.2.1.
   if (to_len < RSA_PKCS1_PADDING_SIZE) {
     OPENSSL_PUT_ERROR(RSA, RSA_R_KEY_SIZE_TOO_SMALL);
     return 0;
   }

   if (from_len > to_len - RSA_PKCS1_PADDING_SIZE) {
     OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_LARGE);
     return 0;
   }

   to[0] = 0;
   to[1] = 2;

   size_t padding_len = to_len - 3 - from_len;
   if (!rand_nonzero(to + 2, padding_len)) {
     return 0;
   }

   to[2 + padding_len] = 0;
   OPENSSL_memcpy(to + to_len - from_len, from, from_len);
   return 1;
 }

 int RSA_padding_check_PKCS1_type_2(uint8_t *out, size_t *out_len,
                                    size_t max_out, const uint8_t *from,
                                    size_t from_len) {
   if (from_len == 0) {
     OPENSSL_PUT_ERROR(RSA, RSA_R_EMPTY_PUBLIC_KEY);
     return 0;
   }

   // PKCS#1 v1.5 decryption. See "PKCS #1 v2.2: RSA Cryptography
   // Standard", section 7.2.2.
   if (from_len < RSA_PKCS1_PADDING_SIZE) {
     // |from| is zero-padded to the size of the RSA modulus, a public value, so
     // this can be rejected in non-constant time.
     OPENSSL_PUT_ERROR(RSA, RSA_R_KEY_SIZE_TOO_SMALL);
     return 0;
   }

   crypto_word_t first_byte_is_zero = constant_time_eq_w(from[0], 0);
   crypto_word_t second_byte_is_two = constant_time_eq_w(from[1], 2);

   crypto_word_t zero_index = 0, looking_for_index = CONSTTIME_TRUE_W;
   for (size_t i = 2; i < from_len; i++) {
     crypto_word_t equals0 = constant_time_is_zero_w(from[i]);
     zero_index =
         constant_time_select_w(looking_for_index & equals0, i, zero_index);
     looking_for_index = constant_time_select_w(equals0, 0, looking_for_index);
   }

   // The input must begin with 00 02.
   crypto_word_t valid_index = first_byte_is_zero;
   valid_index &= second_byte_is_two;

   // We must have found the end of PS.
   valid_index &= ~looking_for_index;

   // PS must be at least 8 bytes long, and it starts two bytes into |from|.
   valid_index &= constant_time_ge_w(zero_index, 2 + 8);

   // Skip the zero byte.
   zero_index++;

   // NOTE: Although this logic attempts to be constant time, the API contracts
   // of this function and |RSA_decrypt| with |RSA_PKCS1_PADDING| make it
   // impossible to completely avoid Bleichenbacher's attack. Consumers should
   // use |RSA_PADDING_NONE| and perform the padding check in constant-time
   // combined with a swap to a random session key or other mitigation.
   if (!valid_index) {
     OPENSSL_PUT_ERROR(RSA, RSA_R_PKCS_DECODING_ERROR);
     return 0;
   }

   const size_t msg_len = from_len - zero_index;
   if (msg_len > max_out) {
     // This shouldn't happen because this function is always called with
     // |max_out| as the key size and |from_len| is bounded by the key size.
     OPENSSL_PUT_ERROR(RSA, RSA_R_PKCS_DECODING_ERROR);
     return 0;
   }

   OPENSSL_memcpy(out, &from[zero_index], msg_len);
   *out_len = msg_len;
   return 1;
 }

 int RSA_padding_add_none(uint8_t *to, size_t to_len, const uint8_t *from,
                          size_t from_len) {
   if (from_len > to_len) {
     OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_LARGE);
     return 0;
   }

   if (from_len < to_len) {
     OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_SMALL);
     return 0;
   }

   OPENSSL_memcpy(to, from, from_len);
   return 1;
 }

 static int PKCS1_MGF1(uint8_t *out, size_t len, const uint8_t *seed,
                       size_t seed_len, const EVP_MD *md) {
   int ret = 0;
   EVP_MD_CTX ctx;
   EVP_MD_CTX_init(&ctx);

   size_t md_len = EVP_MD_size(md);

   for (uint32_t i = 0; len > 0; i++) {
     uint8_t counter[4];
     counter[0] = (uint8_t)(i >> 24);
     counter[1] = (uint8_t)(i >> 16);
     counter[2] = (uint8_t)(i >> 8);
     counter[3] = (uint8_t)i;
     if (!EVP_DigestInit_ex(&ctx, md, NULL) ||
         !EVP_DigestUpdate(&ctx, seed, seed_len) ||
         !EVP_DigestUpdate(&ctx, counter, sizeof(counter))) {
       goto err;
     }

     if (md_len <= len) {
       if (!EVP_DigestFinal_ex(&ctx, out, NULL)) {
         goto err;
       }
       out += md_len;
       len -= md_len;
     } else {
       uint8_t digest[EVP_MAX_MD_SIZE];
       if (!EVP_DigestFinal_ex(&ctx, digest, NULL)) {
         goto err;
       }
       OPENSSL_memcpy(out, digest, len);
       len = 0;
     }
   }

   ret = 1;

 err:
   EVP_MD_CTX_cleanup(&ctx);
   return ret;
 }

 int RSA_padding_add_PKCS1_OAEP_mgf1(uint8_t *to, size_t to_len,
                                     const uint8_t *from, size_t from_len,
                                     const uint8_t *param, size_t param_len,
                                     const EVP_MD *md, const EVP_MD *mgf1md) {
   if (md == NULL) {
     md = EVP_sha1();
   }
   if (mgf1md == NULL) {
     mgf1md = md;
   }

   size_t mdlen = EVP_MD_size(md);

   if (to_len < 2 * mdlen + 2) {
     OPENSSL_PUT_ERROR(RSA, RSA_R_KEY_SIZE_TOO_SMALL);
     return 0;
   }

   size_t emlen = to_len - 1;
   if (from_len > emlen - 2 * mdlen - 1) {
     OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_LARGE);
     return 0;
   }

   if (emlen < 2 * mdlen + 1) {
     OPENSSL_PUT_ERROR(RSA, RSA_R_KEY_SIZE_TOO_SMALL);
     return 0;
   }

   to[0] = 0;
   uint8_t *seed = to + 1;
   uint8_t *db = to + mdlen + 1;

   if (!EVP_Digest(param, param_len, db, NULL, md, NULL)) {
     return 0;
   }
   OPENSSL_memset(db + mdlen, 0, emlen - from_len - 2 * mdlen - 1);
   db[emlen - from_len - mdlen - 1] = 0x01;
   OPENSSL_memcpy(db + emlen - from_len - mdlen, from, from_len);
   if (!RAND_bytes(seed, mdlen)) {
     return 0;
   }

   uint8_t *dbmask = OPENSSL_malloc(emlen - mdlen);
   if (dbmask == NULL) {
     OPENSSL_PUT_ERROR(RSA, ERR_R_MALLOC_FAILURE);
     return 0;
   }

   int ret = 0;
   if (!PKCS1_MGF1(dbmask, emlen - mdlen, seed, mdlen, mgf1md)) {
     goto out;
   }
   for (size_t i = 0; i < emlen - mdlen; i++) {
     db[i] ^= dbmask[i];
   }

   uint8_t seedmask[EVP_MAX_MD_SIZE];
   if (!PKCS1_MGF1(seedmask, mdlen, db, emlen - mdlen, mgf1md)) {
     goto out;
   }
   for (size_t i = 0; i < mdlen; i++) {
     seed[i] ^= seedmask[i];
   }
   ret = 1;

 out:
   OPENSSL_free(dbmask);
   return ret;
 }

 int RSA_padding_check_PKCS1_OAEP_mgf1(uint8_t *out, size_t *out_len,
                                       size_t max_out, const uint8_t *from,
                                       size_t from_len, const uint8_t *param,
                                       size_t param_len, const EVP_MD *md,
                                       const EVP_MD *mgf1md) {
   uint8_t *db = NULL;

   if (md == NULL) {
     md = EVP_sha1();
   }
   if (mgf1md == NULL) {
     mgf1md = md;
   }

   size_t mdlen = EVP_MD_size(md);

   // The encoded message is one byte smaller than the modulus to ensure that it
   // doesn't end up greater than the modulus. Thus there's an extra "+1" here
   // compared to https://tools.ietf.org/html/rfc2437#section-9.1.1.2.
   if (from_len < 1 + 2*mdlen + 1) {
     // 'from_len' is the length of the modulus, i.e. does not depend on the
     // particular ciphertext.
     goto decoding_err;
   }

   size_t dblen = from_len - mdlen - 1;
   db = OPENSSL_malloc(dblen);
   if (db == NULL) {
     OPENSSL_PUT_ERROR(RSA, ERR_R_MALLOC_FAILURE);
     goto err;
   }

   const uint8_t *maskedseed = from + 1;
   const uint8_t *maskeddb = from + 1 + mdlen;

   uint8_t seed[EVP_MAX_MD_SIZE];
   if (!PKCS1_MGF1(seed, mdlen, maskeddb, dblen, mgf1md)) {
     goto err;
   }
   for (size_t i = 0; i < mdlen; i++) {
     seed[i] ^= maskedseed[i];
   }

   if (!PKCS1_MGF1(db, dblen, seed, mdlen, mgf1md)) {
     goto err;
   }
   for (size_t i = 0; i < dblen; i++) {
     db[i] ^= maskeddb[i];
   }

   uint8_t phash[EVP_MAX_MD_SIZE];
   if (!EVP_Digest(param, param_len, phash, NULL, md, NULL)) {
     goto err;
   }

   crypto_word_t bad = ~constant_time_is_zero_w(CRYPTO_memcmp(db, phash, mdlen));
   bad |= ~constant_time_is_zero_w(from[0]);

   crypto_word_t looking_for_one_byte = CONSTTIME_TRUE_W;
   size_t one_index = 0;
   for (size_t i = mdlen; i < dblen; i++) {
     crypto_word_t equals1 = constant_time_eq_w(db[i], 1);
     crypto_word_t equals0 = constant_time_eq_w(db[i], 0);
     one_index =
         constant_time_select_w(looking_for_one_byte & equals1, i, one_index);
     looking_for_one_byte =
         constant_time_select_w(equals1, 0, looking_for_one_byte);
     bad |= looking_for_one_byte & ~equals0;
   }

   bad |= looking_for_one_byte;

   if (bad) {
     goto decoding_err;
   }

   one_index++;
   size_t mlen = dblen - one_index;
   if (max_out < mlen) {
     OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_LARGE);
     goto err;
   }

   OPENSSL_memcpy(out, db + one_index, mlen);
   *out_len = mlen;
   OPENSSL_free(db);
   return 1;

 decoding_err:
   // to avoid chosen ciphertext attacks, the error message should not reveal
   // which kind of decoding error happened
   OPENSSL_PUT_ERROR(RSA, RSA_R_OAEP_DECODING_ERROR);
  err:
   OPENSSL_free(db);
   return 0;
 }

 static const uint8_t kPSSZeroes[] = {0, 0, 0, 0, 0, 0, 0, 0};

 int RSA_verify_PKCS1_PSS_mgf1(RSA *rsa, const uint8_t *mHash,
                               const EVP_MD *Hash, const EVP_MD *mgf1Hash,
                               const uint8_t *EM, int sLen) {
   int i;
   int ret = 0;
   int maskedDBLen, MSBits, emLen;
   size_t hLen;
   const uint8_t *H;
   uint8_t *DB = NULL;
   EVP_MD_CTX ctx;
   uint8_t H_[EVP_MAX_MD_SIZE];
   EVP_MD_CTX_init(&ctx);

   if (mgf1Hash == NULL) {
     mgf1Hash = Hash;
   }

   hLen = EVP_MD_size(Hash);

   // Negative sLen has special meanings:
   //	-1	sLen == hLen
   //	-2	salt length is autorecovered from signature
   //	-N	reserved
   if (sLen == -1) {
     sLen = hLen;
   } else if (sLen == -2) {
     sLen = -2;
   } else if (sLen < -2) {
     OPENSSL_PUT_ERROR(RSA, RSA_R_SLEN_CHECK_FAILED);
     goto err;
   }

   MSBits = (BN_num_bits(rsa->n) - 1) & 0x7;
   emLen = RSA_size(rsa);
   if (EM[0] & (0xFF << MSBits)) {
     OPENSSL_PUT_ERROR(RSA, RSA_R_FIRST_OCTET_INVALID);
     goto err;
   }
   if (MSBits == 0) {
     EM++;
     emLen--;
   }
   if (emLen < (int)hLen + 2 || emLen < ((int)hLen + sLen + 2)) {
     // sLen can be small negative
     OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_LARGE);
     goto err;
   }
   if (EM[emLen - 1] != 0xbc) {
     OPENSSL_PUT_ERROR(RSA, RSA_R_LAST_OCTET_INVALID);
     goto err;
   }
   maskedDBLen = emLen - hLen - 1;
   H = EM + maskedDBLen;
   DB = OPENSSL_malloc(maskedDBLen);
   if (!DB) {
     OPENSSL_PUT_ERROR(RSA, ERR_R_MALLOC_FAILURE);
     goto err;
   }
   if (!PKCS1_MGF1(DB, maskedDBLen, H, hLen, mgf1Hash)) {
     goto err;
   }
   for (i = 0; i < maskedDBLen; i++) {
     DB[i] ^= EM[i];
   }
   if (MSBits) {
     DB[0] &= 0xFF >> (8 - MSBits);
   }
   for (i = 0; DB[i] == 0 && i < (maskedDBLen - 1); i++) {
     ;
   }
   if (DB[i++] != 0x1) {
     OPENSSL_PUT_ERROR(RSA, RSA_R_SLEN_RECOVERY_FAILED);
     goto err;
   }
   if (sLen >= 0 && (maskedDBLen - i) != sLen) {
     OPENSSL_PUT_ERROR(RSA, RSA_R_SLEN_CHECK_FAILED);
     goto err;
   }
   if (!EVP_DigestInit_ex(&ctx, Hash, NULL) ||
       !EVP_DigestUpdate(&ctx, kPSSZeroes, sizeof(kPSSZeroes)) ||
       !EVP_DigestUpdate(&ctx, mHash, hLen) ||
       !EVP_DigestUpdate(&ctx, DB + i, maskedDBLen - i) ||
       !EVP_DigestFinal_ex(&ctx, H_, NULL)) {
     goto err;
   }
   if (OPENSSL_memcmp(H_, H, hLen)) {
     OPENSSL_PUT_ERROR(RSA, RSA_R_BAD_SIGNATURE);
     ret = 0;
   } else {
     ret = 1;
   }

 err:
   OPENSSL_free(DB);
   EVP_MD_CTX_cleanup(&ctx);

   return ret;
 }

 int RSA_padding_add_PKCS1_PSS_mgf1(RSA *rsa, unsigned char *EM,
                                    const unsigned char *mHash,
                                    const EVP_MD *Hash, const EVP_MD *mgf1Hash,
                                    int sLenRequested) {
   int ret = 0;
   size_t maskedDBLen, MSBits, emLen;
   size_t hLen;
   unsigned char *H, *salt = NULL, *p;

   if (mgf1Hash == NULL) {
     mgf1Hash = Hash;
   }

   hLen = EVP_MD_size(Hash);

   if (BN_is_zero(rsa->n)) {
     OPENSSL_PUT_ERROR(RSA, RSA_R_EMPTY_PUBLIC_KEY);
     goto err;
   }

   MSBits = (BN_num_bits(rsa->n) - 1) & 0x7;
   emLen = RSA_size(rsa);
   if (MSBits == 0) {
     assert(emLen >= 1);
     *EM++ = 0;
     emLen--;
   }

   if (emLen < hLen + 2) {
     OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_LARGE);
     goto err;
   }

   // Negative sLenRequested has special meanings:
   //   -1  sLen == hLen
   //   -2  salt length is maximized
   //   -N  reserved
   size_t sLen;
   if (sLenRequested == -1) {
     sLen = hLen;
   } else if (sLenRequested == -2) {
     sLen = emLen - hLen - 2;
   } else if (sLenRequested < 0) {
     OPENSSL_PUT_ERROR(RSA, RSA_R_SLEN_CHECK_FAILED);
     goto err;
   } else {
     sLen = (size_t)sLenRequested;
   }

   if (emLen - hLen - 2 < sLen) {
     OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_LARGE);
     goto err;
   }

   if (sLen > 0) {
     salt = OPENSSL_malloc(sLen);
     if (!salt) {
       OPENSSL_PUT_ERROR(RSA, ERR_R_MALLOC_FAILURE);
       goto err;
     }
     if (!RAND_bytes(salt, sLen)) {
       goto err;
     }
   }
   maskedDBLen = emLen - hLen - 1;
   H = EM + maskedDBLen;

   EVP_MD_CTX ctx;
   EVP_MD_CTX_init(&ctx);
   int digest_ok = EVP_DigestInit_ex(&ctx, Hash, NULL) &&
                   EVP_DigestUpdate(&ctx, kPSSZeroes, sizeof(kPSSZeroes)) &&
                   EVP_DigestUpdate(&ctx, mHash, hLen) &&
                   EVP_DigestUpdate(&ctx, salt, sLen) &&
                   EVP_DigestFinal_ex(&ctx, H, NULL);
   EVP_MD_CTX_cleanup(&ctx);
   if (!digest_ok) {
     goto err;
   }

   // Generate dbMask in place then perform XOR on it
   if (!PKCS1_MGF1(EM, maskedDBLen, H, hLen, mgf1Hash)) {
     goto err;
   }

   p = EM;

   // Initial PS XORs with all zeroes which is a NOP so just update
   // pointer. Note from a test above this value is guaranteed to
   // be non-negative.
   p += emLen - sLen - hLen - 2;
   *p++ ^= 0x1;
   if (sLen > 0) {
     for (size_t i = 0; i < sLen; i++) {
       *p++ ^= salt[i];
     }
   }
   if (MSBits) {
     EM[0] &= 0xFF >> (8 - MSBits);
   }

   // H is already in place so just set final 0xbc

   EM[emLen - 1] = 0xbc;

   ret = 1;

 err:
   OPENSSL_free(salt);

   return ret;
 }
	/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
	* project 2005.
	*/
	/* ====================================================================
	* Copyright (c) 2005 The OpenSSL Project. All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions
	* are met:
	*
	* 1. Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	*
	* 2. Redistributions in binary form must reproduce the above copyright
	* notice, this list of conditions and the following disclaimer in
	* the documentation and/or other materials provided with the
	* distribution.
	*
	* 3. All advertising materials mentioning features or use of this
	* software must display the following acknowledgment:
	* "This product includes software developed by the OpenSSL Project
	* for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
	*
	* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
	* endorse or promote products derived from this software without
	* prior written permission. For written permission, please contact
	* licensing@OpenSSL.org.
	*
	* 5. Products derived from this software may not be called "OpenSSL"
	* nor may "OpenSSL" appear in their names without prior written
	* permission of the OpenSSL Project.
	*
	* 6. Redistributions of any form whatsoever must retain the following
	* acknowledgment:
	* "This product includes software developed by the OpenSSL Project
	* for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
	*
	* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
	* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
	* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
	* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
	* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
	* OF THE POSSIBILITY OF SUCH DAMAGE.
	* ====================================================================
	*
	* This product includes cryptographic software written by Eric Young
	* (eay@cryptsoft.com). This product includes software written by Tim
	* Hudson (tjh@cryptsoft.com). */

	#include <openssl/rsa.h>

	#include <assert.h>
	#include <limits.h>
	#include <string.h>

	#include <openssl/bn.h>
	#include <openssl/digest.h>
	#include <openssl/err.h>
	#include <openssl/mem.h>
	#include <openssl/rand.h>
	#include <openssl/sha.h>

	#include "internal.h"
	#include "../../internal.h"


	#define RSA_PKCS1_PADDING_SIZE 11

	int RSA_padding_add_PKCS1_type_1(uint8_t *to, size_t to_len,
	const uint8_t *from, size_t from_len) {
	// See RFC 8017, section 9.2.
	if (to_len < RSA_PKCS1_PADDING_SIZE) {
	OPENSSL_PUT_ERROR(RSA, RSA_R_KEY_SIZE_TOO_SMALL);
	return 0;
	}

	if (from_len > to_len - RSA_PKCS1_PADDING_SIZE) {
	OPENSSL_PUT_ERROR(RSA, RSA_R_DIGEST_TOO_BIG_FOR_RSA_KEY);
	return 0;
	}

	to[0] = 0;
	to[1] = 1;
	OPENSSL_memset(to + 2, 0xff, to_len - 3 - from_len);
	to[to_len - from_len - 1] = 0;
	OPENSSL_memcpy(to + to_len - from_len, from, from_len);
	return 1;
	}

	int RSA_padding_check_PKCS1_type_1(uint8_t out, size_t out_len,
	size_t max_out, const uint8_t *from,
	size_t from_len) {
	// See RFC 8017, section 9.2. This is part of signature verification and thus
	// does not need to run in constant-time.
	if (from_len < 2) {
	OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_SMALL);
	return 0;
	}

	// Check the header.
	if (from[0] != 0 \|\| from[1] != 1) {
	OPENSSL_PUT_ERROR(RSA, RSA_R_BLOCK_TYPE_IS_NOT_01);
	return 0;
	}

	// Scan over padded data, looking for the 00.
	size_t pad;
	for (pad = 2 /* header */; pad < from_len; pad++) {
	if (from[pad] == 0x00) {
	break;
	}

	if (from[pad] != 0xff) {
	OPENSSL_PUT_ERROR(RSA, RSA_R_BAD_FIXED_HEADER_DECRYPT);
	return 0;
	}
	}

	if (pad == from_len) {
	OPENSSL_PUT_ERROR(RSA, RSA_R_NULL_BEFORE_BLOCK_MISSING);
	return 0;
	}

	if (pad < 2 /* header */ + 8) {
	OPENSSL_PUT_ERROR(RSA, RSA_R_BAD_PAD_BYTE_COUNT);
	return 0;
	}

	// Skip over the 00.
	pad++;

	if (from_len - pad > max_out) {
	OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_LARGE);
	return 0;
	}

	OPENSSL_memcpy(out, from + pad, from_len - pad);
	*out_len = from_len - pad;
	return 1;
	}

	static int rand_nonzero(uint8_t *out, size_t len) {
	if (!RAND_bytes(out, len)) {
	return 0;
	}

	for (size_t i = 0; i < len; i++) {
	while (out[i] == 0) {
	if (!RAND_bytes(out + i, 1)) {
	return 0;
	}
	}
	}

	return 1;
	}

	int RSA_padding_add_PKCS1_type_2(uint8_t *to, size_t to_len,
	const uint8_t *from, size_t from_len) {
	// See RFC 8017, section 7.2.1.
	if (to_len < RSA_PKCS1_PADDING_SIZE) {
	OPENSSL_PUT_ERROR(RSA, RSA_R_KEY_SIZE_TOO_SMALL);
	return 0;
	}

	if (from_len > to_len - RSA_PKCS1_PADDING_SIZE) {
	OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_LARGE);
	return 0;
	}

	to[0] = 0;
	to[1] = 2;

	size_t padding_len = to_len - 3 - from_len;
	if (!rand_nonzero(to + 2, padding_len)) {
	return 0;
	}

	to[2 + padding_len] = 0;
	OPENSSL_memcpy(to + to_len - from_len, from, from_len);
	return 1;
	}

	int RSA_padding_check_PKCS1_type_2(uint8_t out, size_t out_len,
	size_t max_out, const uint8_t *from,
	size_t from_len) {
	if (from_len == 0) {
	OPENSSL_PUT_ERROR(RSA, RSA_R_EMPTY_PUBLIC_KEY);
	return 0;
	}

	// PKCS#1 v1.5 decryption. See "PKCS #1 v2.2: RSA Cryptography
	// Standard", section 7.2.2.
	if (from_len < RSA_PKCS1_PADDING_SIZE) {
	// \|from\| is zero-padded to the size of the RSA modulus, a public value, so
	// this can be rejected in non-constant time.
	OPENSSL_PUT_ERROR(RSA, RSA_R_KEY_SIZE_TOO_SMALL);
	return 0;
	}

	crypto_word_t first_byte_is_zero = constant_time_eq_w(from[0], 0);
	crypto_word_t second_byte_is_two = constant_time_eq_w(from[1], 2);

	crypto_word_t zero_index = 0, looking_for_index = CONSTTIME_TRUE_W;
	for (size_t i = 2; i < from_len; i++) {
	crypto_word_t equals0 = constant_time_is_zero_w(from[i]);
	zero_index =
	constant_time_select_w(looking_for_index & equals0, i, zero_index);
	looking_for_index = constant_time_select_w(equals0, 0, looking_for_index);
	}

	// The input must begin with 00 02.
	crypto_word_t valid_index = first_byte_is_zero;
	valid_index &= second_byte_is_two;

	// We must have found the end of PS.
	valid_index &= ~looking_for_index;

	// PS must be at least 8 bytes long, and it starts two bytes into \|from\|.
	valid_index &= constant_time_ge_w(zero_index, 2 + 8);

	// Skip the zero byte.
	zero_index++;

	// NOTE: Although this logic attempts to be constant time, the API contracts
	// of this function and \|RSA_decrypt\| with \|RSA_PKCS1_PADDING\| make it
	// impossible to completely avoid Bleichenbacher's attack. Consumers should
	// use \|RSA_PADDING_NONE\| and perform the padding check in constant-time
	// combined with a swap to a random session key or other mitigation.
	if (!valid_index) {
	OPENSSL_PUT_ERROR(RSA, RSA_R_PKCS_DECODING_ERROR);
	return 0;
	}

	const size_t msg_len = from_len - zero_index;
	if (msg_len > max_out) {
	// This shouldn't happen because this function is always called with
	// \|max_out\| as the key size and \|from_len\| is bounded by the key size.
	OPENSSL_PUT_ERROR(RSA, RSA_R_PKCS_DECODING_ERROR);
	return 0;
	}

	OPENSSL_memcpy(out, &from[zero_index], msg_len);
	*out_len = msg_len;
	return 1;
	}

	int RSA_padding_add_none(uint8_t to, size_t to_len, const uint8_t from,
	size_t from_len) {
	if (from_len > to_len) {
	OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_LARGE);
	return 0;
	}

	if (from_len < to_len) {
	OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_SMALL);
	return 0;
	}

	OPENSSL_memcpy(to, from, from_len);
	return 1;
	}

	static int PKCS1_MGF1(uint8_t out, size_t len, const uint8_t seed,
	size_t seed_len, const EVP_MD *md) {
	int ret = 0;
	EVP_MD_CTX ctx;
	EVP_MD_CTX_init(&ctx);

	size_t md_len = EVP_MD_size(md);

	for (uint32_t i = 0; len > 0; i++) {
	uint8_t counter[4];
	counter[0] = (uint8_t)(i >> 24);
	counter[1] = (uint8_t)(i >> 16);
	counter[2] = (uint8_t)(i >> 8);
	counter[3] = (uint8_t)i;
	if (!EVP_DigestInit_ex(&ctx, md, NULL) \|\|
	!EVP_DigestUpdate(&ctx, seed, seed_len) \|\|
	!EVP_DigestUpdate(&ctx, counter, sizeof(counter))) {
	goto err;
	}

	if (md_len <= len) {
	if (!EVP_DigestFinal_ex(&ctx, out, NULL)) {
	goto err;
	}
	out += md_len;
	len -= md_len;
	} else {
	uint8_t digest[EVP_MAX_MD_SIZE];
	if (!EVP_DigestFinal_ex(&ctx, digest, NULL)) {
	goto err;
	}
	OPENSSL_memcpy(out, digest, len);
	len = 0;
	}
	}

	ret = 1;

	err:
	EVP_MD_CTX_cleanup(&ctx);
	return ret;
	}

	int RSA_padding_add_PKCS1_OAEP_mgf1(uint8_t *to, size_t to_len,
	const uint8_t *from, size_t from_len,
	const uint8_t *param, size_t param_len,
	const EVP_MD md, const EVP_MD mgf1md) {
	if (md == NULL) {
	md = EVP_sha1();
	}
	if (mgf1md == NULL) {
	mgf1md = md;
	}

	size_t mdlen = EVP_MD_size(md);

	if (to_len < 2 * mdlen + 2) {
	OPENSSL_PUT_ERROR(RSA, RSA_R_KEY_SIZE_TOO_SMALL);
	return 0;
	}

	size_t emlen = to_len - 1;
	if (from_len > emlen - 2 * mdlen - 1) {
	OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_LARGE);
	return 0;
	}

	if (emlen < 2 * mdlen + 1) {
	OPENSSL_PUT_ERROR(RSA, RSA_R_KEY_SIZE_TOO_SMALL);
	return 0;
	}

	to[0] = 0;
	uint8_t *seed = to + 1;
	uint8_t *db = to + mdlen + 1;

	if (!EVP_Digest(param, param_len, db, NULL, md, NULL)) {
	return 0;
	}
	OPENSSL_memset(db + mdlen, 0, emlen - from_len - 2 * mdlen - 1);
	db[emlen - from_len - mdlen - 1] = 0x01;
	OPENSSL_memcpy(db + emlen - from_len - mdlen, from, from_len);
	if (!RAND_bytes(seed, mdlen)) {
	return 0;
	}

	uint8_t *dbmask = OPENSSL_malloc(emlen - mdlen);
	if (dbmask == NULL) {
	OPENSSL_PUT_ERROR(RSA, ERR_R_MALLOC_FAILURE);
	return 0;
	}

	int ret = 0;
	if (!PKCS1_MGF1(dbmask, emlen - mdlen, seed, mdlen, mgf1md)) {
	goto out;
	}
	for (size_t i = 0; i < emlen - mdlen; i++) {
	db[i] ^= dbmask[i];
	}

	uint8_t seedmask[EVP_MAX_MD_SIZE];
	if (!PKCS1_MGF1(seedmask, mdlen, db, emlen - mdlen, mgf1md)) {
	goto out;
	}
	for (size_t i = 0; i < mdlen; i++) {
	seed[i] ^= seedmask[i];
	}
	ret = 1;

	out:
	OPENSSL_free(dbmask);
	return ret;
	}

	int RSA_padding_check_PKCS1_OAEP_mgf1(uint8_t out, size_t out_len,
	size_t max_out, const uint8_t *from,
	size_t from_len, const uint8_t *param,
	size_t param_len, const EVP_MD *md,
	const EVP_MD *mgf1md) {
	uint8_t *db = NULL;

	if (md == NULL) {
	md = EVP_sha1();
	}
	if (mgf1md == NULL) {
	mgf1md = md;
	}

	size_t mdlen = EVP_MD_size(md);

	// The encoded message is one byte smaller than the modulus to ensure that it
	// doesn't end up greater than the modulus. Thus there's an extra "+1" here
	// compared to https://tools.ietf.org/html/rfc2437#section-9.1.1.2.
	if (from_len < 1 + 2*mdlen + 1) {
	// 'from_len' is the length of the modulus, i.e. does not depend on the
	// particular ciphertext.
	goto decoding_err;
	}

	size_t dblen = from_len - mdlen - 1;
	db = OPENSSL_malloc(dblen);
	if (db == NULL) {
	OPENSSL_PUT_ERROR(RSA, ERR_R_MALLOC_FAILURE);
	goto err;
	}

	const uint8_t *maskedseed = from + 1;
	const uint8_t *maskeddb = from + 1 + mdlen;

	uint8_t seed[EVP_MAX_MD_SIZE];
	if (!PKCS1_MGF1(seed, mdlen, maskeddb, dblen, mgf1md)) {
	goto err;
	}
	for (size_t i = 0; i < mdlen; i++) {
	seed[i] ^= maskedseed[i];
	}

	if (!PKCS1_MGF1(db, dblen, seed, mdlen, mgf1md)) {
	goto err;
	}
	for (size_t i = 0; i < dblen; i++) {
	db[i] ^= maskeddb[i];
	}

	uint8_t phash[EVP_MAX_MD_SIZE];
	if (!EVP_Digest(param, param_len, phash, NULL, md, NULL)) {
	goto err;
	}

	crypto_word_t bad = ~constant_time_is_zero_w(CRYPTO_memcmp(db, phash, mdlen));
	bad \|= ~constant_time_is_zero_w(from[0]);

	crypto_word_t looking_for_one_byte = CONSTTIME_TRUE_W;
	size_t one_index = 0;
	for (size_t i = mdlen; i < dblen; i++) {
	crypto_word_t equals1 = constant_time_eq_w(db[i], 1);
	crypto_word_t equals0 = constant_time_eq_w(db[i], 0);
	one_index =
	constant_time_select_w(looking_for_one_byte & equals1, i, one_index);
	looking_for_one_byte =
	constant_time_select_w(equals1, 0, looking_for_one_byte);
	bad \|= looking_for_one_byte & ~equals0;
	}

	bad \|= looking_for_one_byte;

	if (bad) {
	goto decoding_err;
	}

	one_index++;
	size_t mlen = dblen - one_index;
	if (max_out < mlen) {
	OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_LARGE);
	goto err;
	}

	OPENSSL_memcpy(out, db + one_index, mlen);
	*out_len = mlen;
	OPENSSL_free(db);
	return 1;

	decoding_err:
	// to avoid chosen ciphertext attacks, the error message should not reveal
	// which kind of decoding error happened
	OPENSSL_PUT_ERROR(RSA, RSA_R_OAEP_DECODING_ERROR);
	err:
	OPENSSL_free(db);
	return 0;
	}

	static const uint8_t kPSSZeroes[] = {0, 0, 0, 0, 0, 0, 0, 0};

	int RSA_verify_PKCS1_PSS_mgf1(RSA rsa, const uint8_t mHash,
	const EVP_MD Hash, const EVP_MD mgf1Hash,
	const uint8_t *EM, int sLen) {
	int i;
	int ret = 0;
	int maskedDBLen, MSBits, emLen;
	size_t hLen;
	const uint8_t *H;
	uint8_t *DB = NULL;
	EVP_MD_CTX ctx;
	uint8_t H_[EVP_MAX_MD_SIZE];
	EVP_MD_CTX_init(&ctx);

	if (mgf1Hash == NULL) {
	mgf1Hash = Hash;
	}

	hLen = EVP_MD_size(Hash);

	// Negative sLen has special meanings:
	// -1 sLen == hLen
	// -2 salt length is autorecovered from signature
	// -N reserved
	if (sLen == -1) {
	sLen = hLen;
	} else if (sLen == -2) {
	sLen = -2;
	} else if (sLen < -2) {
	OPENSSL_PUT_ERROR(RSA, RSA_R_SLEN_CHECK_FAILED);
	goto err;
	}

	MSBits = (BN_num_bits(rsa->n) - 1) & 0x7;
	emLen = RSA_size(rsa);
	if (EM[0] & (0xFF << MSBits)) {
	OPENSSL_PUT_ERROR(RSA, RSA_R_FIRST_OCTET_INVALID);
	goto err;
	}
	if (MSBits == 0) {
	EM++;
	emLen--;
	}
	if (emLen < (int)hLen + 2 \|\| emLen < ((int)hLen + sLen + 2)) {
	// sLen can be small negative
	OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_LARGE);
	goto err;
	}
	if (EM[emLen - 1] != 0xbc) {
	OPENSSL_PUT_ERROR(RSA, RSA_R_LAST_OCTET_INVALID);
	goto err;
	}
	maskedDBLen = emLen - hLen - 1;
	H = EM + maskedDBLen;
	DB = OPENSSL_malloc(maskedDBLen);
	if (!DB) {
	OPENSSL_PUT_ERROR(RSA, ERR_R_MALLOC_FAILURE);
	goto err;
	}
	if (!PKCS1_MGF1(DB, maskedDBLen, H, hLen, mgf1Hash)) {
	goto err;
	}
	for (i = 0; i < maskedDBLen; i++) {
	DB[i] ^= EM[i];
	}
	if (MSBits) {
	DB[0] &= 0xFF >> (8 - MSBits);
	}
	for (i = 0; DB[i] == 0 && i < (maskedDBLen - 1); i++) {
	;
	}
	if (DB[i++] != 0x1) {
	OPENSSL_PUT_ERROR(RSA, RSA_R_SLEN_RECOVERY_FAILED);
	goto err;
	}
	if (sLen >= 0 && (maskedDBLen - i) != sLen) {
	OPENSSL_PUT_ERROR(RSA, RSA_R_SLEN_CHECK_FAILED);
	goto err;
	}
	if (!EVP_DigestInit_ex(&ctx, Hash, NULL) \|\|
	!EVP_DigestUpdate(&ctx, kPSSZeroes, sizeof(kPSSZeroes)) \|\|
	!EVP_DigestUpdate(&ctx, mHash, hLen) \|\|
	!EVP_DigestUpdate(&ctx, DB + i, maskedDBLen - i) \|\|
	!EVP_DigestFinal_ex(&ctx, H_, NULL)) {
	goto err;
	}
	if (OPENSSL_memcmp(H_, H, hLen)) {
	OPENSSL_PUT_ERROR(RSA, RSA_R_BAD_SIGNATURE);
	ret = 0;
	} else {
	ret = 1;
	}

	err:
	OPENSSL_free(DB);
	EVP_MD_CTX_cleanup(&ctx);

	return ret;
	}

	int RSA_padding_add_PKCS1_PSS_mgf1(RSA rsa, unsigned char EM,
	const unsigned char *mHash,
	const EVP_MD Hash, const EVP_MD mgf1Hash,
	int sLenRequested) {
	int ret = 0;
	size_t maskedDBLen, MSBits, emLen;
	size_t hLen;
	unsigned char H, salt = NULL, *p;

	if (mgf1Hash == NULL) {
	mgf1Hash = Hash;
	}

	hLen = EVP_MD_size(Hash);

	if (BN_is_zero(rsa->n)) {
	OPENSSL_PUT_ERROR(RSA, RSA_R_EMPTY_PUBLIC_KEY);
	goto err;
	}

	MSBits = (BN_num_bits(rsa->n) - 1) & 0x7;
	emLen = RSA_size(rsa);
	if (MSBits == 0) {
	assert(emLen >= 1);
	*EM++ = 0;
	emLen--;
	}

	if (emLen < hLen + 2) {
	OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_LARGE);
	goto err;
	}

	// Negative sLenRequested has special meanings:
	// -1 sLen == hLen
	// -2 salt length is maximized
	// -N reserved
	size_t sLen;
	if (sLenRequested == -1) {
	sLen = hLen;
	} else if (sLenRequested == -2) {
	sLen = emLen - hLen - 2;
	} else if (sLenRequested < 0) {
	OPENSSL_PUT_ERROR(RSA, RSA_R_SLEN_CHECK_FAILED);
	goto err;
	} else {
	sLen = (size_t)sLenRequested;
	}

	if (emLen - hLen - 2 < sLen) {
	OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_LARGE);
	goto err;
	}

	if (sLen > 0) {
	salt = OPENSSL_malloc(sLen);
	if (!salt) {
	OPENSSL_PUT_ERROR(RSA, ERR_R_MALLOC_FAILURE);
	goto err;
	}
	if (!RAND_bytes(salt, sLen)) {
	goto err;
	}
	}
	maskedDBLen = emLen - hLen - 1;
	H = EM + maskedDBLen;

	EVP_MD_CTX ctx;
	EVP_MD_CTX_init(&ctx);
	int digest_ok = EVP_DigestInit_ex(&ctx, Hash, NULL) &&
	EVP_DigestUpdate(&ctx, kPSSZeroes, sizeof(kPSSZeroes)) &&
	EVP_DigestUpdate(&ctx, mHash, hLen) &&
	EVP_DigestUpdate(&ctx, salt, sLen) &&
	EVP_DigestFinal_ex(&ctx, H, NULL);
	EVP_MD_CTX_cleanup(&ctx);
	if (!digest_ok) {
	goto err;
	}

	// Generate dbMask in place then perform XOR on it
	if (!PKCS1_MGF1(EM, maskedDBLen, H, hLen, mgf1Hash)) {
	goto err;
	}

	p = EM;

	// Initial PS XORs with all zeroes which is a NOP so just update
	// pointer. Note from a test above this value is guaranteed to
	// be non-negative.
	p += emLen - sLen - hLen - 2;
	*p++ ^= 0x1;
	if (sLen > 0) {
	for (size_t i = 0; i < sLen; i++) {
	*p++ ^= salt[i];
	}
	}
	if (MSBits) {
	EM[0] &= 0xFF >> (8 - MSBits);
	}

	// H is already in place so just set final 0xbc

	EM[emLen - 1] = 0xbc;

	ret = 1;

	err:
	OPENSSL_free(salt);

	return ret;
	}