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         FIPS_selftest_check();
 223
 224         md_type = M_EVP_MD_type(mhash);
 225
 226         if (rsa_pad_mode == RSA_X931_PADDING)
 227                 {
 228                 int hash_id;
 229                 memcpy(tmpdinfo, md, md_len);
 230                 hash_id = RSA_X931_hash_id(md_type);
 231                 if (hash_id == -1)
 232                         {
 233                         RSAerr(RSA_F_FIPS_RSA_SIGN_DIGEST,RSA_R_UNKNOWN_ALGORITHM_TYPE);
 234                         return 0;
 235                         }
 236                 tmpdinfo[md_len] = (unsigned char)hash_id;
 237                 i = md_len + 1;
 238                 }
 239         else if (rsa_pad_mode == RSA_PKCS1_PADDING)
 240                 {
 241
 242                 der = fips_digestinfo_encoding(md_type, &dlen);
 243
 244                 if (!der)
 245                         {
 246                         RSAerr(RSA_F_FIPS_RSA_SIGN_DIGEST,RSA_R_UNKNOWN_ALGORITHM_TYPE);
 247                         return 0;
 248                         }
 249                 memcpy(tmpdinfo, der, dlen);
 250                 memcpy(tmpdinfo + dlen, md, md_len);
 251
 252                 i = dlen + md_len;
 253
 254                 }
 255         else if (rsa_pad_mode == RSA_PKCS1_PSS_PADDING)
 256                 {
 257                 unsigned char *sbuf;
 258                 i = RSA_size(rsa);
 259                 sbuf = OPENSSL_malloc(RSA_size(rsa));
 260                 if (!sbuf)
 261                         {
 262                         RSAerr(RSA_F_FIPS_RSA_SIGN_DIGEST,ERR_R_MALLOC_FAILURE);
 263                         goto psserr;
 264                         }
 265                 if (!RSA_padding_add_PKCS1_PSS_mgf1(rsa, sbuf, md, mhash,
 266                                                         mgf1Hash, saltlen))
 267                         goto psserr;
 268                 j=rsa->meth->rsa_priv_enc(i,sbuf,sigret,rsa,RSA_NO_PADDING);
 269                 if (j > 0)
 270                         {
 271                         ret=1;
 272                         *siglen=j;
 273                         }
 274                 psserr:
 275                 OPENSSL_cleanse(sbuf, i);
 276                 OPENSSL_free(sbuf);
 277                 return ret;
 278                 }
 279
 280         j=RSA_size(rsa);
 281         if (i > (j-RSA_PKCS1_PADDING_SIZE))
 282                 {
 283                 RSAerr(RSA_F_FIPS_RSA_SIGN_DIGEST,RSA_R_DIGEST_TOO_BIG_FOR_RSA_KEY);
 284                 goto done;
 285                 }
 286         /* NB: call underlying method directly to avoid FIPS blocking */
 287         j=rsa->meth->rsa_priv_enc(i,tmpdinfo,sigret,rsa,rsa_pad_mode);
 288         if (j > 0)
 289                 {
 290                 ret=1;
 291                 *siglen=j;
 292                 }
 293
 294         done:
 295         OPENSSL_cleanse(tmpdinfo,i);
 296         return ret;
 297         }
 298
 299 int FIPS_rsa_verify_ctx(RSA *rsa, EVP_MD_CTX *ctx,
 300                         int rsa_pad_mode, int saltlen, const EVP_MD *mgf1Hash,
 301                         unsigned char *sigbuf, unsigned int siglen)
 302         {
 303         unsigned int md_len, rv;
 304         unsigned char md[EVP_MAX_MD_SIZE];
 305         FIPS_digestfinal(ctx, md, &md_len);
 306         rv = FIPS_rsa_verify_digest(rsa, md, md_len, M_EVP_MD_CTX_md(ctx),
 307                                         rsa_pad_mode, saltlen, mgf1Hash,
 308                                         sigbuf, siglen);
 309         OPENSSL_cleanse(md, md_len);
 310         return rv;
 311         }
 312
 313 int FIPS_rsa_verify_digest(RSA *rsa, const unsigned char *dig, int diglen,
 314                         const EVP_MD *mhash, int rsa_pad_mode, int saltlen,
 315                         const EVP_MD *mgf1Hash,
 316                         unsigned char *sigbuf, unsigned int siglen)
 317         {
 318         int i,ret=0;
 319         unsigned int dlen;
 320         unsigned char *s;
 321         const unsigned char *der;
 322         int md_type;
 323         int rsa_dec_pad_mode;
 324
 325         if (siglen != (unsigned int)RSA_size(rsa))
 326                 {
 327                 RSAerr(RSA_F_FIPS_RSA_VERIFY_DIGEST,RSA_R_WRONG_SIGNATURE_LENGTH);
 328                 return(0);
 329                 }
 330
 331         FIPS_selftest_check();
 332
 333         md_type = M_EVP_MD_type(mhash);
 334
 335         s= OPENSSL_malloc((unsigned int)siglen);
 336         if (s == NULL)
 337                 {
 338                 RSAerr(RSA_F_FIPS_RSA_VERIFY_DIGEST,ERR_R_MALLOC_FAILURE);
 339                 goto err;
 340                 }
 341
 342         if (rsa_pad_mode == RSA_PKCS1_PSS_PADDING)
 343                 rsa_dec_pad_mode = RSA_NO_PADDING;
 344         else
 345                 rsa_dec_pad_mode = rsa_pad_mode;
 346
 347         /* NB: call underlying method directly to avoid FIPS blocking */
 348         i=rsa->meth->rsa_pub_dec((int)siglen,sigbuf,s, rsa, rsa_dec_pad_mode);
 349
 350         if (i <= 0) goto err;
 351
 352         if (rsa_pad_mode == RSA_X931_PADDING)
 353                 {
 354                 int hash_id;
 355                 if (i != (int)(diglen + 1))
 356                         {
 357                         RSAerr(RSA_F_FIPS_RSA_VERIFY_DIGEST,RSA_R_BAD_SIGNATURE);
 358                         goto err;
 359                         }
 360                 hash_id = RSA_X931_hash_id(md_type);
 361                 if (hash_id == -1)
 362                         {
 363                         RSAerr(RSA_F_FIPS_RSA_VERIFY_DIGEST,RSA_R_UNKNOWN_ALGORITHM_TYPE);
 364                         goto err;
 365                         }
 366                 if (s[diglen] != (unsigned char)hash_id)
 367                         {
 368                         RSAerr(RSA_F_FIPS_RSA_VERIFY_DIGEST,RSA_R_BAD_SIGNATURE);
 369                         goto err;
 370                         }
 371                 if (memcmp(s, dig, diglen))
 372                         {
 373                         RSAerr(RSA_F_FIPS_RSA_VERIFY_DIGEST,RSA_R_BAD_SIGNATURE);
 374                         goto err;
 375                         }
 376                 ret = 1;
 377                 }
 378         else if (rsa_pad_mode == RSA_PKCS1_PADDING)
 379                 {
 380
 381                 der = fips_digestinfo_encoding(md_type, &dlen);
 382
 383                 if (!der)
 384                         {
 385                         RSAerr(RSA_F_FIPS_RSA_VERIFY_DIGEST,RSA_R_UNKNOWN_ALGORITHM_TYPE);
 386                         return(0);
 387                         }
 388
 389                 /* Compare, DigestInfo length, DigestInfo header and finally
 390                  * digest value itself
 391                  */
 392
 393                 /* If length mismatch try alternate encoding */
 394                 if (i != (int)(dlen + diglen))
 395                         der = fips_digestinfo_nn_encoding(md_type, &dlen);
 396
 397                 if ((i != (int)(dlen + diglen)) || memcmp(der, s, dlen)
 398                         || memcmp(s + dlen, dig, diglen))
 399                         {
 400                         RSAerr(RSA_F_FIPS_RSA_VERIFY_DIGEST,RSA_R_BAD_SIGNATURE);
 401                         goto err;
 402                         }
 403                 ret = 1;
 404
 405                 }
 406         else if (rsa_pad_mode == RSA_PKCS1_PSS_PADDING)
 407                 {
 408                 ret = RSA_verify_PKCS1_PSS_mgf1(rsa, dig, mhash, mgf1Hash,
 409                                                 s, saltlen);
 410                 if (ret < 0)
 411                         ret = 0;
 412                 }
 413 err:
 414         if (s != NULL)
 415                 {
 416                 OPENSSL_cleanse(s, siglen);
 417                 OPENSSL_free(s);
 418                 }
 419         return(ret);
 420         }
 421
 422 #endif