Typo: should check mgf1md
[oweals/openssl.git] / crypto / rsa / rsa_pmeth.c
1 /*
2  * Copyright 2006-2016 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the OpenSSL license (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 #include <stdio.h>
11 #include "internal/cryptlib.h"
12 #include <openssl/asn1t.h>
13 #include <openssl/x509.h>
14 #include <openssl/rsa.h>
15 #include <openssl/bn.h>
16 #include <openssl/evp.h>
17 #include <openssl/x509v3.h>
18 #include <openssl/cms.h>
19 #include "internal/evp_int.h"
20 #include "rsa_locl.h"
21
22 /* RSA pkey context structure */
23
24 typedef struct {
25     /* Key gen parameters */
26     int nbits;
27     BIGNUM *pub_exp;
28     /* Keygen callback info */
29     int gentmp[2];
30     /* RSA padding mode */
31     int pad_mode;
32     /* message digest */
33     const EVP_MD *md;
34     /* message digest for MGF1 */
35     const EVP_MD *mgf1md;
36     /* PSS salt length */
37     int saltlen;
38     /* Minimum salt length or -1 if no PSS parameter restriction */
39     int min_saltlen;
40     /* Temp buffer */
41     unsigned char *tbuf;
42     /* OAEP label */
43     unsigned char *oaep_label;
44     size_t oaep_labellen;
45 } RSA_PKEY_CTX;
46
47 /* True if PSS parameters are restricted */
48 #define rsa_pss_restricted(rctx) (rctx->min_saltlen != -1)
49
50 static int pkey_rsa_init(EVP_PKEY_CTX *ctx)
51 {
52     RSA_PKEY_CTX *rctx = OPENSSL_zalloc(sizeof(*rctx));
53
54     if (rctx == NULL)
55         return 0;
56     rctx->nbits = 1024;
57     if (pkey_ctx_is_pss(ctx))
58         rctx->pad_mode = RSA_PKCS1_PSS_PADDING;
59     else
60         rctx->pad_mode = RSA_PKCS1_PADDING;
61     /* Maximum for sign, auto for verify */
62     rctx->saltlen = RSA_PSS_SALTLEN_AUTO;
63     rctx->min_saltlen = -1;
64     ctx->data = rctx;
65     ctx->keygen_info = rctx->gentmp;
66     ctx->keygen_info_count = 2;
67
68     return 1;
69 }
70
71 static int pkey_rsa_copy(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src)
72 {
73     RSA_PKEY_CTX *dctx, *sctx;
74
75     if (!pkey_rsa_init(dst))
76         return 0;
77     sctx = src->data;
78     dctx = dst->data;
79     dctx->nbits = sctx->nbits;
80     if (sctx->pub_exp) {
81         dctx->pub_exp = BN_dup(sctx->pub_exp);
82         if (!dctx->pub_exp)
83             return 0;
84     }
85     dctx->pad_mode = sctx->pad_mode;
86     dctx->md = sctx->md;
87     dctx->mgf1md = sctx->mgf1md;
88     if (sctx->oaep_label) {
89         OPENSSL_free(dctx->oaep_label);
90         dctx->oaep_label = OPENSSL_memdup(sctx->oaep_label, sctx->oaep_labellen);
91         if (!dctx->oaep_label)
92             return 0;
93         dctx->oaep_labellen = sctx->oaep_labellen;
94     }
95     return 1;
96 }
97
98 static int setup_tbuf(RSA_PKEY_CTX *ctx, EVP_PKEY_CTX *pk)
99 {
100     if (ctx->tbuf != NULL)
101         return 1;
102     ctx->tbuf = OPENSSL_malloc(EVP_PKEY_size(pk->pkey));
103     if (ctx->tbuf == NULL)
104         return 0;
105     return 1;
106 }
107
108 static void pkey_rsa_cleanup(EVP_PKEY_CTX *ctx)
109 {
110     RSA_PKEY_CTX *rctx = ctx->data;
111     if (rctx) {
112         BN_free(rctx->pub_exp);
113         OPENSSL_free(rctx->tbuf);
114         OPENSSL_free(rctx->oaep_label);
115         OPENSSL_free(rctx);
116     }
117 }
118
119 static int pkey_rsa_sign(EVP_PKEY_CTX *ctx, unsigned char *sig,
120                          size_t *siglen, const unsigned char *tbs,
121                          size_t tbslen)
122 {
123     int ret;
124     RSA_PKEY_CTX *rctx = ctx->data;
125     RSA *rsa = ctx->pkey->pkey.rsa;
126
127     if (rctx->md) {
128         if (tbslen != (size_t)EVP_MD_size(rctx->md)) {
129             RSAerr(RSA_F_PKEY_RSA_SIGN, RSA_R_INVALID_DIGEST_LENGTH);
130             return -1;
131         }
132
133         if (EVP_MD_type(rctx->md) == NID_mdc2) {
134             unsigned int sltmp;
135             if (rctx->pad_mode != RSA_PKCS1_PADDING)
136                 return -1;
137             ret = RSA_sign_ASN1_OCTET_STRING(0,
138                                              tbs, tbslen, sig, &sltmp, rsa);
139
140             if (ret <= 0)
141                 return ret;
142             ret = sltmp;
143         } else if (rctx->pad_mode == RSA_X931_PADDING) {
144             if ((size_t)EVP_PKEY_size(ctx->pkey) < tbslen + 1) {
145                 RSAerr(RSA_F_PKEY_RSA_SIGN, RSA_R_KEY_SIZE_TOO_SMALL);
146                 return -1;
147             }
148             if (!setup_tbuf(rctx, ctx)) {
149                 RSAerr(RSA_F_PKEY_RSA_SIGN, ERR_R_MALLOC_FAILURE);
150                 return -1;
151             }
152             memcpy(rctx->tbuf, tbs, tbslen);
153             rctx->tbuf[tbslen] = RSA_X931_hash_id(EVP_MD_type(rctx->md));
154             ret = RSA_private_encrypt(tbslen + 1, rctx->tbuf,
155                                       sig, rsa, RSA_X931_PADDING);
156         } else if (rctx->pad_mode == RSA_PKCS1_PADDING) {
157             unsigned int sltmp;
158             ret = RSA_sign(EVP_MD_type(rctx->md),
159                            tbs, tbslen, sig, &sltmp, rsa);
160             if (ret <= 0)
161                 return ret;
162             ret = sltmp;
163         } else if (rctx->pad_mode == RSA_PKCS1_PSS_PADDING) {
164             if (!setup_tbuf(rctx, ctx))
165                 return -1;
166             if (!RSA_padding_add_PKCS1_PSS_mgf1(rsa,
167                                                 rctx->tbuf, tbs,
168                                                 rctx->md, rctx->mgf1md,
169                                                 rctx->saltlen))
170                 return -1;
171             ret = RSA_private_encrypt(RSA_size(rsa), rctx->tbuf,
172                                       sig, rsa, RSA_NO_PADDING);
173         } else
174             return -1;
175     } else
176         ret = RSA_private_encrypt(tbslen, tbs, sig, ctx->pkey->pkey.rsa,
177                                   rctx->pad_mode);
178     if (ret < 0)
179         return ret;
180     *siglen = ret;
181     return 1;
182 }
183
184 static int pkey_rsa_verifyrecover(EVP_PKEY_CTX *ctx,
185                                   unsigned char *rout, size_t *routlen,
186                                   const unsigned char *sig, size_t siglen)
187 {
188     int ret;
189     RSA_PKEY_CTX *rctx = ctx->data;
190
191     if (rctx->md) {
192         if (rctx->pad_mode == RSA_X931_PADDING) {
193             if (!setup_tbuf(rctx, ctx))
194                 return -1;
195             ret = RSA_public_decrypt(siglen, sig,
196                                      rctx->tbuf, ctx->pkey->pkey.rsa,
197                                      RSA_X931_PADDING);
198             if (ret < 1)
199                 return 0;
200             ret--;
201             if (rctx->tbuf[ret] != RSA_X931_hash_id(EVP_MD_type(rctx->md))) {
202                 RSAerr(RSA_F_PKEY_RSA_VERIFYRECOVER,
203                        RSA_R_ALGORITHM_MISMATCH);
204                 return 0;
205             }
206             if (ret != EVP_MD_size(rctx->md)) {
207                 RSAerr(RSA_F_PKEY_RSA_VERIFYRECOVER,
208                        RSA_R_INVALID_DIGEST_LENGTH);
209                 return 0;
210             }
211             if (rout)
212                 memcpy(rout, rctx->tbuf, ret);
213         } else if (rctx->pad_mode == RSA_PKCS1_PADDING) {
214             size_t sltmp;
215             ret = int_rsa_verify(EVP_MD_type(rctx->md),
216                                  NULL, 0, rout, &sltmp,
217                                  sig, siglen, ctx->pkey->pkey.rsa);
218             if (ret <= 0)
219                 return 0;
220             ret = sltmp;
221         } else
222             return -1;
223     } else
224         ret = RSA_public_decrypt(siglen, sig, rout, ctx->pkey->pkey.rsa,
225                                  rctx->pad_mode);
226     if (ret < 0)
227         return ret;
228     *routlen = ret;
229     return 1;
230 }
231
232 static int pkey_rsa_verify(EVP_PKEY_CTX *ctx,
233                            const unsigned char *sig, size_t siglen,
234                            const unsigned char *tbs, size_t tbslen)
235 {
236     RSA_PKEY_CTX *rctx = ctx->data;
237     RSA *rsa = ctx->pkey->pkey.rsa;
238     size_t rslen;
239
240     if (rctx->md) {
241         if (rctx->pad_mode == RSA_PKCS1_PADDING)
242             return RSA_verify(EVP_MD_type(rctx->md), tbs, tbslen,
243                               sig, siglen, rsa);
244         if (tbslen != (size_t)EVP_MD_size(rctx->md)) {
245             RSAerr(RSA_F_PKEY_RSA_VERIFY, RSA_R_INVALID_DIGEST_LENGTH);
246             return -1;
247         }
248         if (rctx->pad_mode == RSA_X931_PADDING) {
249             if (pkey_rsa_verifyrecover(ctx, NULL, &rslen, sig, siglen) <= 0)
250                 return 0;
251         } else if (rctx->pad_mode == RSA_PKCS1_PSS_PADDING) {
252             int ret;
253             if (!setup_tbuf(rctx, ctx))
254                 return -1;
255             ret = RSA_public_decrypt(siglen, sig, rctx->tbuf,
256                                      rsa, RSA_NO_PADDING);
257             if (ret <= 0)
258                 return 0;
259             ret = RSA_verify_PKCS1_PSS_mgf1(rsa, tbs,
260                                             rctx->md, rctx->mgf1md,
261                                             rctx->tbuf, rctx->saltlen);
262             if (ret <= 0)
263                 return 0;
264             return 1;
265         } else
266             return -1;
267     } else {
268         if (!setup_tbuf(rctx, ctx))
269             return -1;
270         rslen = RSA_public_decrypt(siglen, sig, rctx->tbuf,
271                                    rsa, rctx->pad_mode);
272         if (rslen == 0)
273             return 0;
274     }
275
276     if ((rslen != tbslen) || memcmp(tbs, rctx->tbuf, rslen))
277         return 0;
278
279     return 1;
280
281 }
282
283 static int pkey_rsa_encrypt(EVP_PKEY_CTX *ctx,
284                             unsigned char *out, size_t *outlen,
285                             const unsigned char *in, size_t inlen)
286 {
287     int ret;
288     RSA_PKEY_CTX *rctx = ctx->data;
289
290     if (rctx->pad_mode == RSA_PKCS1_OAEP_PADDING) {
291         int klen = RSA_size(ctx->pkey->pkey.rsa);
292         if (!setup_tbuf(rctx, ctx))
293             return -1;
294         if (!RSA_padding_add_PKCS1_OAEP_mgf1(rctx->tbuf, klen,
295                                              in, inlen,
296                                              rctx->oaep_label,
297                                              rctx->oaep_labellen,
298                                              rctx->md, rctx->mgf1md))
299             return -1;
300         ret = RSA_public_encrypt(klen, rctx->tbuf, out,
301                                  ctx->pkey->pkey.rsa, RSA_NO_PADDING);
302     } else
303         ret = RSA_public_encrypt(inlen, in, out, ctx->pkey->pkey.rsa,
304                                  rctx->pad_mode);
305     if (ret < 0)
306         return ret;
307     *outlen = ret;
308     return 1;
309 }
310
311 static int pkey_rsa_decrypt(EVP_PKEY_CTX *ctx,
312                             unsigned char *out, size_t *outlen,
313                             const unsigned char *in, size_t inlen)
314 {
315     int ret;
316     RSA_PKEY_CTX *rctx = ctx->data;
317
318     if (rctx->pad_mode == RSA_PKCS1_OAEP_PADDING) {
319         if (!setup_tbuf(rctx, ctx))
320             return -1;
321         ret = RSA_private_decrypt(inlen, in, rctx->tbuf,
322                                   ctx->pkey->pkey.rsa, RSA_NO_PADDING);
323         if (ret <= 0)
324             return ret;
325         ret = RSA_padding_check_PKCS1_OAEP_mgf1(out, ret, rctx->tbuf,
326                                                 ret, ret,
327                                                 rctx->oaep_label,
328                                                 rctx->oaep_labellen,
329                                                 rctx->md, rctx->mgf1md);
330     } else
331         ret = RSA_private_decrypt(inlen, in, out, ctx->pkey->pkey.rsa,
332                                   rctx->pad_mode);
333     if (ret < 0)
334         return ret;
335     *outlen = ret;
336     return 1;
337 }
338
339 static int check_padding_md(const EVP_MD *md, int padding)
340 {
341     int mdnid;
342
343     if (!md)
344         return 1;
345
346     mdnid = EVP_MD_type(md);
347
348     if (padding == RSA_NO_PADDING) {
349         RSAerr(RSA_F_CHECK_PADDING_MD, RSA_R_INVALID_PADDING_MODE);
350         return 0;
351     }
352
353     if (padding == RSA_X931_PADDING) {
354         if (RSA_X931_hash_id(mdnid) == -1) {
355             RSAerr(RSA_F_CHECK_PADDING_MD, RSA_R_INVALID_X931_DIGEST);
356             return 0;
357         }
358     } else {
359         switch(mdnid) {
360         /* List of all supported RSA digests */
361         case NID_sha1:
362         case NID_sha224:
363         case NID_sha256:
364         case NID_sha384:
365         case NID_sha512:
366         case NID_md5:
367         case NID_md5_sha1:
368         case NID_md2:
369         case NID_md4:
370         case NID_mdc2:
371         case NID_ripemd160:
372             return 1;
373
374         default:
375             RSAerr(RSA_F_CHECK_PADDING_MD, RSA_R_INVALID_DIGEST);
376             return 0;
377
378         }
379     }
380
381     return 1;
382 }
383
384 static int pkey_rsa_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2)
385 {
386     RSA_PKEY_CTX *rctx = ctx->data;
387
388     switch (type) {
389     case EVP_PKEY_CTRL_RSA_PADDING:
390         if ((p1 >= RSA_PKCS1_PADDING) && (p1 <= RSA_PKCS1_PSS_PADDING)) {
391             if (!check_padding_md(rctx->md, p1))
392                 return 0;
393             if (p1 == RSA_PKCS1_PSS_PADDING) {
394                 if (!(ctx->operation &
395                       (EVP_PKEY_OP_SIGN | EVP_PKEY_OP_VERIFY)))
396                     goto bad_pad;
397                 if (!rctx->md)
398                     rctx->md = EVP_sha1();
399             } else if (pkey_ctx_is_pss(ctx)) {
400                 goto bad_pad;
401             }
402             if (p1 == RSA_PKCS1_OAEP_PADDING) {
403                 if (!(ctx->operation & EVP_PKEY_OP_TYPE_CRYPT))
404                     goto bad_pad;
405                 if (!rctx->md)
406                     rctx->md = EVP_sha1();
407             }
408             rctx->pad_mode = p1;
409             return 1;
410         }
411  bad_pad:
412         RSAerr(RSA_F_PKEY_RSA_CTRL,
413                RSA_R_ILLEGAL_OR_UNSUPPORTED_PADDING_MODE);
414         return -2;
415
416     case EVP_PKEY_CTRL_GET_RSA_PADDING:
417         *(int *)p2 = rctx->pad_mode;
418         return 1;
419
420     case EVP_PKEY_CTRL_RSA_PSS_SALTLEN:
421     case EVP_PKEY_CTRL_GET_RSA_PSS_SALTLEN:
422         if (rctx->pad_mode != RSA_PKCS1_PSS_PADDING) {
423             RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_INVALID_PSS_SALTLEN);
424             return -2;
425         }
426         if (type == EVP_PKEY_CTRL_GET_RSA_PSS_SALTLEN) {
427             *(int *)p2 = rctx->saltlen;
428         } else {
429             if (p1 < RSA_PSS_SALTLEN_MAX)
430                 return -2;
431             if (rsa_pss_restricted(rctx)) {
432                 if (p1 == RSA_PSS_SALTLEN_AUTO
433                     && ctx->operation == EVP_PKEY_OP_VERIFY) {
434                     RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_INVALID_PSS_SALTLEN);
435                     return -2;
436                 }
437                 if ((p1 == RSA_PSS_SALTLEN_DIGEST
438                      && rctx->min_saltlen > EVP_MD_size(rctx->md))
439                     || (p1 >= 0 && p1 < rctx->min_saltlen)) {
440                     RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_PSS_SALTLEN_TOO_SMALL);
441                     return 0;
442                 }
443             }
444             rctx->saltlen = p1;
445         }
446         return 1;
447
448     case EVP_PKEY_CTRL_RSA_KEYGEN_BITS:
449         if (p1 < 512) {
450             RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_KEY_SIZE_TOO_SMALL);
451             return -2;
452         }
453         rctx->nbits = p1;
454         return 1;
455
456     case EVP_PKEY_CTRL_RSA_KEYGEN_PUBEXP:
457         if (p2 == NULL || !BN_is_odd((BIGNUM *)p2) || BN_is_one((BIGNUM *)p2)) {
458             RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_BAD_E_VALUE);
459             return -2;
460         }
461         BN_free(rctx->pub_exp);
462         rctx->pub_exp = p2;
463         return 1;
464
465     case EVP_PKEY_CTRL_RSA_OAEP_MD:
466     case EVP_PKEY_CTRL_GET_RSA_OAEP_MD:
467         if (rctx->pad_mode != RSA_PKCS1_OAEP_PADDING) {
468             RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_INVALID_PADDING_MODE);
469             return -2;
470         }
471         if (type == EVP_PKEY_CTRL_GET_RSA_OAEP_MD)
472             *(const EVP_MD **)p2 = rctx->md;
473         else
474             rctx->md = p2;
475         return 1;
476
477     case EVP_PKEY_CTRL_MD:
478         if (!check_padding_md(p2, rctx->pad_mode))
479             return 0;
480         if (rsa_pss_restricted(rctx)) {
481             if (EVP_MD_type(rctx->md) == EVP_MD_type(p2))
482                 return 1;
483             RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_DIGEST_NOT_ALLOWED);
484             return 0;
485         }
486         rctx->md = p2;
487         return 1;
488
489     case EVP_PKEY_CTRL_GET_MD:
490         *(const EVP_MD **)p2 = rctx->md;
491         return 1;
492
493     case EVP_PKEY_CTRL_RSA_MGF1_MD:
494     case EVP_PKEY_CTRL_GET_RSA_MGF1_MD:
495         if (rctx->pad_mode != RSA_PKCS1_PSS_PADDING
496             && rctx->pad_mode != RSA_PKCS1_OAEP_PADDING) {
497             RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_INVALID_MGF1_MD);
498             return -2;
499         }
500         if (type == EVP_PKEY_CTRL_GET_RSA_MGF1_MD) {
501             if (rctx->mgf1md)
502                 *(const EVP_MD **)p2 = rctx->mgf1md;
503             else
504                 *(const EVP_MD **)p2 = rctx->md;
505         } else {
506             if (rsa_pss_restricted(rctx)) {
507                 if (EVP_MD_type(rctx->mgf1md) == EVP_MD_type(p2))
508                     return 1;
509                 RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_MGF1_DIGEST_NOT_ALLOWED);
510                 return 0;
511             }
512             rctx->mgf1md = p2;
513         }
514         return 1;
515
516     case EVP_PKEY_CTRL_RSA_OAEP_LABEL:
517         if (rctx->pad_mode != RSA_PKCS1_OAEP_PADDING) {
518             RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_INVALID_PADDING_MODE);
519             return -2;
520         }
521         OPENSSL_free(rctx->oaep_label);
522         if (p2 && p1 > 0) {
523             rctx->oaep_label = p2;
524             rctx->oaep_labellen = p1;
525         } else {
526             rctx->oaep_label = NULL;
527             rctx->oaep_labellen = 0;
528         }
529         return 1;
530
531     case EVP_PKEY_CTRL_GET_RSA_OAEP_LABEL:
532         if (rctx->pad_mode != RSA_PKCS1_OAEP_PADDING) {
533             RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_INVALID_PADDING_MODE);
534             return -2;
535         }
536         *(unsigned char **)p2 = rctx->oaep_label;
537         return rctx->oaep_labellen;
538
539     case EVP_PKEY_CTRL_DIGESTINIT:
540     case EVP_PKEY_CTRL_PKCS7_SIGN:
541 #ifndef OPENSSL_NO_CMS
542     case EVP_PKEY_CTRL_CMS_SIGN:
543 #endif
544     return 1;
545
546     case EVP_PKEY_CTRL_PKCS7_ENCRYPT:
547     case EVP_PKEY_CTRL_PKCS7_DECRYPT:
548 #ifndef OPENSSL_NO_CMS
549     case EVP_PKEY_CTRL_CMS_DECRYPT:
550     case EVP_PKEY_CTRL_CMS_ENCRYPT:
551 #endif
552     if (!pkey_ctx_is_pss(ctx))
553         return 1;
554     /* fall through */
555     case EVP_PKEY_CTRL_PEER_KEY:
556         RSAerr(RSA_F_PKEY_RSA_CTRL,
557                RSA_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
558         return -2;
559
560     default:
561         return -2;
562
563     }
564 }
565
566 static int pkey_rsa_ctrl_str(EVP_PKEY_CTX *ctx,
567                              const char *type, const char *value)
568 {
569     if (value == NULL) {
570         RSAerr(RSA_F_PKEY_RSA_CTRL_STR, RSA_R_VALUE_MISSING);
571         return 0;
572     }
573     if (strcmp(type, "rsa_padding_mode") == 0) {
574         int pm;
575         if (strcmp(value, "pkcs1") == 0)
576             pm = RSA_PKCS1_PADDING;
577         else if (strcmp(value, "sslv23") == 0)
578             pm = RSA_SSLV23_PADDING;
579         else if (strcmp(value, "none") == 0)
580             pm = RSA_NO_PADDING;
581         else if (strcmp(value, "oeap") == 0)
582             pm = RSA_PKCS1_OAEP_PADDING;
583         else if (strcmp(value, "oaep") == 0)
584             pm = RSA_PKCS1_OAEP_PADDING;
585         else if (strcmp(value, "x931") == 0)
586             pm = RSA_X931_PADDING;
587         else if (strcmp(value, "pss") == 0)
588             pm = RSA_PKCS1_PSS_PADDING;
589         else {
590             RSAerr(RSA_F_PKEY_RSA_CTRL_STR, RSA_R_UNKNOWN_PADDING_TYPE);
591             return -2;
592         }
593         return EVP_PKEY_CTX_set_rsa_padding(ctx, pm);
594     }
595
596     if (strcmp(type, "rsa_pss_saltlen") == 0) {
597         int saltlen;
598         if (!strcmp(value, "digest"))
599             saltlen = RSA_PSS_SALTLEN_DIGEST;
600         else if (!strcmp(value, "max"))
601             saltlen = RSA_PSS_SALTLEN_MAX;
602         else if (!strcmp(value, "auto"))
603             saltlen = RSA_PSS_SALTLEN_AUTO;
604         else
605             saltlen = atoi(value);
606         return EVP_PKEY_CTX_set_rsa_pss_saltlen(ctx, saltlen);
607     }
608
609     if (strcmp(type, "rsa_keygen_bits") == 0) {
610         int nbits;
611         nbits = atoi(value);
612         return EVP_PKEY_CTX_set_rsa_keygen_bits(ctx, nbits);
613     }
614
615     if (strcmp(type, "rsa_keygen_pubexp") == 0) {
616         int ret;
617         BIGNUM *pubexp = NULL;
618         if (!BN_asc2bn(&pubexp, value))
619             return 0;
620         ret = EVP_PKEY_CTX_set_rsa_keygen_pubexp(ctx, pubexp);
621         if (ret <= 0)
622             BN_free(pubexp);
623         return ret;
624     }
625
626     if (strcmp(type, "rsa_mgf1_md") == 0)
627         return EVP_PKEY_CTX_md(ctx,
628                                EVP_PKEY_OP_TYPE_SIG | EVP_PKEY_OP_TYPE_CRYPT,
629                                EVP_PKEY_CTRL_RSA_MGF1_MD, value);
630
631     if (pkey_ctx_is_pss(ctx)) {
632
633         if (strcmp(type, "rsa_pss_keygen_mgf1_md") == 0)
634             return EVP_PKEY_CTX_md(ctx, EVP_PKEY_OP_KEYGEN,
635                                    EVP_PKEY_CTRL_RSA_MGF1_MD, value);
636
637         if (strcmp(type, "rsa_pss_keygen_md") == 0)
638             return EVP_PKEY_CTX_md(ctx, EVP_PKEY_OP_KEYGEN,
639                                    EVP_PKEY_CTRL_MD, value);
640
641         if (strcmp(type, "rsa_pss_keygen_saltlen") == 0) {
642             int saltlen = atoi(value);
643
644             return EVP_PKEY_CTX_set_rsa_pss_keygen_saltlen(ctx, saltlen);
645         }
646     }
647
648     if (strcmp(type, "rsa_oaep_md") == 0)
649         return EVP_PKEY_CTX_md(ctx, EVP_PKEY_OP_TYPE_CRYPT,
650                                EVP_PKEY_CTRL_RSA_OAEP_MD, value);
651
652     if (strcmp(type, "rsa_oaep_label") == 0) {
653         unsigned char *lab;
654         long lablen;
655         int ret;
656         lab = OPENSSL_hexstr2buf(value, &lablen);
657         if (!lab)
658             return 0;
659         ret = EVP_PKEY_CTX_set0_rsa_oaep_label(ctx, lab, lablen);
660         if (ret <= 0)
661             OPENSSL_free(lab);
662         return ret;
663     }
664
665     return -2;
666 }
667
668 /* Set PSS parameters when generating a key, if necessary */
669 static int rsa_set_pss_param(RSA *rsa, EVP_PKEY_CTX *ctx)
670 {
671     RSA_PKEY_CTX *rctx = ctx->data;
672
673     if (!pkey_ctx_is_pss(ctx))
674         return 1;
675     /* If all parameters are default values don't set pss */
676     if (rctx->md == NULL && rctx->mgf1md == NULL && rctx->saltlen == -2)
677         return 1;
678     rsa->pss = rsa_pss_params_create(rctx->md, rctx->mgf1md,
679                                      rctx->saltlen == -2 ? 0 : rctx->saltlen);
680     if (rsa->pss == NULL)
681         return 0;
682     return 1;
683 }
684
685 static int pkey_rsa_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)
686 {
687     RSA *rsa = NULL;
688     RSA_PKEY_CTX *rctx = ctx->data;
689     BN_GENCB *pcb;
690     int ret;
691
692     if (rctx->pub_exp == NULL) {
693         rctx->pub_exp = BN_new();
694         if (rctx->pub_exp == NULL || !BN_set_word(rctx->pub_exp, RSA_F4))
695             return 0;
696     }
697     rsa = RSA_new();
698     if (rsa == NULL)
699         return 0;
700     if (ctx->pkey_gencb) {
701         pcb = BN_GENCB_new();
702         if (pcb == NULL) {
703             RSA_free(rsa);
704             return 0;
705         }
706         evp_pkey_set_cb_translate(pcb, ctx);
707     } else
708         pcb = NULL;
709     ret = RSA_generate_key_ex(rsa, rctx->nbits, rctx->pub_exp, pcb);
710     BN_GENCB_free(pcb);
711     if (ret > 0 && !rsa_set_pss_param(rsa, ctx)) {
712         RSA_free(rsa);
713         return 0;
714     }
715     if (ret > 0)
716         EVP_PKEY_assign(pkey, ctx->pmeth->pkey_id, rsa);
717     else
718         RSA_free(rsa);
719     return ret;
720 }
721
722 const EVP_PKEY_METHOD rsa_pkey_meth = {
723     EVP_PKEY_RSA,
724     EVP_PKEY_FLAG_AUTOARGLEN,
725     pkey_rsa_init,
726     pkey_rsa_copy,
727     pkey_rsa_cleanup,
728
729     0, 0,
730
731     0,
732     pkey_rsa_keygen,
733
734     0,
735     pkey_rsa_sign,
736
737     0,
738     pkey_rsa_verify,
739
740     0,
741     pkey_rsa_verifyrecover,
742
743     0, 0, 0, 0,
744
745     0,
746     pkey_rsa_encrypt,
747
748     0,
749     pkey_rsa_decrypt,
750
751     0, 0,
752
753     pkey_rsa_ctrl,
754     pkey_rsa_ctrl_str
755 };
756
757 /*
758  * Called for PSS sign or verify initialisation: checks PSS parameter
759  * sanity and sets any restrictions on key usage.
760  */
761
762 static int pkey_pss_init(EVP_PKEY_CTX *ctx)
763 {
764     RSA *rsa;
765     RSA_PKEY_CTX *rctx = ctx->data;
766     const EVP_MD *md;
767     const EVP_MD *mgf1md;
768     int min_saltlen, max_saltlen;
769
770     /* Should never happen */
771     if (!pkey_ctx_is_pss(ctx))
772         return 0;
773     rsa = ctx->pkey->pkey.rsa;
774     /* If no restrictions just return */
775     if (rsa->pss == NULL)
776         return 1;
777     /* Get and check parameters */
778     if (!rsa_pss_get_param(rsa->pss, &md, &mgf1md, &min_saltlen))
779         return 0;
780
781     /* See if minumum salt length exceeds maximum possible */
782     max_saltlen = RSA_size(rsa) - EVP_MD_size(md);
783     if ((RSA_bits(rsa) & 0x7) == 1)
784         max_saltlen--;
785     if (min_saltlen > max_saltlen) {
786         RSAerr(RSA_F_PKEY_PSS_INIT, RSA_R_INVALID_SALT_LENGTH);
787         return 0;
788     }
789
790     rctx->min_saltlen = min_saltlen;
791
792     /*
793      * Set PSS restrictions as defaults: we can then block any attempt to
794      * use invalid values in pkey_rsa_ctrl
795      */
796
797     rctx->md = md;
798     rctx->mgf1md = mgf1md;
799     rctx->saltlen = min_saltlen;
800
801     return 1;
802 }
803
804 const EVP_PKEY_METHOD rsa_pss_pkey_meth = {
805     EVP_PKEY_RSA_PSS,
806     EVP_PKEY_FLAG_AUTOARGLEN,
807     pkey_rsa_init,
808     pkey_rsa_copy,
809     pkey_rsa_cleanup,
810
811     0, 0,
812
813     0,
814     pkey_rsa_keygen,
815
816     pkey_pss_init,
817     pkey_rsa_sign,
818
819     pkey_pss_init,
820     pkey_rsa_verify,
821
822     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
823
824     pkey_rsa_ctrl,
825     pkey_rsa_ctrl_str
826 };