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