3f941b10327b18af68849ec90937c4409b54e128
[openssl.git] / providers / implementations / signature / rsa.c
1 /*
2  * Copyright 2019 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 <string.h>
17 #include <openssl/crypto.h>
18 #include <openssl/core_numbers.h>
19 #include <openssl/core_names.h>
20 #include <openssl/err.h>
21 #include <openssl/rsa.h>
22 #include <openssl/params.h>
23 #include <openssl/evp.h>
24 #include "internal/cryptlib.h"
25 #include "internal/nelem.h"
26 #include "internal/sizes.h"
27 #include "crypto/rsa.h"
28 #include "prov/providercommonerr.h"
29 #include "prov/implementations.h"
30 #include "prov/provider_ctx.h"
31
32 static OSSL_OP_signature_newctx_fn rsa_newctx;
33 static OSSL_OP_signature_sign_init_fn rsa_signature_init;
34 static OSSL_OP_signature_verify_init_fn rsa_signature_init;
35 static OSSL_OP_signature_verify_recover_init_fn rsa_signature_init;
36 static OSSL_OP_signature_sign_fn rsa_sign;
37 static OSSL_OP_signature_verify_fn rsa_verify;
38 static OSSL_OP_signature_verify_recover_fn rsa_verify_recover;
39 static OSSL_OP_signature_digest_sign_init_fn rsa_digest_signverify_init;
40 static OSSL_OP_signature_digest_sign_update_fn rsa_digest_signverify_update;
41 static OSSL_OP_signature_digest_sign_final_fn rsa_digest_sign_final;
42 static OSSL_OP_signature_digest_verify_init_fn rsa_digest_signverify_init;
43 static OSSL_OP_signature_digest_verify_update_fn rsa_digest_signverify_update;
44 static OSSL_OP_signature_digest_verify_final_fn rsa_digest_verify_final;
45 static OSSL_OP_signature_freectx_fn rsa_freectx;
46 static OSSL_OP_signature_dupctx_fn rsa_dupctx;
47 static OSSL_OP_signature_get_ctx_params_fn rsa_get_ctx_params;
48 static OSSL_OP_signature_gettable_ctx_params_fn rsa_gettable_ctx_params;
49 static OSSL_OP_signature_set_ctx_params_fn rsa_set_ctx_params;
50 static OSSL_OP_signature_settable_ctx_params_fn rsa_settable_ctx_params;
51 static OSSL_OP_signature_get_ctx_md_params_fn rsa_get_ctx_md_params;
52 static OSSL_OP_signature_gettable_ctx_md_params_fn rsa_gettable_ctx_md_params;
53 static OSSL_OP_signature_set_ctx_md_params_fn rsa_set_ctx_md_params;
54 static OSSL_OP_signature_settable_ctx_md_params_fn rsa_settable_ctx_md_params;
55
56 static OSSL_ITEM padding_item[] = {
57     { RSA_PKCS1_PADDING,        "pkcs1"  },
58     { RSA_SSLV23_PADDING,       "sslv23" },
59     { RSA_NO_PADDING,           "none"   },
60     { RSA_PKCS1_OAEP_PADDING,   "oaep"   }, /* Correct spelling first */
61     { RSA_PKCS1_OAEP_PADDING,   "oeap"   },
62     { RSA_X931_PADDING,         "x931"   },
63     { RSA_PKCS1_PSS_PADDING,    "pss"    },
64     { 0,                        NULL     }
65 };
66
67 /*
68  * What's passed as an actual key is defined by the KEYMGMT interface.
69  * We happen to know that our KEYMGMT simply passes RSA structures, so
70  * we use that here too.
71  */
72
73 typedef struct {
74     OPENSSL_CTX *libctx;
75     RSA *rsa;
76
77     /*
78      * Flag to determine if the hash function can be changed (1) or not (0)
79      * Because it's dangerous to change during a DigestSign or DigestVerify
80      * operation, this flag is cleared by their Init function, and set again
81      * by their Final function.
82      */
83     unsigned int flag_allow_md : 1;
84
85     /* The Algorithm Identifier of the combined signature agorithm */
86     unsigned char aid[128];
87     size_t  aid_len;
88
89     /* main digest */
90     EVP_MD *md;
91     EVP_MD_CTX *mdctx;
92     int mdnid;
93     char mdname[OSSL_MAX_NAME_SIZE]; /* Purely informational */
94
95     /* RSA padding mode */
96     int pad_mode;
97     /* message digest for MGF1 */
98     EVP_MD *mgf1_md;
99     char mgf1_mdname[OSSL_MAX_NAME_SIZE]; /* Purely informational */
100     /* PSS salt length */
101     int saltlen;
102     /* Minimum salt length or -1 if no PSS parameter restriction */
103     int min_saltlen;
104
105     /* Temp buffer */
106     unsigned char *tbuf;
107
108 } PROV_RSA_CTX;
109
110 static size_t rsa_get_md_size(const PROV_RSA_CTX *prsactx)
111 {
112     if (prsactx->md != NULL)
113         return EVP_MD_size(prsactx->md);
114     return 0;
115 }
116
117 static int rsa_get_md_nid(const EVP_MD *md)
118 {
119     /*
120      * Because the RSA library deals with NIDs, we need to translate.
121      * We do so using EVP_MD_is_a(), and therefore need a name to NID
122      * map.
123      */
124     static const OSSL_ITEM name_to_nid[] = {
125         { NID_sha1,      OSSL_DIGEST_NAME_SHA1      },
126         { NID_sha224,    OSSL_DIGEST_NAME_SHA2_224  },
127         { NID_sha256,    OSSL_DIGEST_NAME_SHA2_256  },
128         { NID_sha384,    OSSL_DIGEST_NAME_SHA2_384  },
129         { NID_sha512,    OSSL_DIGEST_NAME_SHA2_512  },
130         { NID_md5,       OSSL_DIGEST_NAME_MD5       },
131         { NID_md5_sha1,  OSSL_DIGEST_NAME_MD5_SHA1  },
132         { NID_md2,       OSSL_DIGEST_NAME_MD2       },
133         { NID_md4,       OSSL_DIGEST_NAME_MD4       },
134         { NID_mdc2,      OSSL_DIGEST_NAME_MDC2      },
135         { NID_ripemd160, OSSL_DIGEST_NAME_RIPEMD160 },
136         { NID_sha3_224,  OSSL_DIGEST_NAME_SHA3_224  },
137         { NID_sha3_256,  OSSL_DIGEST_NAME_SHA3_256  },
138         { NID_sha3_384,  OSSL_DIGEST_NAME_SHA3_384  },
139         { NID_sha3_512,  OSSL_DIGEST_NAME_SHA3_512  },
140     };
141     size_t i;
142     int mdnid = NID_undef;
143
144     if (md == NULL)
145         goto end;
146
147     for (i = 0; i < OSSL_NELEM(name_to_nid); i++) {
148         if (EVP_MD_is_a(md, name_to_nid[i].ptr)) {
149             mdnid = (int)name_to_nid[i].id;
150             break;
151         }
152     }
153
154     if (mdnid == NID_undef)
155         ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_DIGEST);
156
157  end:
158     return mdnid;
159 }
160
161 static int rsa_check_padding(int mdnid, int padding)
162 {
163     if (padding == RSA_NO_PADDING) {
164         ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_PADDING_MODE);
165         return 0;
166     }
167
168     if (padding == RSA_X931_PADDING) {
169         if (RSA_X931_hash_id(mdnid) == -1) {
170             ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_X931_DIGEST);
171             return 0;
172         }
173     }
174
175     return 1;
176 }
177
178 static void *rsa_newctx(void *provctx)
179 {
180     PROV_RSA_CTX *prsactx = OPENSSL_zalloc(sizeof(PROV_RSA_CTX));
181
182     if (prsactx == NULL)
183         return NULL;
184
185     prsactx->libctx = PROV_LIBRARY_CONTEXT_OF(provctx);
186     prsactx->flag_allow_md = 1;
187     return prsactx;
188 }
189
190 /* True if PSS parameters are restricted */
191 #define rsa_pss_restricted(prsactx) (prsactx->min_saltlen != -1)
192
193 static int rsa_signature_init(void *vprsactx, void *vrsa)
194 {
195     PROV_RSA_CTX *prsactx = (PROV_RSA_CTX *)vprsactx;
196
197     if (prsactx == NULL || vrsa == NULL || !RSA_up_ref(vrsa))
198         return 0;
199
200     RSA_free(prsactx->rsa);
201     prsactx->rsa = vrsa;
202     if (RSA_get0_pss_params(prsactx->rsa) != NULL)
203         prsactx->pad_mode = RSA_PKCS1_PSS_PADDING;
204     else
205         prsactx->pad_mode = RSA_PKCS1_PADDING;
206     /* Maximum for sign, auto for verify */
207     prsactx->saltlen = RSA_PSS_SALTLEN_AUTO;
208     prsactx->min_saltlen = -1;
209
210     return 1;
211 }
212
213 static int rsa_setup_md(PROV_RSA_CTX *ctx, const char *mdname,
214                         const char *mdprops)
215 {
216     if (mdname != NULL) {
217         EVP_MD *md = EVP_MD_fetch(ctx->libctx, mdname, mdprops);
218         int md_nid = rsa_get_md_nid(md);
219         size_t algorithmidentifier_len = 0;
220         const unsigned char *algorithmidentifier = NULL;
221
222         if (md == NULL)
223             return 0;
224
225         if (!rsa_check_padding(md_nid, ctx->pad_mode)) {
226             EVP_MD_free(md);
227             return 0;
228         }
229
230         EVP_MD_CTX_free(ctx->mdctx);
231         EVP_MD_free(ctx->md);
232         ctx->md = NULL;
233         ctx->mdctx = NULL;
234         ctx->mdname[0] = '\0';
235         ctx->aid[0] = '\0';
236         ctx->aid_len = 0;
237
238         algorithmidentifier =
239             rsa_algorithmidentifier_encoding(md_nid, &algorithmidentifier_len);
240
241         ctx->md = md;
242         ctx->mdnid = md_nid;
243         OPENSSL_strlcpy(ctx->mdname, mdname, sizeof(ctx->mdname));
244         if (algorithmidentifier != NULL) {
245             memcpy(ctx->aid, algorithmidentifier, algorithmidentifier_len);
246             ctx->aid_len = algorithmidentifier_len;
247         }
248     }
249
250     return 1;
251 }
252
253 static int rsa_setup_mgf1_md(PROV_RSA_CTX *ctx, const char *mdname,
254                              const char *props)
255 {
256     if (ctx->mgf1_mdname[0] != '\0')
257         EVP_MD_free(ctx->mgf1_md);
258
259     if ((ctx->mgf1_md = EVP_MD_fetch(ctx->libctx, mdname, props)) == NULL)
260         return 0;
261     OPENSSL_strlcpy(ctx->mgf1_mdname, mdname, sizeof(ctx->mgf1_mdname));
262
263     return 1;
264 }
265
266 static int setup_tbuf(PROV_RSA_CTX *ctx)
267 {
268     if (ctx->tbuf != NULL)
269         return 1;
270     if ((ctx->tbuf = OPENSSL_malloc(RSA_size(ctx->rsa))) == NULL) {
271         ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
272         return 0;
273     }
274     return 1;
275 }
276
277 static void clean_tbuf(PROV_RSA_CTX *ctx)
278 {
279     if (ctx->tbuf != NULL)
280         OPENSSL_cleanse(ctx->tbuf, RSA_size(ctx->rsa));
281 }
282
283 static void free_tbuf(PROV_RSA_CTX *ctx)
284 {
285     OPENSSL_clear_free(ctx->tbuf, RSA_size(ctx->rsa));
286     ctx->tbuf = NULL;
287 }
288
289 static int rsa_sign(void *vprsactx, unsigned char *sig, size_t *siglen,
290                     size_t sigsize, const unsigned char *tbs, size_t tbslen)
291 {
292     PROV_RSA_CTX *prsactx = (PROV_RSA_CTX *)vprsactx;
293     int ret;
294     size_t rsasize = RSA_size(prsactx->rsa);
295     size_t mdsize = rsa_get_md_size(prsactx);
296
297     if (sig == NULL) {
298         *siglen = rsasize;
299         return 1;
300     }
301
302     if (sigsize < (size_t)rsasize)
303         return 0;
304
305     if (mdsize != 0) {
306         if (tbslen != mdsize) {
307             ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_DIGEST_LENGTH);
308             return 0;
309         }
310
311         if (EVP_MD_is_a(prsactx->md, OSSL_DIGEST_NAME_MDC2)) {
312             unsigned int sltmp;
313
314             if (prsactx->pad_mode != RSA_PKCS1_PADDING) {
315                 ERR_raise_data(ERR_LIB_PROV, PROV_R_INVALID_PADDING_MODE,
316                                "only PKCS#1 padding supported with MDC2");
317                 return 0;
318             }
319             ret = RSA_sign_ASN1_OCTET_STRING(0, tbs, tbslen, sig, &sltmp,
320                                              prsactx->rsa);
321
322             if (ret <= 0) {
323                 ERR_raise(ERR_LIB_PROV, ERR_LIB_RSA);
324                 return 0;
325             }
326             ret = sltmp;
327             goto end;
328         }
329
330         switch (prsactx->pad_mode) {
331         case RSA_X931_PADDING:
332             if ((size_t)RSA_size(prsactx->rsa) < tbslen + 1) {
333                 ERR_raise(ERR_LIB_PROV, PROV_R_KEY_SIZE_TOO_SMALL);
334                 return 0;
335             }
336             if (!setup_tbuf(prsactx)) {
337                 ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
338                 return 0;
339             }
340             memcpy(prsactx->tbuf, tbs, tbslen);
341             prsactx->tbuf[tbslen] = RSA_X931_hash_id(prsactx->mdnid);
342             ret = RSA_private_encrypt(tbslen + 1, prsactx->tbuf,
343                                       sig, prsactx->rsa, RSA_X931_PADDING);
344             clean_tbuf(prsactx);
345             break;
346
347         case RSA_PKCS1_PADDING:
348             {
349                 unsigned int sltmp;
350
351                 ret = RSA_sign(prsactx->mdnid, tbs, tbslen, sig, &sltmp,
352                                prsactx->rsa);
353                 if (ret <= 0) {
354                     ERR_raise(ERR_LIB_PROV, ERR_LIB_RSA);
355                     return 0;
356                 }
357                 ret = sltmp;
358             }
359             break;
360
361         case RSA_PKCS1_PSS_PADDING:
362             /* Check PSS restrictions */
363             if (rsa_pss_restricted(prsactx)) {
364                 switch (prsactx->saltlen) {
365                 case RSA_PSS_SALTLEN_DIGEST:
366                     if (prsactx->min_saltlen > EVP_MD_size(prsactx->md)) {
367                         ERR_raise(ERR_LIB_PROV, PROV_R_PSS_SALTLEN_TOO_SMALL);
368                         return 0;
369                     }
370                     /* FALLTHRU */
371                 default:
372                     if (prsactx->saltlen >= 0
373                         && prsactx->saltlen < prsactx->min_saltlen) {
374                         ERR_raise(ERR_LIB_PROV, PROV_R_PSS_SALTLEN_TOO_SMALL);
375                         return 0;
376                     }
377                     break;
378                 }
379             }
380             if (!setup_tbuf(prsactx))
381                 return 0;
382             if (!RSA_padding_add_PKCS1_PSS_mgf1(prsactx->rsa,
383                                                 prsactx->tbuf, tbs,
384                                                 prsactx->md, prsactx->mgf1_md,
385                                                 prsactx->saltlen)) {
386                 ERR_raise(ERR_LIB_PROV, ERR_LIB_RSA);
387                 return 0;
388             }
389             ret = RSA_private_encrypt(RSA_size(prsactx->rsa), prsactx->tbuf,
390                                       sig, prsactx->rsa, RSA_NO_PADDING);
391             clean_tbuf(prsactx);
392             break;
393
394         default:
395             ERR_raise_data(ERR_LIB_PROV, PROV_R_INVALID_PADDING_MODE,
396                            "Only X.931, PKCS#1 v1.5 or PSS padding allowed");
397             return 0;
398         }
399     } else {
400         ret = RSA_private_encrypt(tbslen, tbs, sig, prsactx->rsa,
401                                   prsactx->pad_mode);
402     }
403
404 #ifdef LEGACY_MODE
405  end:
406 #endif
407     if (ret <= 0) {
408         ERR_raise(ERR_LIB_PROV, ERR_LIB_RSA);
409         return 0;
410     }
411
412     *siglen = ret;
413     return 1;
414 }
415
416 static int rsa_verify_recover(void *vprsactx,
417                               unsigned char *rout,
418                               size_t *routlen,
419                               size_t routsize,
420                               const unsigned char *sig,
421                               size_t siglen)
422 {
423     PROV_RSA_CTX *prsactx = (PROV_RSA_CTX *)vprsactx;
424     int ret;
425
426     if (rout == NULL) {
427         *routlen = RSA_size(prsactx->rsa);
428         return 1;
429     }
430
431     if (prsactx->md != NULL) {
432         switch (prsactx->pad_mode) {
433         case RSA_X931_PADDING:
434             if (!setup_tbuf(prsactx))
435                 return 0;
436             ret = RSA_public_decrypt(siglen, sig, prsactx->tbuf, prsactx->rsa,
437                                      RSA_X931_PADDING);
438             if (ret < 1) {
439                 ERR_raise(ERR_LIB_PROV, ERR_LIB_RSA);
440                 return 0;
441             }
442             ret--;
443             if (prsactx->tbuf[ret] != RSA_X931_hash_id(prsactx->mdnid)) {
444                 ERR_raise(ERR_LIB_PROV, PROV_R_ALGORITHM_MISMATCH);
445                 return 0;
446             }
447             if (ret != EVP_MD_size(prsactx->md)) {
448                 ERR_raise_data(ERR_LIB_PROV, PROV_R_INVALID_DIGEST_LENGTH,
449                                "Should be %d, but got %d",
450                                EVP_MD_size(prsactx->md), ret);
451                 return 0;
452             }
453
454             *routlen = ret;
455             if (routsize < (size_t)ret) {
456                 ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
457                 return 0;
458             }
459             memcpy(rout, prsactx->tbuf, ret);
460             break;
461
462         case RSA_PKCS1_PADDING:
463             {
464                 size_t sltmp;
465
466                 ret = int_rsa_verify(prsactx->mdnid, NULL, 0, rout, &sltmp,
467                                      sig, siglen, prsactx->rsa);
468                 if (ret <= 0) {
469                     ERR_raise(ERR_LIB_PROV, ERR_LIB_RSA);
470                     return 0;
471                 }
472                 ret = sltmp;
473             }
474             break;
475
476         default:
477             ERR_raise_data(ERR_LIB_PROV, PROV_R_INVALID_PADDING_MODE,
478                            "Only X.931 or PKCS#1 v1.5 padding allowed");
479             return 0;
480         }
481     } else {
482         ret = RSA_public_decrypt(siglen, sig, rout, prsactx->rsa,
483                                  prsactx->pad_mode);
484         if (ret < 0) {
485             ERR_raise(ERR_LIB_PROV, ERR_LIB_RSA);
486             return 0;
487         }
488     }
489     *routlen = ret;
490     return 1;
491 }
492
493 static int rsa_verify(void *vprsactx, const unsigned char *sig, size_t siglen,
494                       const unsigned char *tbs, size_t tbslen)
495 {
496     PROV_RSA_CTX *prsactx = (PROV_RSA_CTX *)vprsactx;
497     size_t rslen;
498
499     if (prsactx->md != NULL) {
500         switch (prsactx->pad_mode) {
501         case RSA_PKCS1_PADDING:
502             if (!RSA_verify(prsactx->mdnid, tbs, tbslen, sig, siglen,
503                             prsactx->rsa)) {
504                 ERR_raise(ERR_LIB_PROV, ERR_LIB_RSA);
505                 return 0;
506             }
507             return 1;
508         case RSA_X931_PADDING:
509             if (rsa_verify_recover(prsactx, NULL, &rslen, 0, sig, siglen) <= 0)
510                 return 0;
511             break;
512         case RSA_PKCS1_PSS_PADDING:
513             {
514                 int ret;
515                 size_t mdsize;
516
517                 /* Check PSS restrictions */
518                 if (rsa_pss_restricted(prsactx)) {
519                     switch (prsactx->saltlen) {
520                     case RSA_PSS_SALTLEN_AUTO:
521                         ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_PSS_SALTLEN);
522                         return 0;
523                     case RSA_PSS_SALTLEN_DIGEST:
524                         if (prsactx->min_saltlen > EVP_MD_size(prsactx->md)) {
525                             ERR_raise(ERR_LIB_PROV,
526                                       PROV_R_PSS_SALTLEN_TOO_SMALL);
527                             return 0;
528                         }
529                         /* FALLTHRU */
530                     default:
531                         if (prsactx->saltlen >= 0
532                             && prsactx->saltlen < prsactx->min_saltlen) {
533                             ERR_raise(ERR_LIB_PROV, PROV_R_PSS_SALTLEN_TOO_SMALL);
534                             return 0;
535                         }
536                         break;
537                     }
538                 }
539
540                 /*
541                  * We need to check this for the RSA_verify_PKCS1_PSS_mgf1()
542                  * call
543                  */
544                 mdsize = rsa_get_md_size(prsactx);
545                 if (tbslen != mdsize) {
546                     ERR_raise_data(ERR_LIB_PROV, PROV_R_INVALID_DIGEST_LENGTH,
547                                    "Should be %d, but got %d",
548                                    mdsize, tbslen);
549                     return 0;
550                 }
551
552                 if (!setup_tbuf(prsactx))
553                     return 0;
554                 ret = RSA_public_decrypt(siglen, sig, prsactx->tbuf,
555                                          prsactx->rsa, RSA_NO_PADDING);
556                 if (ret <= 0) {
557                     ERR_raise(ERR_LIB_PROV, ERR_LIB_RSA);
558                     return 0;
559                 }
560                 ret = RSA_verify_PKCS1_PSS_mgf1(prsactx->rsa, tbs,
561                                                 prsactx->md, prsactx->mgf1_md,
562                                                 prsactx->tbuf,
563                                                 prsactx->saltlen);
564                 if (ret <= 0) {
565                     ERR_raise(ERR_LIB_PROV, ERR_LIB_RSA);
566                     return 0;
567                 }
568                 return 1;
569             }
570         default:
571             ERR_raise_data(ERR_LIB_PROV, PROV_R_INVALID_PADDING_MODE,
572                            "Only X.931, PKCS#1 v1.5 or PSS padding allowed");
573             return 0;
574         }
575     } else {
576         if (!setup_tbuf(prsactx))
577             return 0;
578         rslen = RSA_public_decrypt(siglen, sig, prsactx->tbuf, prsactx->rsa,
579                                    prsactx->pad_mode);
580         if (rslen == 0) {
581             ERR_raise(ERR_LIB_PROV, ERR_LIB_RSA);
582             return 0;
583         }
584     }
585
586     if ((rslen != tbslen) || memcmp(tbs, prsactx->tbuf, rslen))
587         return 0;
588
589     return 1;
590 }
591
592 static int rsa_digest_signverify_init(void *vprsactx, const char *mdname,
593                                       const char *props, void *vrsa)
594 {
595     PROV_RSA_CTX *prsactx = (PROV_RSA_CTX *)vprsactx;
596
597     prsactx->flag_allow_md = 0;
598     if (!rsa_signature_init(vprsactx, vrsa)
599         || !rsa_setup_md(prsactx, mdname, props))
600         return 0;
601
602     prsactx->mdctx = EVP_MD_CTX_new();
603     if (prsactx->mdctx == NULL)
604         goto error;
605
606     if (!EVP_DigestInit_ex(prsactx->mdctx, prsactx->md, NULL))
607         goto error;
608
609     return 1;
610
611  error:
612     EVP_MD_CTX_free(prsactx->mdctx);
613     EVP_MD_free(prsactx->md);
614     prsactx->mdctx = NULL;
615     prsactx->md = NULL;
616     return 0;
617 }
618
619 int rsa_digest_signverify_update(void *vprsactx, const unsigned char *data,
620                                  size_t datalen)
621 {
622     PROV_RSA_CTX *prsactx = (PROV_RSA_CTX *)vprsactx;
623
624     if (prsactx == NULL || prsactx->mdctx == NULL)
625         return 0;
626
627     return EVP_DigestUpdate(prsactx->mdctx, data, datalen);
628 }
629
630 int rsa_digest_sign_final(void *vprsactx, unsigned char *sig, size_t *siglen,
631                           size_t sigsize)
632 {
633     PROV_RSA_CTX *prsactx = (PROV_RSA_CTX *)vprsactx;
634     unsigned char digest[EVP_MAX_MD_SIZE];
635     unsigned int dlen = 0;
636
637     prsactx->flag_allow_md = 1;
638     if (prsactx == NULL || prsactx->mdctx == NULL)
639         return 0;
640
641     /*
642      * If sig is NULL then we're just finding out the sig size. Other fields
643      * are ignored. Defer to rsa_sign.
644      */
645     if (sig != NULL) {
646         /*
647          * TODO(3.0): There is the possibility that some externally provided
648          * digests exceed EVP_MAX_MD_SIZE. We should probably handle that somehow -
649          * but that problem is much larger than just in RSA.
650          */
651         if (!EVP_DigestFinal_ex(prsactx->mdctx, digest, &dlen))
652             return 0;
653     }
654
655     return rsa_sign(vprsactx, sig, siglen, sigsize, digest, (size_t)dlen);
656 }
657
658
659 int rsa_digest_verify_final(void *vprsactx, const unsigned char *sig,
660                             size_t siglen)
661 {
662     PROV_RSA_CTX *prsactx = (PROV_RSA_CTX *)vprsactx;
663     unsigned char digest[EVP_MAX_MD_SIZE];
664     unsigned int dlen = 0;
665
666     prsactx->flag_allow_md = 1;
667     if (prsactx == NULL || prsactx->mdctx == NULL)
668         return 0;
669
670     /*
671      * TODO(3.0): There is the possibility that some externally provided
672      * digests exceed EVP_MAX_MD_SIZE. We should probably handle that somehow -
673      * but that problem is much larger than just in RSA.
674      */
675     if (!EVP_DigestFinal_ex(prsactx->mdctx, digest, &dlen))
676         return 0;
677
678     return rsa_verify(vprsactx, sig, siglen, digest, (size_t)dlen);
679 }
680
681 static void rsa_freectx(void *vprsactx)
682 {
683     PROV_RSA_CTX *prsactx = (PROV_RSA_CTX *)vprsactx;
684
685     if (prsactx == NULL)
686         return;
687
688     RSA_free(prsactx->rsa);
689     EVP_MD_CTX_free(prsactx->mdctx);
690     EVP_MD_free(prsactx->md);
691     EVP_MD_free(prsactx->mgf1_md);
692     free_tbuf(prsactx);
693
694     OPENSSL_clear_free(prsactx, sizeof(prsactx));
695 }
696
697 static void *rsa_dupctx(void *vprsactx)
698 {
699     PROV_RSA_CTX *srcctx = (PROV_RSA_CTX *)vprsactx;
700     PROV_RSA_CTX *dstctx;
701
702     dstctx = OPENSSL_zalloc(sizeof(*srcctx));
703     if (dstctx == NULL)
704         return NULL;
705
706     *dstctx = *srcctx;
707     dstctx->rsa = NULL;
708     dstctx->md = NULL;
709     dstctx->mdctx = NULL;
710     dstctx->tbuf = NULL;
711
712     if (srcctx->rsa != NULL && !RSA_up_ref(srcctx->rsa))
713         goto err;
714     dstctx->rsa = srcctx->rsa;
715
716     if (srcctx->md != NULL && !EVP_MD_up_ref(srcctx->md))
717         goto err;
718     dstctx->md = srcctx->md;
719
720     if (srcctx->mgf1_md != NULL && !EVP_MD_up_ref(srcctx->mgf1_md))
721         goto err;
722     dstctx->mgf1_md = srcctx->mgf1_md;
723
724     if (srcctx->mdctx != NULL) {
725         dstctx->mdctx = EVP_MD_CTX_new();
726         if (dstctx->mdctx == NULL
727                 || !EVP_MD_CTX_copy_ex(dstctx->mdctx, srcctx->mdctx))
728             goto err;
729     }
730
731     return dstctx;
732  err:
733     rsa_freectx(dstctx);
734     return NULL;
735 }
736
737 static int rsa_get_ctx_params(void *vprsactx, OSSL_PARAM *params)
738 {
739     PROV_RSA_CTX *prsactx = (PROV_RSA_CTX *)vprsactx;
740     OSSL_PARAM *p;
741
742     if (prsactx == NULL || params == NULL)
743         return 0;
744
745     p = OSSL_PARAM_locate(params, OSSL_SIGNATURE_PARAM_ALGORITHM_ID);
746     if (p != NULL
747         && !OSSL_PARAM_set_octet_string(p, prsactx->aid, prsactx->aid_len))
748         return 0;
749
750     p = OSSL_PARAM_locate(params, OSSL_SIGNATURE_PARAM_PAD_MODE);
751     if (p != NULL)
752         switch (p->data_type) {
753         case OSSL_PARAM_INTEGER:
754             if (!OSSL_PARAM_set_int(p, prsactx->pad_mode))
755                 return 0;
756             break;
757         case OSSL_PARAM_UTF8_STRING:
758             {
759                 int i;
760                 const char *word = NULL;
761
762                 for (i = 0; padding_item[i].id != 0; i++) {
763                     if (prsactx->pad_mode == (int)padding_item[i].id) {
764                         word = padding_item[i].ptr;
765                         break;
766                     }
767                 }
768
769                 if (word != NULL) {
770                     if (!OSSL_PARAM_set_utf8_string(p, word))
771                         return 0;
772                 } else {
773                     ERR_raise(ERR_LIB_PROV, ERR_R_INTERNAL_ERROR);
774                 }
775             }
776             break;
777         default:
778             return 0;
779         }
780
781     p = OSSL_PARAM_locate(params, OSSL_SIGNATURE_PARAM_DIGEST);
782     if (p != NULL && !OSSL_PARAM_set_utf8_string(p, prsactx->mdname))
783         return 0;
784
785     p = OSSL_PARAM_locate(params, OSSL_SIGNATURE_PARAM_MGF1_DIGEST);
786     if (p != NULL && !OSSL_PARAM_set_utf8_string(p, prsactx->mgf1_mdname))
787         return 0;
788
789     p = OSSL_PARAM_locate(params, OSSL_SIGNATURE_PARAM_PSS_SALTLEN);
790     if (p != NULL) {
791         if (p->data_type == OSSL_PARAM_INTEGER) {
792             if (!OSSL_PARAM_set_int(p, prsactx->saltlen))
793                 return 0;
794         } else if (p->data_type == OSSL_PARAM_UTF8_STRING) {
795             switch (prsactx->saltlen) {
796             case RSA_PSS_SALTLEN_DIGEST:
797                 if (!OSSL_PARAM_set_utf8_string(p, "digest"))
798                     return 0;
799                 break;
800             case RSA_PSS_SALTLEN_MAX:
801                 if (!OSSL_PARAM_set_utf8_string(p, "max"))
802                     return 0;
803                 break;
804             case RSA_PSS_SALTLEN_AUTO:
805                 if (!OSSL_PARAM_set_utf8_string(p, "auto"))
806                     return 0;
807                 break;
808             default:
809                 if (BIO_snprintf(p->data, p->data_size, "%d", prsactx->saltlen)
810                     <= 0)
811                     return 0;
812                 break;
813             }
814         }
815     }
816
817     return 1;
818 }
819
820 static const OSSL_PARAM known_gettable_ctx_params[] = {
821     OSSL_PARAM_octet_string(OSSL_SIGNATURE_PARAM_ALGORITHM_ID, NULL, 0),
822     OSSL_PARAM_utf8_string(OSSL_SIGNATURE_PARAM_PAD_MODE, NULL, 0),
823     OSSL_PARAM_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST, NULL, 0),
824     OSSL_PARAM_utf8_string(OSSL_SIGNATURE_PARAM_MGF1_DIGEST, NULL, 0),
825     OSSL_PARAM_utf8_string(OSSL_SIGNATURE_PARAM_PSS_SALTLEN, NULL, 0),
826     OSSL_PARAM_END
827 };
828
829 static const OSSL_PARAM *rsa_gettable_ctx_params(void)
830 {
831     return known_gettable_ctx_params;
832 }
833
834 static int rsa_set_ctx_params(void *vprsactx, const OSSL_PARAM params[])
835 {
836     PROV_RSA_CTX *prsactx = (PROV_RSA_CTX *)vprsactx;
837     const OSSL_PARAM *p;
838
839     if (prsactx == NULL || params == NULL)
840         return 0;
841
842     p = OSSL_PARAM_locate_const(params, OSSL_SIGNATURE_PARAM_DIGEST);
843     /* Not allowed during certain operations */
844     if (p != NULL && !prsactx->flag_allow_md)
845         return 0;
846     if (p != NULL) {
847         char mdname[OSSL_MAX_NAME_SIZE] = "", *pmdname = mdname;
848         char mdprops[OSSL_MAX_PROPQUERY_SIZE] = "", *pmdprops = mdprops;
849         const OSSL_PARAM *propsp =
850             OSSL_PARAM_locate_const(params,
851                                     OSSL_SIGNATURE_PARAM_PROPERTIES);
852
853         if (!OSSL_PARAM_get_utf8_string(p, &pmdname, sizeof(mdname)))
854             return 0;
855         if (propsp != NULL
856             && !OSSL_PARAM_get_utf8_string(propsp, &pmdprops, sizeof(mdprops)))
857             return 0;
858
859         /* TODO(3.0) PSS check needs more work */
860         if (rsa_pss_restricted(prsactx)) {
861             /* TODO(3.0) figure out what to do for prsactx->md == NULL */
862             if (prsactx->md == NULL || EVP_MD_is_a(prsactx->md, mdname))
863                 return 1;
864             ERR_raise(ERR_LIB_PROV, PROV_R_DIGEST_NOT_ALLOWED);
865             return 0;
866         }
867
868         /* non-PSS code follows */
869         if (!rsa_setup_md(prsactx, mdname, mdprops))
870             return 0;
871     }
872
873     p = OSSL_PARAM_locate_const(params, OSSL_SIGNATURE_PARAM_PAD_MODE);
874     if (p != NULL) {
875         int pad_mode = 0;
876
877         switch (p->data_type) {
878         case OSSL_PARAM_INTEGER: /* Support for legacy pad mode number */
879             if (!OSSL_PARAM_get_int(p, &pad_mode))
880                 return 0;
881             break;
882         case OSSL_PARAM_UTF8_STRING:
883             {
884                 int i;
885
886                 if (p->data == NULL)
887                     return 0;
888
889                 for (i = 0; padding_item[i].id != 0; i++) {
890                     if (strcmp(p->data, padding_item[i].ptr) == 0) {
891                         pad_mode = padding_item[i].id;
892                         break;
893                     }
894                 }
895             }
896             break;
897         default:
898             return 0;
899         }
900
901         switch (pad_mode) {
902         case RSA_PKCS1_OAEP_PADDING:
903             /*
904              * OAEP padding is for asymmetric cipher only so is not compatible
905              * with signature use.
906              */
907             ERR_raise_data(ERR_LIB_PROV,
908                            PROV_R_ILLEGAL_OR_UNSUPPORTED_PADDING_MODE,
909                            "OAEP padding not allowed for signing / verifying");
910             return 0;
911         case RSA_PKCS1_PSS_PADDING:
912             if (prsactx->mdname[0] == '\0')
913                 rsa_setup_md(prsactx, "SHA1", "");
914             goto cont;
915         case RSA_PKCS1_PADDING:
916         case RSA_SSLV23_PADDING:
917         case RSA_NO_PADDING:
918         case RSA_X931_PADDING:
919             if (RSA_get0_pss_params(prsactx->rsa) != NULL) {
920                 ERR_raise_data(ERR_LIB_PROV,
921                                PROV_R_ILLEGAL_OR_UNSUPPORTED_PADDING_MODE,
922                                "X.931 padding not allowed with RSA-PSS");
923                 return 0;
924             }
925         cont:
926             if (!rsa_check_padding(prsactx->mdnid, pad_mode))
927                 return 0;
928             break;
929         default:
930             return 0;
931         }
932         prsactx->pad_mode = pad_mode;
933     }
934
935     p = OSSL_PARAM_locate_const(params, OSSL_SIGNATURE_PARAM_PSS_SALTLEN);
936     if (p != NULL) {
937         int saltlen;
938
939         if (prsactx->pad_mode != RSA_PKCS1_PSS_PADDING) {
940             ERR_raise_data(ERR_LIB_PROV, PROV_R_NOT_SUPPORTED,
941                            "PSS saltlen can only be specified if "
942                            "PSS padding has been specified first");
943             return 0;
944         }
945
946         switch (p->data_type) {
947         case OSSL_PARAM_INTEGER: /* Support for legacy pad mode number */
948             if (!OSSL_PARAM_get_int(p, &saltlen))
949                 return 0;
950             break;
951         case OSSL_PARAM_UTF8_STRING:
952             if (strcmp(p->data, "digest") == 0)
953                 saltlen = RSA_PSS_SALTLEN_DIGEST;
954             else if (strcmp(p->data, "max") == 0)
955                 saltlen = RSA_PSS_SALTLEN_MAX;
956             else if (strcmp(p->data, "auto") == 0)
957                 saltlen = RSA_PSS_SALTLEN_AUTO;
958             else
959                 saltlen = atoi(p->data);
960             break;
961         default:
962             return 0;
963         }
964
965         /*
966          * RSA_PSS_SALTLEN_MAX seems curiously named in this check.
967          * Contrary to what it's name suggests, it's the currently
968          * lowest saltlen number possible.
969          */
970         if (saltlen < RSA_PSS_SALTLEN_MAX) {
971             ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_PSS_SALTLEN);
972             return 0;
973         }
974
975         prsactx->saltlen = saltlen;
976     }
977
978     p = OSSL_PARAM_locate_const(params, OSSL_SIGNATURE_PARAM_MGF1_DIGEST);
979     if (p != NULL) {
980         char mdname[OSSL_MAX_NAME_SIZE] = "", *pmdname = mdname;
981         char mdprops[OSSL_MAX_PROPQUERY_SIZE] = "", *pmdprops = mdprops;
982         const OSSL_PARAM *propsp =
983             OSSL_PARAM_locate_const(params,
984                                     OSSL_SIGNATURE_PARAM_MGF1_PROPERTIES);
985
986         if (!OSSL_PARAM_get_utf8_string(p, &pmdname, sizeof(mdname)))
987             return 0;
988         if (propsp != NULL
989             && !OSSL_PARAM_get_utf8_string(propsp, &pmdprops, sizeof(mdprops)))
990             return 0;
991
992         if (prsactx->pad_mode != RSA_PKCS1_PSS_PADDING) {
993             ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_MGF1_MD);
994             return  0;
995         }
996
997         /* TODO(3.0) PSS check needs more work */
998         if (rsa_pss_restricted(prsactx)) {
999             /* TODO(3.0) figure out what to do for prsactx->md == NULL */
1000             if (prsactx->mgf1_md == NULL
1001                 || EVP_MD_is_a(prsactx->mgf1_md, mdname))
1002                 return 1;
1003             ERR_raise(ERR_LIB_PROV, PROV_R_DIGEST_NOT_ALLOWED);
1004             return 0;
1005         }
1006
1007         /* non-PSS code follows */
1008         if (!rsa_setup_mgf1_md(prsactx, mdname, mdprops))
1009             return 0;
1010     }
1011
1012     return 1;
1013 }
1014
1015 static const OSSL_PARAM known_settable_ctx_params[] = {
1016     OSSL_PARAM_utf8_string(OSSL_SIGNATURE_PARAM_PAD_MODE, NULL, 0),
1017     OSSL_PARAM_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST, NULL, 0),
1018     OSSL_PARAM_utf8_string(OSSL_SIGNATURE_PARAM_PROPERTIES, NULL, 0),
1019     OSSL_PARAM_utf8_string(OSSL_SIGNATURE_PARAM_MGF1_DIGEST, NULL, 0),
1020     OSSL_PARAM_utf8_string(OSSL_SIGNATURE_PARAM_MGF1_PROPERTIES, NULL, 0),
1021     OSSL_PARAM_utf8_string(OSSL_SIGNATURE_PARAM_PSS_SALTLEN, NULL, 0),
1022     OSSL_PARAM_END
1023 };
1024
1025 static const OSSL_PARAM *rsa_settable_ctx_params(void)
1026 {
1027     /*
1028      * TODO(3.0): Should this function return a different set of settable ctx
1029      * params if the ctx is being used for a DigestSign/DigestVerify? In that
1030      * case it is not allowed to set the digest size/digest name because the
1031      * digest is explicitly set as part of the init.
1032      */
1033     return known_settable_ctx_params;
1034 }
1035
1036 static int rsa_get_ctx_md_params(void *vprsactx, OSSL_PARAM *params)
1037 {
1038     PROV_RSA_CTX *prsactx = (PROV_RSA_CTX *)vprsactx;
1039
1040     if (prsactx->mdctx == NULL)
1041         return 0;
1042
1043     return EVP_MD_CTX_get_params(prsactx->mdctx, params);
1044 }
1045
1046 static const OSSL_PARAM *rsa_gettable_ctx_md_params(void *vprsactx)
1047 {
1048     PROV_RSA_CTX *prsactx = (PROV_RSA_CTX *)vprsactx;
1049
1050     if (prsactx->md == NULL)
1051         return 0;
1052
1053     return EVP_MD_gettable_ctx_params(prsactx->md);
1054 }
1055
1056 static int rsa_set_ctx_md_params(void *vprsactx, const OSSL_PARAM params[])
1057 {
1058     PROV_RSA_CTX *prsactx = (PROV_RSA_CTX *)vprsactx;
1059
1060     if (prsactx->mdctx == NULL)
1061         return 0;
1062
1063     return EVP_MD_CTX_set_params(prsactx->mdctx, params);
1064 }
1065
1066 static const OSSL_PARAM *rsa_settable_ctx_md_params(void *vprsactx)
1067 {
1068     PROV_RSA_CTX *prsactx = (PROV_RSA_CTX *)vprsactx;
1069
1070     if (prsactx->md == NULL)
1071         return 0;
1072
1073     return EVP_MD_settable_ctx_params(prsactx->md);
1074 }
1075
1076 const OSSL_DISPATCH rsa_signature_functions[] = {
1077     { OSSL_FUNC_SIGNATURE_NEWCTX, (void (*)(void))rsa_newctx },
1078     { OSSL_FUNC_SIGNATURE_SIGN_INIT, (void (*)(void))rsa_signature_init },
1079     { OSSL_FUNC_SIGNATURE_SIGN, (void (*)(void))rsa_sign },
1080     { OSSL_FUNC_SIGNATURE_VERIFY_INIT, (void (*)(void))rsa_signature_init },
1081     { OSSL_FUNC_SIGNATURE_VERIFY, (void (*)(void))rsa_verify },
1082     { OSSL_FUNC_SIGNATURE_VERIFY_RECOVER_INIT, (void (*)(void))rsa_signature_init },
1083     { OSSL_FUNC_SIGNATURE_VERIFY_RECOVER, (void (*)(void))rsa_verify_recover },
1084     { OSSL_FUNC_SIGNATURE_DIGEST_SIGN_INIT,
1085       (void (*)(void))rsa_digest_signverify_init },
1086     { OSSL_FUNC_SIGNATURE_DIGEST_SIGN_UPDATE,
1087       (void (*)(void))rsa_digest_signverify_update },
1088     { OSSL_FUNC_SIGNATURE_DIGEST_SIGN_FINAL,
1089       (void (*)(void))rsa_digest_sign_final },
1090     { OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_INIT,
1091       (void (*)(void))rsa_digest_signverify_init },
1092     { OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_UPDATE,
1093       (void (*)(void))rsa_digest_signverify_update },
1094     { OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_FINAL,
1095       (void (*)(void))rsa_digest_verify_final },
1096     { OSSL_FUNC_SIGNATURE_FREECTX, (void (*)(void))rsa_freectx },
1097     { OSSL_FUNC_SIGNATURE_DUPCTX, (void (*)(void))rsa_dupctx },
1098     { OSSL_FUNC_SIGNATURE_GET_CTX_PARAMS, (void (*)(void))rsa_get_ctx_params },
1099     { OSSL_FUNC_SIGNATURE_GETTABLE_CTX_PARAMS,
1100       (void (*)(void))rsa_gettable_ctx_params },
1101     { OSSL_FUNC_SIGNATURE_SET_CTX_PARAMS, (void (*)(void))rsa_set_ctx_params },
1102     { OSSL_FUNC_SIGNATURE_SETTABLE_CTX_PARAMS,
1103       (void (*)(void))rsa_settable_ctx_params },
1104     { OSSL_FUNC_SIGNATURE_GET_CTX_MD_PARAMS,
1105       (void (*)(void))rsa_get_ctx_md_params },
1106     { OSSL_FUNC_SIGNATURE_GETTABLE_CTX_MD_PARAMS,
1107       (void (*)(void))rsa_gettable_ctx_md_params },
1108     { OSSL_FUNC_SIGNATURE_SET_CTX_MD_PARAMS,
1109       (void (*)(void))rsa_set_ctx_md_params },
1110     { OSSL_FUNC_SIGNATURE_SETTABLE_CTX_MD_PARAMS,
1111       (void (*)(void))rsa_settable_ctx_md_params },
1112     { 0, NULL }
1113 };