fips/rsa/fips_rsa_sign.c

   1 /* fips_rsa_sign.c */
   2 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
   3  * project 2007.
   4  */
   5 /* ====================================================================
   6  * Copyright (c) 2007 The OpenSSL Project.  All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  *
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in
  17  *    the documentation and/or other materials provided with the
  18  *    distribution.
  19  *
  20  * 3. All advertising materials mentioning features or use of this
  21  *    software must display the following acknowledgment:
  22  *    "This product includes software developed by the OpenSSL Project
  23  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
  24  *
  25  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  26  *    endorse or promote products derived from this software without
  27  *    prior written permission. For written permission, please contact
  28  *    licensing@OpenSSL.org.
  29  *
  30  * 5. Products derived from this software may not be called "OpenSSL"
  31  *    nor may "OpenSSL" appear in their names without prior written
  32  *    permission of the OpenSSL Project.
  33  *
  34  * 6. Redistributions of any form whatsoever must retain the following
  35  *    acknowledgment:
  36  *    "This product includes software developed by the OpenSSL Project
  37  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
  38  *
  39  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  40  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  41  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  42  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  43  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  44  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  45  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  46  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  48  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  49  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  50  * OF THE POSSIBILITY OF SUCH DAMAGE.
  51  * ====================================================================
  52  *
  53  * This product includes cryptographic software written by Eric Young
  54  * (eay@cryptsoft.com).  This product includes software written by Tim
  55  * Hudson (tjh@cryptsoft.com).
  56  *
  57  */
  58
  59 #define OPENSSL_FIPSAPI
  60
  61 #include <string.h>
  62 #include <openssl/evp.h>
  63 #include <openssl/rsa.h>
  64 #include <openssl/err.h>
  65 #include <openssl/sha.h>
  66 #include <openssl/fips.h>
  67
  68 #ifdef OPENSSL_FIPS
  69
  70 /* FIPS versions of RSA_sign() and RSA_verify().
  71  * These will only have to deal with SHA* signatures and by including
  72  * pregenerated encodings all ASN1 dependencies can be avoided
  73  */
  74
  75 /* Standard encodings including NULL parameter */
  76
  77 static const unsigned char sha1_bin[] = {
  78   0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03, 0x02, 0x1a, 0x05,
  79   0x00, 0x04, 0x14
  80 };
  81
  82 static const unsigned char sha224_bin[] = {
  83   0x30, 0x2d, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03,
  84   0x04, 0x02, 0x04, 0x05, 0x00, 0x04, 0x1c
  85 };
  86
  87 static const unsigned char sha256_bin[] = {
  88   0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03,
  89   0x04, 0x02, 0x01, 0x05, 0x00, 0x04, 0x20
  90 };
  91
  92 static const unsigned char sha384_bin[] = {
  93   0x30, 0x41, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03,
  94   0x04, 0x02, 0x02, 0x05, 0x00, 0x04, 0x30
  95 };
  96
  97 static const unsigned char sha512_bin[] = {
  98   0x30, 0x51, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03,
  99   0x04, 0x02, 0x03, 0x05, 0x00, 0x04, 0x40
 100 };
 101
 102 /* Alternate encodings with absent parameters. We don't generate signature
 103  * using this format but do tolerate received signatures of this form.
 104  */
 105
 106 static unsigned char sha1_nn_bin[] = {
 107   0x30, 0x1f, 0x30, 0x07, 0x06, 0x05, 0x2b, 0x0e, 0x03, 0x02, 0x1a, 0x04,
 108   0x14
 109 };
 110
 111 static unsigned char sha224_nn_bin[] = {
 112   0x30, 0x2b, 0x30, 0x0b, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03,
 113   0x04, 0x02, 0x04, 0x04, 0x1c
 114 };
 115
 116 static unsigned char sha256_nn_bin[] = {
 117   0x30, 0x2f, 0x30, 0x0b, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03,
 118   0x04, 0x02, 0x01, 0x04, 0x20
 119 };
 120
 121 static unsigned char sha384_nn_bin[] = {
 122   0x30, 0x3f, 0x30, 0x0b, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03,
 123   0x04, 0x02, 0x02, 0x04, 0x30
 124 };
 125
 126 static unsigned char sha512_nn_bin[] = {
 127   0x30, 0x4f, 0x30, 0x0b, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03,
 128   0x04, 0x02, 0x03, 0x04, 0x40
 129 };
 130
 131
 132 static const unsigned char *fips_digestinfo_encoding(int nid, unsigned int *len)
 133         {
 134         switch (nid)
 135                 {
 136
 137                 case NID_sha1:
 138                 *len = sizeof(sha1_bin);
 139                 return sha1_bin;
 140
 141                 case NID_sha224:
 142                 *len = sizeof(sha224_bin);
 143                 return sha224_bin;
 144
 145                 case NID_sha256:
 146                 *len = sizeof(sha256_bin);
 147                 return sha256_bin;
 148
 149                 case NID_sha384:
 150                 *len = sizeof(sha384_bin);
 151                 return sha384_bin;
 152
 153                 case NID_sha512:
 154                 *len = sizeof(sha512_bin);
 155                 return sha512_bin;
 156
 157                 default:
 158                 return NULL;
 159
 160                 }
 161         }
 162
 163 static const unsigned char *fips_digestinfo_nn_encoding(int nid, unsigned int *len)
 164         {
 165         switch (nid)
 166                 {
 167
 168                 case NID_sha1:
 169                 *len = sizeof(sha1_nn_bin);
 170                 return sha1_nn_bin;
 171
 172                 case NID_sha224:
 173                 *len = sizeof(sha224_nn_bin);
 174                 return sha224_nn_bin;
 175
 176                 case NID_sha256:
 177                 *len = sizeof(sha256_nn_bin);
 178                 return sha256_nn_bin;
 179
 180                 case NID_sha384:
 181                 *len = sizeof(sha384_nn_bin);
 182                 return sha384_nn_bin;
 183
 184                 case NID_sha512:
 185                 *len = sizeof(sha512_nn_bin);
 186                 return sha512_nn_bin;
 187
 188                 default:
 189                 return NULL;
 190
 191                 }
 192         }
 193
 194 int FIPS_rsa_sign_ctx(RSA *rsa, EVP_MD_CTX *ctx,
 195                         int rsa_pad_mode, int saltlen, const EVP_MD *mgf1Hash,
 196                         unsigned char *sigret, unsigned int *siglen)
 197         {
 198         unsigned int md_len, rv;
 199         unsigned char md[EVP_MAX_MD_SIZE];
 200         FIPS_digestfinal(ctx, md, &md_len);
 201         rv = FIPS_rsa_sign_digest(rsa, md, md_len,
 202                                         M_EVP_MD_CTX_md(ctx),
 203                                         rsa_pad_mode, saltlen,
 204                                         mgf1Hash, sigret, siglen);
 205         OPENSSL_cleanse(md, md_len);
 206         return rv;
 207         }
 208
 209
 210 int FIPS_rsa_sign_digest(RSA *rsa, const unsigned char *md, int md_len,
 211                         const EVP_MD *mhash, int rsa_pad_mode, int saltlen,
 212                         const EVP_MD *mgf1Hash,
 213                         unsigned char *sigret, unsigned int *siglen)
 214         {
 215         int i=0,j,ret=0;
 216         unsigned int dlen;
 217         const unsigned char *der;
 218         int md_type;
 219         /* Largest DigestInfo: 19 (max encoding) + max MD */
 220         unsigned char tmpdinfo[19 + EVP_MAX_MD_SIZE];
 221
 222         if (FIPS_selftest_failed())
 223                 {
 224                 FIPSerr(FIPS_F_FIPS_RSA_SIGN_DIGEST, FIPS_R_SELFTEST_FAILED);
 225                 return 0;
 226                 }
 227         if (!mhash && rsa_pad_mode == RSA_PKCS1_PADDING)
 228                 md_type = saltlen;
 229         else
 230                 md_type = M_EVP_MD_type(mhash);
 231
 232         if (rsa_pad_mode == RSA_X931_PADDING)
 233                 {
 234                 int hash_id;
 235                 memcpy(tmpdinfo, md, md_len);
 236                 hash_id = RSA_X931_hash_id(md_type);
 237                 if (hash_id == -1)
 238                         {
 239                         RSAerr(RSA_F_FIPS_RSA_SIGN_DIGEST,RSA_R_UNKNOWN_ALGORITHM_TYPE);
 240                         return 0;
 241                         }
 242                 tmpdinfo[md_len] = (unsigned char)hash_id;
 243                 i = md_len + 1;
 244                 }
 245         else if (rsa_pad_mode == RSA_PKCS1_PADDING)
 246                 {
 247
 248                 der = fips_digestinfo_encoding(md_type, &dlen);
 249
 250                 if (!der)
 251                         {
 252                         RSAerr(RSA_F_FIPS_RSA_SIGN_DIGEST,RSA_R_UNKNOWN_ALGORITHM_TYPE);
 253                         return 0;
 254                         }
 255                 memcpy(tmpdinfo, der, dlen);
 256                 memcpy(tmpdinfo + dlen, md, md_len);
 257
 258                 i = dlen + md_len;
 259
 260                 }
 261         else if (rsa_pad_mode == RSA_PKCS1_PSS_PADDING)
 262                 {
 263                 unsigned char *sbuf;
 264                 i = RSA_size(rsa);
 265                 sbuf = OPENSSL_malloc(RSA_size(rsa));
 266                 if (!sbuf)
 267                         {
 268                         RSAerr(RSA_F_FIPS_RSA_SIGN_DIGEST,ERR_R_MALLOC_FAILURE);
 269                         goto psserr;
 270                         }
 271                 if (!RSA_padding_add_PKCS1_PSS_mgf1(rsa, sbuf, md, mhash,
 272                                                         mgf1Hash, saltlen))
 273                         goto psserr;
 274                 j=rsa->meth->rsa_priv_enc(i,sbuf,sigret,rsa,RSA_NO_PADDING);
 275                 if (j > 0)
 276                         {
 277                         ret=1;
 278                         *siglen=j;
 279                         }
 280                 psserr:
 281                 OPENSSL_cleanse(sbuf, i);
 282                 OPENSSL_free(sbuf);
 283                 return ret;
 284                 }
 285
 286         j=RSA_size(rsa);
 287         if (i > (j-RSA_PKCS1_PADDING_SIZE))
 288                 {
 289                 RSAerr(RSA_F_FIPS_RSA_SIGN_DIGEST,RSA_R_DIGEST_TOO_BIG_FOR_RSA_KEY);
 290                 goto done;
 291                 }
 292         /* NB: call underlying method directly to avoid FIPS blocking */
 293         j=rsa->meth->rsa_priv_enc(i,tmpdinfo,sigret,rsa,rsa_pad_mode);
 294         if (j > 0)
 295                 {
 296                 ret=1;
 297                 *siglen=j;
 298                 }
 299
 300         done:
 301         OPENSSL_cleanse(tmpdinfo,i);
 302         return ret;
 303         }
 304
 305 int FIPS_rsa_verify_ctx(RSA *rsa, EVP_MD_CTX *ctx,
 306                         int rsa_pad_mode, int saltlen, const EVP_MD *mgf1Hash,
 307                         const unsigned char *sigbuf, unsigned int siglen)
 308         {
 309         unsigned int md_len, rv;
 310         unsigned char md[EVP_MAX_MD_SIZE];
 311         FIPS_digestfinal(ctx, md, &md_len);
 312         rv = FIPS_rsa_verify_digest(rsa, md, md_len, M_EVP_MD_CTX_md(ctx),
 313                                         rsa_pad_mode, saltlen, mgf1Hash,
 314                                         sigbuf, siglen);
 315         OPENSSL_cleanse(md, md_len);
 316         return rv;
 317         }
 318
 319 int FIPS_rsa_verify_digest(RSA *rsa, const unsigned char *dig, int diglen,
 320                         const EVP_MD *mhash, int rsa_pad_mode, int saltlen,
 321                         const EVP_MD *mgf1Hash,
 322                         const unsigned char *sigbuf, unsigned int siglen)
 323         {
 324         int i,ret=0;
 325         unsigned int dlen;
 326         unsigned char *s;
 327         const unsigned char *der;
 328         int md_type;
 329         int rsa_dec_pad_mode;
 330
 331         if (FIPS_selftest_failed())
 332                 {
 333                 FIPSerr(FIPS_F_FIPS_RSA_VERIFY_DIGEST, FIPS_R_SELFTEST_FAILED);
 334                 return 0;
 335                 }
 336
 337         if (siglen != (unsigned int)RSA_size(rsa))
 338                 {
 339                 RSAerr(RSA_F_FIPS_RSA_VERIFY_DIGEST,RSA_R_WRONG_SIGNATURE_LENGTH);
 340                 return(0);
 341                 }
 342
 343         if (!mhash && rsa_pad_mode == RSA_PKCS1_PADDING)
 344                 md_type = saltlen;
 345         else
 346                 md_type = M_EVP_MD_type(mhash);
 347
 348         s= OPENSSL_malloc((unsigned int)siglen);
 349         if (s == NULL)
 350                 {
 351                 RSAerr(RSA_F_FIPS_RSA_VERIFY_DIGEST,ERR_R_MALLOC_FAILURE);
 352                 goto err;
 353                 }
 354
 355         if (rsa_pad_mode == RSA_PKCS1_PSS_PADDING)
 356                 rsa_dec_pad_mode = RSA_NO_PADDING;
 357         else
 358                 rsa_dec_pad_mode = rsa_pad_mode;
 359
 360         /* NB: call underlying method directly to avoid FIPS blocking */
 361         i=rsa->meth->rsa_pub_dec((int)siglen,sigbuf,s, rsa, rsa_dec_pad_mode);
 362
 363         if (i <= 0) goto err;
 364
 365         if (rsa_pad_mode == RSA_X931_PADDING)
 366                 {
 367                 int hash_id;
 368                 if (i != (int)(diglen + 1))
 369                         {
 370                         RSAerr(RSA_F_FIPS_RSA_VERIFY_DIGEST,RSA_R_BAD_SIGNATURE);
 371                         goto err;
 372                         }
 373                 hash_id = RSA_X931_hash_id(md_type);
 374                 if (hash_id == -1)
 375                         {
 376                         RSAerr(RSA_F_FIPS_RSA_VERIFY_DIGEST,RSA_R_UNKNOWN_ALGORITHM_TYPE);
 377                         goto err;
 378                         }
 379                 if (s[diglen] != (unsigned char)hash_id)
 380                         {
 381                         RSAerr(RSA_F_FIPS_RSA_VERIFY_DIGEST,RSA_R_BAD_SIGNATURE);
 382                         goto err;
 383                         }
 384                 if (memcmp(s, dig, diglen))
 385                         {
 386                         RSAerr(RSA_F_FIPS_RSA_VERIFY_DIGEST,RSA_R_BAD_SIGNATURE);
 387                         goto err;
 388                         }
 389                 ret = 1;
 390                 }
 391         else if (rsa_pad_mode == RSA_PKCS1_PADDING)
 392                 {
 393
 394                 der = fips_digestinfo_encoding(md_type, &dlen);
 395
 396                 if (!der)
 397                         {
 398                         RSAerr(RSA_F_FIPS_RSA_VERIFY_DIGEST,RSA_R_UNKNOWN_ALGORITHM_TYPE);
 399                         return(0);
 400                         }
 401
 402                 /* Compare, DigestInfo length, DigestInfo header and finally
 403                  * digest value itself
 404                  */
 405
 406                 /* If length mismatch try alternate encoding */
 407                 if (i != (int)(dlen + diglen))
 408                         der = fips_digestinfo_nn_encoding(md_type, &dlen);
 409
 410                 if ((i != (int)(dlen + diglen)) || memcmp(der, s, dlen)
 411                         || memcmp(s + dlen, dig, diglen))
 412                         {
 413                         RSAerr(RSA_F_FIPS_RSA_VERIFY_DIGEST,RSA_R_BAD_SIGNATURE);
 414                         goto err;
 415                         }
 416                 ret = 1;
 417
 418                 }
 419         else if (rsa_pad_mode == RSA_PKCS1_PSS_PADDING)
 420                 {
 421                 ret = RSA_verify_PKCS1_PSS_mgf1(rsa, dig, mhash, mgf1Hash,
 422                                                 s, saltlen);
 423                 if (ret < 0)
 424                         ret = 0;
 425                 }
 426 err:
 427         if (s != NULL)
 428                 {
 429                 OPENSSL_cleanse(s, siglen);
 430                 OPENSSL_free(s);
 431                 }
 432         return(ret);
 433         }
 434
 435 #endif