Move FIPS RSA function definitions to fips.h
[openssl.git] / 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                         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                         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