crypto/rsa/rsa_pss.c

   1 /*
   2  * Copyright 2005-2018 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 /*
  11  * RSA low level APIs are deprecated for public use, but still ok for
  12  * internal use.
  13  */
  14 #include "internal/deprecated.h"
  15
  16 #include <stdio.h>
  17 #include "internal/cryptlib.h"
  18 #include <openssl/bn.h>
  19 #include <openssl/rsa.h>
  20 #include <openssl/evp.h>
  21 #include <openssl/rand.h>
  22 #include <openssl/sha.h>
  23 #include "rsa_local.h"
  24
  25 static const unsigned char zeroes[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
  26
  27 #if defined(_MSC_VER) && defined(_ARM_)
  28 # pragma optimize("g", off)
  29 #endif
  30
  31 int RSA_verify_PKCS1_PSS(RSA *rsa, const unsigned char *mHash,
  32                          const EVP_MD *Hash, const unsigned char *EM,
  33                          int sLen)
  34 {
  35     return RSA_verify_PKCS1_PSS_mgf1(rsa, mHash, Hash, NULL, EM, sLen);
  36 }
  37
  38 int RSA_verify_PKCS1_PSS_mgf1(RSA *rsa, const unsigned char *mHash,
  39                               const EVP_MD *Hash, const EVP_MD *mgf1Hash,
  40                               const unsigned char *EM, int sLen)
  41 {
  42     int i;
  43     int ret = 0;
  44     int hLen, maskedDBLen, MSBits, emLen;
  45     const unsigned char *H;
  46     unsigned char *DB = NULL;
  47     EVP_MD_CTX *ctx = EVP_MD_CTX_new();
  48     unsigned char H_[EVP_MAX_MD_SIZE];
  49
  50     if (ctx == NULL)
  51         goto err;
  52
  53     if (mgf1Hash == NULL)
  54         mgf1Hash = Hash;
  55
  56     hLen = EVP_MD_size(Hash);
  57     if (hLen < 0)
  58         goto err;
  59     /*-
  60      * Negative sLen has special meanings:
  61      *      -1      sLen == hLen
  62      *      -2      salt length is autorecovered from signature
  63      *      -3      salt length is maximized
  64      *      -N      reserved
  65      */
  66     if (sLen == RSA_PSS_SALTLEN_DIGEST) {
  67         sLen = hLen;
  68     } else if (sLen < RSA_PSS_SALTLEN_MAX) {
  69         RSAerr(RSA_F_RSA_VERIFY_PKCS1_PSS_MGF1, RSA_R_SLEN_CHECK_FAILED);
  70         goto err;
  71     }
  72
  73     MSBits = (BN_num_bits(rsa->n) - 1) & 0x7;
  74     emLen = RSA_size(rsa);
  75     if (EM[0] & (0xFF << MSBits)) {
  76         RSAerr(RSA_F_RSA_VERIFY_PKCS1_PSS_MGF1, RSA_R_FIRST_OCTET_INVALID);
  77         goto err;
  78     }
  79     if (MSBits == 0) {
  80         EM++;
  81         emLen--;
  82     }
  83     if (emLen < hLen + 2) {
  84         RSAerr(RSA_F_RSA_VERIFY_PKCS1_PSS_MGF1, RSA_R_DATA_TOO_LARGE);
  85         goto err;
  86     }
  87     if (sLen == RSA_PSS_SALTLEN_MAX) {
  88         sLen = emLen - hLen - 2;
  89     } else if (sLen > emLen - hLen - 2) { /* sLen can be small negative */
  90         RSAerr(RSA_F_RSA_VERIFY_PKCS1_PSS_MGF1, RSA_R_DATA_TOO_LARGE);
  91         goto err;
  92     }
  93     if (EM[emLen - 1] != 0xbc) {
  94         RSAerr(RSA_F_RSA_VERIFY_PKCS1_PSS_MGF1, RSA_R_LAST_OCTET_INVALID);
  95         goto err;
  96     }
  97     maskedDBLen = emLen - hLen - 1;
  98     H = EM + maskedDBLen;
  99     DB = OPENSSL_malloc(maskedDBLen);
 100     if (DB == NULL) {
 101         RSAerr(RSA_F_RSA_VERIFY_PKCS1_PSS_MGF1, ERR_R_MALLOC_FAILURE);
 102         goto err;
 103     }
 104     if (PKCS1_MGF1(DB, maskedDBLen, H, hLen, mgf1Hash) < 0)
 105         goto err;
 106     for (i = 0; i < maskedDBLen; i++)
 107         DB[i] ^= EM[i];
 108     if (MSBits)
 109         DB[0] &= 0xFF >> (8 - MSBits);
 110     for (i = 0; DB[i] == 0 && i < (maskedDBLen - 1); i++) ;
 111     if (DB[i++] != 0x1) {
 112         RSAerr(RSA_F_RSA_VERIFY_PKCS1_PSS_MGF1, RSA_R_SLEN_RECOVERY_FAILED);
 113         goto err;
 114     }
 115     if (sLen != RSA_PSS_SALTLEN_AUTO && (maskedDBLen - i) != sLen) {
 116         RSAerr(RSA_F_RSA_VERIFY_PKCS1_PSS_MGF1, RSA_R_SLEN_CHECK_FAILED);
 117         goto err;
 118     }
 119     if (!EVP_DigestInit_ex(ctx, Hash, NULL)
 120         || !EVP_DigestUpdate(ctx, zeroes, sizeof(zeroes))
 121         || !EVP_DigestUpdate(ctx, mHash, hLen))
 122         goto err;
 123     if (maskedDBLen - i) {
 124         if (!EVP_DigestUpdate(ctx, DB + i, maskedDBLen - i))
 125             goto err;
 126     }
 127     if (!EVP_DigestFinal_ex(ctx, H_, NULL))
 128         goto err;
 129     if (memcmp(H_, H, hLen)) {
 130         RSAerr(RSA_F_RSA_VERIFY_PKCS1_PSS_MGF1, RSA_R_BAD_SIGNATURE);
 131         ret = 0;
 132     } else {
 133         ret = 1;
 134     }
 135
 136  err:
 137     OPENSSL_free(DB);
 138     EVP_MD_CTX_free(ctx);
 139
 140     return ret;
 141
 142 }
 143
 144 int RSA_padding_add_PKCS1_PSS(RSA *rsa, unsigned char *EM,
 145                               const unsigned char *mHash,
 146                               const EVP_MD *Hash, int sLen)
 147 {
 148     return RSA_padding_add_PKCS1_PSS_mgf1(rsa, EM, mHash, Hash, NULL, sLen);
 149 }
 150
 151 int RSA_padding_add_PKCS1_PSS_mgf1(RSA *rsa, unsigned char *EM,
 152                                    const unsigned char *mHash,
 153                                    const EVP_MD *Hash, const EVP_MD *mgf1Hash,
 154                                    int sLen)
 155 {
 156     int i;
 157     int ret = 0;
 158     int hLen, maskedDBLen, MSBits, emLen;
 159     unsigned char *H, *salt = NULL, *p;
 160     EVP_MD_CTX *ctx = NULL;
 161
 162     if (mgf1Hash == NULL)
 163         mgf1Hash = Hash;
 164
 165     hLen = EVP_MD_size(Hash);
 166     if (hLen < 0)
 167         goto err;
 168     /*-
 169      * Negative sLen has special meanings:
 170      *      -1      sLen == hLen
 171      *      -2      salt length is maximized
 172      *      -3      same as above (on signing)
 173      *      -N      reserved
 174      */
 175     if (sLen == RSA_PSS_SALTLEN_DIGEST) {
 176         sLen = hLen;
 177     } else if (sLen == RSA_PSS_SALTLEN_MAX_SIGN) {
 178         sLen = RSA_PSS_SALTLEN_MAX;
 179     } else if (sLen < RSA_PSS_SALTLEN_MAX) {
 180         RSAerr(RSA_F_RSA_PADDING_ADD_PKCS1_PSS_MGF1, RSA_R_SLEN_CHECK_FAILED);
 181         goto err;
 182     }
 183
 184     MSBits = (BN_num_bits(rsa->n) - 1) & 0x7;
 185     emLen = RSA_size(rsa);
 186     if (MSBits == 0) {
 187         *EM++ = 0;
 188         emLen--;
 189     }
 190     if (emLen < hLen + 2) {
 191         RSAerr(RSA_F_RSA_PADDING_ADD_PKCS1_PSS_MGF1,
 192                RSA_R_DATA_TOO_LARGE_FOR_KEY_SIZE);
 193         goto err;
 194     }
 195     if (sLen == RSA_PSS_SALTLEN_MAX) {
 196         sLen = emLen - hLen - 2;
 197     } else if (sLen > emLen - hLen - 2) {
 198         RSAerr(RSA_F_RSA_PADDING_ADD_PKCS1_PSS_MGF1,
 199                RSA_R_DATA_TOO_LARGE_FOR_KEY_SIZE);
 200         goto err;
 201     }
 202     if (sLen > 0) {
 203         salt = OPENSSL_malloc(sLen);
 204         if (salt == NULL) {
 205             RSAerr(RSA_F_RSA_PADDING_ADD_PKCS1_PSS_MGF1,
 206                    ERR_R_MALLOC_FAILURE);
 207             goto err;
 208         }
 209         if (RAND_bytes(salt, sLen) <= 0)
 210             goto err;
 211     }
 212     maskedDBLen = emLen - hLen - 1;
 213     H = EM + maskedDBLen;
 214     ctx = EVP_MD_CTX_new();
 215     if (ctx == NULL)
 216         goto err;
 217     if (!EVP_DigestInit_ex(ctx, Hash, NULL)
 218         || !EVP_DigestUpdate(ctx, zeroes, sizeof(zeroes))
 219         || !EVP_DigestUpdate(ctx, mHash, hLen))
 220         goto err;
 221     if (sLen && !EVP_DigestUpdate(ctx, salt, sLen))
 222         goto err;
 223     if (!EVP_DigestFinal_ex(ctx, H, NULL))
 224         goto err;
 225
 226     /* Generate dbMask in place then perform XOR on it */
 227     if (PKCS1_MGF1(EM, maskedDBLen, H, hLen, mgf1Hash))
 228         goto err;
 229
 230     p = EM;
 231
 232     /*
 233      * Initial PS XORs with all zeroes which is a NOP so just update pointer.
 234      * Note from a test above this value is guaranteed to be non-negative.
 235      */
 236     p += emLen - sLen - hLen - 2;
 237     *p++ ^= 0x1;
 238     if (sLen > 0) {
 239         for (i = 0; i < sLen; i++)
 240             *p++ ^= salt[i];
 241     }
 242     if (MSBits)
 243         EM[0] &= 0xFF >> (8 - MSBits);
 244
 245     /* H is already in place so just set final 0xbc */
 246
 247     EM[emLen - 1] = 0xbc;
 248
 249     ret = 1;
 250
 251  err:
 252     EVP_MD_CTX_free(ctx);
 253     OPENSSL_clear_free(salt, (size_t)sLen); /* salt != NULL implies sLen > 0 */
 254
 255     return ret;
 256
 257 }
 258
 259 #if defined(_MSC_VER)
 260 # pragma optimize("",on)
 261 #endif