1 // Copyright 2006-2016 The OpenSSL Project Authors. All Rights Reserved.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 //     https://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14 
15 #include <openssl/evp.h>
16 
17 #include <limits.h>
18 #include <string.h>
19 
20 #include <openssl/bn.h>
21 #include <openssl/bytestring.h>
22 #include <openssl/digest.h>
23 #include <openssl/err.h>
24 #include <openssl/mem.h>
25 #include <openssl/nid.h>
26 #include <openssl/rsa.h>
27 #include <openssl/span.h>
28 
29 #include "../internal.h"
30 #include "../mem_internal.h"
31 #include "../rsa/internal.h"
32 #include "internal.h"
33 
34 
35 namespace {
36 
37 struct RSA_PKEY_CTX {
38   // Key gen parameters
39   int nbits = 2048;
40   bssl::UniquePtr<BIGNUM> pub_exp;
41   // RSA padding mode
42   int pad_mode = RSA_PKCS1_PADDING;
43   // message digest
44   const EVP_MD *md = nullptr;
45   // message digest for MGF1
46   const EVP_MD *mgf1md = nullptr;
47   // PSS salt length
48   int saltlen = RSA_PSS_SALTLEN_DIGEST;
49   bssl::Array<uint8_t> oaep_label;
50 };
51 
pkey_rsa_init(EVP_PKEY_CTX * ctx)52 static int pkey_rsa_init(EVP_PKEY_CTX *ctx) {
53   RSA_PKEY_CTX *rctx = bssl::New<RSA_PKEY_CTX>();
54   if (!rctx) {
55     return 0;
56   }
57 
58   ctx->data = rctx;
59   return 1;
60 }
61 
pkey_rsa_copy(EVP_PKEY_CTX * dst,EVP_PKEY_CTX * src)62 static int pkey_rsa_copy(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src) {
63   RSA_PKEY_CTX *dctx, *sctx;
64   if (!pkey_rsa_init(dst)) {
65     return 0;
66   }
67   sctx = reinterpret_cast<RSA_PKEY_CTX *>(src->data);
68   dctx = reinterpret_cast<RSA_PKEY_CTX *>(dst->data);
69   dctx->nbits = sctx->nbits;
70   if (sctx->pub_exp) {
71     dctx->pub_exp.reset(BN_dup(sctx->pub_exp.get()));
72     if (!dctx->pub_exp) {
73       return 0;
74     }
75   }
76 
77   dctx->pad_mode = sctx->pad_mode;
78   dctx->md = sctx->md;
79   dctx->mgf1md = sctx->mgf1md;
80   dctx->saltlen = sctx->saltlen;
81   if (!dctx->oaep_label.CopyFrom(sctx->oaep_label)) {
82     return 0;
83   }
84 
85   return 1;
86 }
87 
pkey_rsa_cleanup(EVP_PKEY_CTX * ctx)88 static void pkey_rsa_cleanup(EVP_PKEY_CTX *ctx) {
89   bssl::Delete(reinterpret_cast<RSA_PKEY_CTX *>(ctx->data));
90 }
91 
pkey_rsa_sign(EVP_PKEY_CTX * ctx,uint8_t * sig,size_t * siglen,const uint8_t * tbs,size_t tbslen)92 static int pkey_rsa_sign(EVP_PKEY_CTX *ctx, uint8_t *sig, size_t *siglen,
93                          const uint8_t *tbs, size_t tbslen) {
94   RSA_PKEY_CTX *rctx = reinterpret_cast<RSA_PKEY_CTX *>(ctx->data);
95   RSA *rsa = reinterpret_cast<RSA *>(ctx->pkey->pkey);
96   const size_t key_len = EVP_PKEY_size(ctx->pkey.get());
97 
98   if (!sig) {
99     *siglen = key_len;
100     return 1;
101   }
102 
103   if (*siglen < key_len) {
104     OPENSSL_PUT_ERROR(EVP, EVP_R_BUFFER_TOO_SMALL);
105     return 0;
106   }
107 
108   if (rctx->md) {
109     unsigned out_len;
110     switch (rctx->pad_mode) {
111       case RSA_PKCS1_PADDING:
112         if (!RSA_sign(EVP_MD_type(rctx->md), tbs, tbslen, sig, &out_len, rsa)) {
113           return 0;
114         }
115         *siglen = out_len;
116         return 1;
117 
118       case RSA_PKCS1_PSS_PADDING:
119         return RSA_sign_pss_mgf1(rsa, siglen, sig, *siglen, tbs, tbslen,
120                                  rctx->md, rctx->mgf1md, rctx->saltlen);
121 
122       default:
123         return 0;
124     }
125   }
126 
127   return RSA_sign_raw(rsa, siglen, sig, *siglen, tbs, tbslen, rctx->pad_mode);
128 }
129 
pkey_rsa_verify(EVP_PKEY_CTX * ctx,const uint8_t * sig,size_t siglen,const uint8_t * tbs,size_t tbslen)130 static int pkey_rsa_verify(EVP_PKEY_CTX *ctx, const uint8_t *sig, size_t siglen,
131                            const uint8_t *tbs, size_t tbslen) {
132   RSA_PKEY_CTX *rctx = reinterpret_cast<RSA_PKEY_CTX *>(ctx->data);
133   RSA *rsa = reinterpret_cast<RSA *>(ctx->pkey->pkey);
134 
135   if (rctx->md) {
136     switch (rctx->pad_mode) {
137       case RSA_PKCS1_PADDING:
138         return RSA_verify(EVP_MD_type(rctx->md), tbs, tbslen, sig, siglen, rsa);
139 
140       case RSA_PKCS1_PSS_PADDING:
141         return RSA_verify_pss_mgf1(rsa, tbs, tbslen, rctx->md, rctx->mgf1md,
142                                    rctx->saltlen, sig, siglen);
143 
144       default:
145         return 0;
146     }
147   }
148 
149   size_t rslen;
150   const size_t key_len = EVP_PKEY_size(ctx->pkey.get());
151   bssl::Array<uint8_t> tbuf;
152   if (!tbuf.InitForOverwrite(key_len) ||
153       !RSA_verify_raw(rsa, &rslen, tbuf.data(), tbuf.size(), sig, siglen,
154                       rctx->pad_mode)) {
155     return 0;
156   }
157   if (rslen != tbslen || CRYPTO_memcmp(tbs, tbuf.data(), rslen) != 0) {
158     OPENSSL_PUT_ERROR(RSA, RSA_R_BAD_SIGNATURE);
159     return 0;
160   }
161 
162   return 1;
163 }
164 
pkey_rsa_verify_recover(EVP_PKEY_CTX * ctx,uint8_t * out,size_t * out_len,const uint8_t * sig,size_t sig_len)165 static int pkey_rsa_verify_recover(EVP_PKEY_CTX *ctx, uint8_t *out,
166                                    size_t *out_len, const uint8_t *sig,
167                                    size_t sig_len) {
168   RSA_PKEY_CTX *rctx = reinterpret_cast<RSA_PKEY_CTX *>(ctx->data);
169   RSA *rsa = reinterpret_cast<RSA *>(ctx->pkey->pkey);
170   const size_t key_len = EVP_PKEY_size(ctx->pkey.get());
171 
172   if (out == NULL) {
173     *out_len = key_len;
174     return 1;
175   }
176 
177   if (*out_len < key_len) {
178     OPENSSL_PUT_ERROR(EVP, EVP_R_BUFFER_TOO_SMALL);
179     return 0;
180   }
181 
182   if (rctx->md == NULL) {
183     return RSA_verify_raw(rsa, out_len, out, *out_len, sig, sig_len,
184                           rctx->pad_mode);
185   }
186 
187   if (rctx->pad_mode != RSA_PKCS1_PADDING) {
188     return 0;
189   }
190 
191   // Assemble the encoded hash, using a placeholder hash value.
192   static const uint8_t kDummyHash[EVP_MAX_MD_SIZE] = {0};
193   const size_t hash_len = EVP_MD_size(rctx->md);
194   uint8_t *asn1_prefix;
195   size_t asn1_prefix_len;
196   int asn1_prefix_allocated;
197   if (!RSA_add_pkcs1_prefix(&asn1_prefix, &asn1_prefix_len,
198                             &asn1_prefix_allocated, EVP_MD_type(rctx->md),
199                             kDummyHash, hash_len)) {
200     return 0;
201   }
202   bssl::UniquePtr<uint8_t> free_asn1_prefix(asn1_prefix_allocated ? asn1_prefix
203                                                                   : nullptr);
204 
205   bssl::Array<uint8_t> tbuf;
206   size_t rslen;
207   if (!tbuf.InitForOverwrite(key_len) ||
208       !RSA_verify_raw(rsa, &rslen, tbuf.data(), tbuf.size(), sig, sig_len,
209                       RSA_PKCS1_PADDING) ||
210       rslen != asn1_prefix_len ||
211       // Compare all but the hash suffix.
212       CRYPTO_memcmp(tbuf.data(), asn1_prefix, asn1_prefix_len - hash_len) !=
213           0) {
214     return 0;
215   }
216 
217   if (out != NULL) {
218     OPENSSL_memcpy(out, tbuf.data() + rslen - hash_len, hash_len);
219   }
220   *out_len = hash_len;
221 
222   return 1;
223 }
224 
pkey_rsa_encrypt(EVP_PKEY_CTX * ctx,uint8_t * out,size_t * outlen,const uint8_t * in,size_t inlen)225 static int pkey_rsa_encrypt(EVP_PKEY_CTX *ctx, uint8_t *out, size_t *outlen,
226                             const uint8_t *in, size_t inlen) {
227   RSA_PKEY_CTX *rctx = reinterpret_cast<RSA_PKEY_CTX *>(ctx->data);
228   RSA *rsa = reinterpret_cast<RSA *>(ctx->pkey->pkey);
229   const size_t key_len = EVP_PKEY_size(ctx->pkey.get());
230 
231   if (!out) {
232     *outlen = key_len;
233     return 1;
234   }
235 
236   if (*outlen < key_len) {
237     OPENSSL_PUT_ERROR(EVP, EVP_R_BUFFER_TOO_SMALL);
238     return 0;
239   }
240 
241   if (rctx->pad_mode == RSA_PKCS1_OAEP_PADDING) {
242     bssl::Array<uint8_t> tbuf;
243     if (!tbuf.InitForOverwrite(key_len) ||
244         !RSA_padding_add_PKCS1_OAEP_mgf1(
245             tbuf.data(), tbuf.size(), in, inlen, rctx->oaep_label.data(),
246             rctx->oaep_label.size(), rctx->md, rctx->mgf1md) ||
247         !RSA_encrypt(rsa, outlen, out, *outlen, tbuf.data(), tbuf.size(),
248                      RSA_NO_PADDING)) {
249       return 0;
250     }
251     return 1;
252   }
253 
254   return RSA_encrypt(rsa, outlen, out, *outlen, in, inlen, rctx->pad_mode);
255 }
256 
pkey_rsa_decrypt(EVP_PKEY_CTX * ctx,uint8_t * out,size_t * outlen,const uint8_t * in,size_t inlen)257 static int pkey_rsa_decrypt(EVP_PKEY_CTX *ctx, uint8_t *out, size_t *outlen,
258                             const uint8_t *in, size_t inlen) {
259   RSA_PKEY_CTX *rctx = reinterpret_cast<RSA_PKEY_CTX *>(ctx->data);
260   RSA *rsa = reinterpret_cast<RSA *>(ctx->pkey->pkey);
261   const size_t key_len = EVP_PKEY_size(ctx->pkey.get());
262 
263   if (!out) {
264     *outlen = key_len;
265     return 1;
266   }
267 
268   if (*outlen < key_len) {
269     OPENSSL_PUT_ERROR(EVP, EVP_R_BUFFER_TOO_SMALL);
270     return 0;
271   }
272 
273   if (rctx->pad_mode == RSA_PKCS1_OAEP_PADDING) {
274     bssl::Array<uint8_t> tbuf;
275     size_t padded_len;
276     if (!tbuf.InitForOverwrite(key_len) ||
277         !RSA_decrypt(rsa, &padded_len, tbuf.data(), tbuf.size(), in, inlen,
278                      RSA_NO_PADDING) ||
279         !RSA_padding_check_PKCS1_OAEP_mgf1(out, outlen, key_len, tbuf.data(),
280                                            padded_len, rctx->oaep_label.data(),
281                                            rctx->oaep_label.size(), rctx->md,
282                                            rctx->mgf1md)) {
283       return 0;
284     }
285     return 1;
286   }
287 
288   return RSA_decrypt(rsa, outlen, out, key_len, in, inlen, rctx->pad_mode);
289 }
290 
check_padding_md(const EVP_MD * md,int padding)291 static int check_padding_md(const EVP_MD *md, int padding) {
292   if (!md) {
293     return 1;
294   }
295 
296   if (padding == RSA_NO_PADDING) {
297     OPENSSL_PUT_ERROR(EVP, EVP_R_INVALID_PADDING_MODE);
298     return 0;
299   }
300 
301   return 1;
302 }
303 
is_known_padding(int padding_mode)304 static int is_known_padding(int padding_mode) {
305   switch (padding_mode) {
306     case RSA_PKCS1_PADDING:
307     case RSA_NO_PADDING:
308     case RSA_PKCS1_OAEP_PADDING:
309     case RSA_PKCS1_PSS_PADDING:
310       return 1;
311     default:
312       return 0;
313   }
314 }
315 
pkey_rsa_ctrl(EVP_PKEY_CTX * ctx,int type,int p1,void * p2)316 static int pkey_rsa_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2) {
317   RSA_PKEY_CTX *rctx = reinterpret_cast<RSA_PKEY_CTX *>(ctx->data);
318   switch (type) {
319     case EVP_PKEY_CTRL_RSA_PADDING:
320       if (!is_known_padding(p1) || !check_padding_md(rctx->md, p1) ||
321           (p1 == RSA_PKCS1_PSS_PADDING &&
322            0 == (ctx->operation & (EVP_PKEY_OP_SIGN | EVP_PKEY_OP_VERIFY))) ||
323           (p1 == RSA_PKCS1_OAEP_PADDING &&
324            0 == (ctx->operation & EVP_PKEY_OP_TYPE_CRYPT))) {
325         OPENSSL_PUT_ERROR(EVP, EVP_R_ILLEGAL_OR_UNSUPPORTED_PADDING_MODE);
326         return 0;
327       }
328       if (p1 == RSA_PKCS1_OAEP_PADDING && rctx->md == NULL) {
329         rctx->md = EVP_sha1();
330       }
331       rctx->pad_mode = p1;
332       return 1;
333 
334     case EVP_PKEY_CTRL_GET_RSA_PADDING:
335       *(int *)p2 = rctx->pad_mode;
336       return 1;
337 
338     case EVP_PKEY_CTRL_RSA_PSS_SALTLEN:
339     case EVP_PKEY_CTRL_GET_RSA_PSS_SALTLEN:
340       if (rctx->pad_mode != RSA_PKCS1_PSS_PADDING) {
341         OPENSSL_PUT_ERROR(EVP, EVP_R_INVALID_PSS_SALTLEN);
342         return 0;
343       }
344       if (type == EVP_PKEY_CTRL_GET_RSA_PSS_SALTLEN) {
345         *(int *)p2 = rctx->saltlen;
346       } else {
347         // Negative salt lengths are special values.
348         if (p1 < 0 &&
349             (p1 != RSA_PSS_SALTLEN_DIGEST && p1 != RSA_PSS_SALTLEN_AUTO)) {
350           return 0;
351         }
352         rctx->saltlen = p1;
353       }
354       return 1;
355 
356     case EVP_PKEY_CTRL_RSA_KEYGEN_BITS:
357       if (p1 < 256) {
358         OPENSSL_PUT_ERROR(EVP, EVP_R_INVALID_KEYBITS);
359         return 0;
360       }
361       rctx->nbits = p1;
362       return 1;
363 
364     case EVP_PKEY_CTRL_RSA_KEYGEN_PUBEXP:
365       if (!p2) {
366         return 0;
367       }
368       rctx->pub_exp.reset(reinterpret_cast<BIGNUM *>(p2));
369       return 1;
370 
371     case EVP_PKEY_CTRL_RSA_OAEP_MD:
372     case EVP_PKEY_CTRL_GET_RSA_OAEP_MD:
373       if (rctx->pad_mode != RSA_PKCS1_OAEP_PADDING) {
374         OPENSSL_PUT_ERROR(EVP, EVP_R_INVALID_PADDING_MODE);
375         return 0;
376       }
377       if (type == EVP_PKEY_CTRL_GET_RSA_OAEP_MD) {
378         *(const EVP_MD **)p2 = rctx->md;
379       } else {
380         rctx->md = reinterpret_cast<EVP_MD *>(p2);
381       }
382       return 1;
383 
384     case EVP_PKEY_CTRL_MD:
385       if (!check_padding_md(reinterpret_cast<EVP_MD *>(p2), rctx->pad_mode)) {
386         return 0;
387       }
388       rctx->md = reinterpret_cast<EVP_MD *>(p2);
389       return 1;
390 
391     case EVP_PKEY_CTRL_GET_MD:
392       *(const EVP_MD **)p2 = rctx->md;
393       return 1;
394 
395     case EVP_PKEY_CTRL_RSA_MGF1_MD:
396     case EVP_PKEY_CTRL_GET_RSA_MGF1_MD:
397       if (rctx->pad_mode != RSA_PKCS1_PSS_PADDING &&
398           rctx->pad_mode != RSA_PKCS1_OAEP_PADDING) {
399         OPENSSL_PUT_ERROR(EVP, EVP_R_INVALID_MGF1_MD);
400         return 0;
401       }
402       if (type == EVP_PKEY_CTRL_GET_RSA_MGF1_MD) {
403         if (rctx->mgf1md) {
404           *(const EVP_MD **)p2 = rctx->mgf1md;
405         } else {
406           *(const EVP_MD **)p2 = rctx->md;
407         }
408       } else {
409         rctx->mgf1md = reinterpret_cast<EVP_MD *>(p2);
410       }
411       return 1;
412 
413     case EVP_PKEY_CTRL_RSA_OAEP_LABEL: {
414       if (rctx->pad_mode != RSA_PKCS1_OAEP_PADDING) {
415         OPENSSL_PUT_ERROR(EVP, EVP_R_INVALID_PADDING_MODE);
416         return 0;
417       }
418       // |EVP_PKEY_CTRL_RSA_OAEP_LABEL| takes ownership of |label|'s underlying
419       // buffer (via |Reset|), but only on success.
420       auto *label = reinterpret_cast<bssl::Span<uint8_t> *>(p2);
421       rctx->oaep_label.Reset(label->data(), label->size());
422       return 1;
423     }
424 
425     case EVP_PKEY_CTRL_GET_RSA_OAEP_LABEL:
426       if (rctx->pad_mode != RSA_PKCS1_OAEP_PADDING) {
427         OPENSSL_PUT_ERROR(EVP, EVP_R_INVALID_PADDING_MODE);
428         return 0;
429       }
430       *reinterpret_cast<CBS *>(p2) = CBS(rctx->oaep_label);
431       return 1;
432 
433     default:
434       OPENSSL_PUT_ERROR(EVP, EVP_R_COMMAND_NOT_SUPPORTED);
435       return 0;
436   }
437 }
438 
pkey_rsa_keygen(EVP_PKEY_CTX * ctx,EVP_PKEY * pkey)439 static int pkey_rsa_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey) {
440   RSA_PKEY_CTX *rctx = reinterpret_cast<RSA_PKEY_CTX *>(ctx->data);
441   if (!rctx->pub_exp) {
442     rctx->pub_exp.reset(BN_new());
443     if (!rctx->pub_exp || !BN_set_word(rctx->pub_exp.get(), RSA_F4)) {
444       return 0;
445     }
446   }
447   bssl::UniquePtr<RSA> rsa(RSA_new());
448   if (!rsa) {
449     return 0;
450   }
451 
452   if (!RSA_generate_key_ex(rsa.get(), rctx->nbits, rctx->pub_exp.get(),
453                            nullptr)) {
454     return 0;
455   }
456 
457   EVP_PKEY_assign_RSA(pkey, rsa.release());
458   return 1;
459 }
460 
461 }  // namespace
462 
463 const EVP_PKEY_METHOD rsa_pkey_meth = {
464     EVP_PKEY_RSA,
465     pkey_rsa_init,
466     pkey_rsa_copy,
467     pkey_rsa_cleanup,
468     pkey_rsa_keygen,
469     pkey_rsa_sign,
470     NULL /* sign_message */,
471     pkey_rsa_verify,
472     NULL /* verify_message */,
473     pkey_rsa_verify_recover,
474     pkey_rsa_encrypt,
475     pkey_rsa_decrypt,
476     NULL /* derive */,
477     NULL /* paramgen */,
478     pkey_rsa_ctrl,
479 };
480 
EVP_PKEY_CTX_set_rsa_padding(EVP_PKEY_CTX * ctx,int padding)481 int EVP_PKEY_CTX_set_rsa_padding(EVP_PKEY_CTX *ctx, int padding) {
482   return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA, -1, EVP_PKEY_CTRL_RSA_PADDING,
483                            padding, NULL);
484 }
485 
EVP_PKEY_CTX_get_rsa_padding(EVP_PKEY_CTX * ctx,int * out_padding)486 int EVP_PKEY_CTX_get_rsa_padding(EVP_PKEY_CTX *ctx, int *out_padding) {
487   return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA, -1, EVP_PKEY_CTRL_GET_RSA_PADDING,
488                            0, out_padding);
489 }
490 
EVP_PKEY_CTX_set_rsa_pss_keygen_md(EVP_PKEY_CTX * ctx,const EVP_MD * md)491 int EVP_PKEY_CTX_set_rsa_pss_keygen_md(EVP_PKEY_CTX *ctx, const EVP_MD *md) {
492   return 0;
493 }
494 
EVP_PKEY_CTX_set_rsa_pss_keygen_saltlen(EVP_PKEY_CTX * ctx,int salt_len)495 int EVP_PKEY_CTX_set_rsa_pss_keygen_saltlen(EVP_PKEY_CTX *ctx, int salt_len) {
496   return 0;
497 }
498 
EVP_PKEY_CTX_set_rsa_pss_keygen_mgf1_md(EVP_PKEY_CTX * ctx,const EVP_MD * md)499 int EVP_PKEY_CTX_set_rsa_pss_keygen_mgf1_md(EVP_PKEY_CTX *ctx,
500                                             const EVP_MD *md) {
501   return 0;
502 }
503 
EVP_PKEY_CTX_set_rsa_pss_saltlen(EVP_PKEY_CTX * ctx,int salt_len)504 int EVP_PKEY_CTX_set_rsa_pss_saltlen(EVP_PKEY_CTX *ctx, int salt_len) {
505   return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA,
506                            (EVP_PKEY_OP_SIGN | EVP_PKEY_OP_VERIFY),
507                            EVP_PKEY_CTRL_RSA_PSS_SALTLEN, salt_len, NULL);
508 }
509 
EVP_PKEY_CTX_get_rsa_pss_saltlen(EVP_PKEY_CTX * ctx,int * out_salt_len)510 int EVP_PKEY_CTX_get_rsa_pss_saltlen(EVP_PKEY_CTX *ctx, int *out_salt_len) {
511   return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA,
512                            (EVP_PKEY_OP_SIGN | EVP_PKEY_OP_VERIFY),
513                            EVP_PKEY_CTRL_GET_RSA_PSS_SALTLEN, 0, out_salt_len);
514 }
515 
EVP_PKEY_CTX_set_rsa_keygen_bits(EVP_PKEY_CTX * ctx,int bits)516 int EVP_PKEY_CTX_set_rsa_keygen_bits(EVP_PKEY_CTX *ctx, int bits) {
517   return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA, EVP_PKEY_OP_KEYGEN,
518                            EVP_PKEY_CTRL_RSA_KEYGEN_BITS, bits, NULL);
519 }
520 
EVP_PKEY_CTX_set_rsa_keygen_pubexp(EVP_PKEY_CTX * ctx,BIGNUM * e)521 int EVP_PKEY_CTX_set_rsa_keygen_pubexp(EVP_PKEY_CTX *ctx, BIGNUM *e) {
522   return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA, EVP_PKEY_OP_KEYGEN,
523                            EVP_PKEY_CTRL_RSA_KEYGEN_PUBEXP, 0, e);
524 }
525 
EVP_PKEY_CTX_set_rsa_oaep_md(EVP_PKEY_CTX * ctx,const EVP_MD * md)526 int EVP_PKEY_CTX_set_rsa_oaep_md(EVP_PKEY_CTX *ctx, const EVP_MD *md) {
527   return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA, EVP_PKEY_OP_TYPE_CRYPT,
528                            EVP_PKEY_CTRL_RSA_OAEP_MD, 0, (void *)md);
529 }
530 
EVP_PKEY_CTX_get_rsa_oaep_md(EVP_PKEY_CTX * ctx,const EVP_MD ** out_md)531 int EVP_PKEY_CTX_get_rsa_oaep_md(EVP_PKEY_CTX *ctx, const EVP_MD **out_md) {
532   return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA, EVP_PKEY_OP_TYPE_CRYPT,
533                            EVP_PKEY_CTRL_GET_RSA_OAEP_MD, 0, (void *)out_md);
534 }
535 
EVP_PKEY_CTX_set_rsa_mgf1_md(EVP_PKEY_CTX * ctx,const EVP_MD * md)536 int EVP_PKEY_CTX_set_rsa_mgf1_md(EVP_PKEY_CTX *ctx, const EVP_MD *md) {
537   return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA,
538                            EVP_PKEY_OP_TYPE_SIG | EVP_PKEY_OP_TYPE_CRYPT,
539                            EVP_PKEY_CTRL_RSA_MGF1_MD, 0, (void *)md);
540 }
541 
EVP_PKEY_CTX_get_rsa_mgf1_md(EVP_PKEY_CTX * ctx,const EVP_MD ** out_md)542 int EVP_PKEY_CTX_get_rsa_mgf1_md(EVP_PKEY_CTX *ctx, const EVP_MD **out_md) {
543   return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA,
544                            EVP_PKEY_OP_TYPE_SIG | EVP_PKEY_OP_TYPE_CRYPT,
545                            EVP_PKEY_CTRL_GET_RSA_MGF1_MD, 0, (void *)out_md);
546 }
547 
EVP_PKEY_CTX_set0_rsa_oaep_label(EVP_PKEY_CTX * ctx,uint8_t * label,size_t label_len)548 int EVP_PKEY_CTX_set0_rsa_oaep_label(EVP_PKEY_CTX *ctx, uint8_t *label,
549                                      size_t label_len) {
550   bssl::Span span(label, label_len);
551   return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA, EVP_PKEY_OP_TYPE_CRYPT,
552                            EVP_PKEY_CTRL_RSA_OAEP_LABEL, 0, &span);
553 }
554 
EVP_PKEY_CTX_get0_rsa_oaep_label(EVP_PKEY_CTX * ctx,const uint8_t ** out_label)555 int EVP_PKEY_CTX_get0_rsa_oaep_label(EVP_PKEY_CTX *ctx,
556                                      const uint8_t **out_label) {
557   CBS label;
558   if (!EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA, EVP_PKEY_OP_TYPE_CRYPT,
559                          EVP_PKEY_CTRL_GET_RSA_OAEP_LABEL, 0, &label)) {
560     return -1;
561   }
562   if (CBS_len(&label) > INT_MAX) {
563     OPENSSL_PUT_ERROR(EVP, ERR_R_OVERFLOW);
564     return -1;
565   }
566   *out_label = CBS_data(&label);
567   return (int)CBS_len(&label);
568 }
569