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