67800282dee19d436e4f31a895fa258683355b28
[openssl.git] / crypto / evp / pmeth_gn.c
1 /*
2  * Copyright 2006-2016 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 #include <stdio.h>
11 #include <stdlib.h>
12 #include <openssl/core.h>
13 #include <openssl/core_names.h>
14 #include "internal/cryptlib.h"
15 #include "internal/core.h"
16 #include <openssl/objects.h>
17 #include <openssl/evp.h>
18 #include "crypto/bn.h"
19 #include "crypto/asn1.h"
20 #include "crypto/evp.h"
21 #include "evp_local.h"
22
23 static int gen_init(EVP_PKEY_CTX *ctx, int operation)
24 {
25     int ret = 0;
26
27     if (ctx == NULL)
28         goto not_supported;
29
30     evp_pkey_ctx_free_old_ops(ctx);
31     ctx->operation = operation;
32
33     if (ctx->keymgmt == NULL || ctx->keymgmt->gen_init == NULL)
34         goto legacy;
35
36     switch (operation) {
37     case EVP_PKEY_OP_PARAMGEN:
38         ctx->op.keymgmt.genctx =
39             evp_keymgmt_gen_init(ctx->keymgmt,
40                                  OSSL_KEYMGMT_SELECT_ALL_PARAMETERS);
41         break;
42     case EVP_PKEY_OP_KEYGEN:
43         ctx->op.keymgmt.genctx =
44             evp_keymgmt_gen_init(ctx->keymgmt, OSSL_KEYMGMT_SELECT_KEYPAIR);
45         break;
46     }
47
48     if (ctx->op.keymgmt.genctx == NULL)
49         ERR_raise(ERR_LIB_EVP, EVP_R_INITIALIZATION_ERROR);
50     else
51         ret = 1;
52     goto end;
53
54  legacy:
55 #ifdef FIPS_MODE
56     goto not_supported;
57 #else
58     if (ctx->pmeth == NULL
59         || (operation == EVP_PKEY_OP_PARAMGEN
60             && ctx->pmeth->paramgen == NULL)
61         || (operation == EVP_PKEY_OP_KEYGEN
62             && ctx->pmeth->keygen == NULL))
63         goto not_supported;
64
65     ret = 1;
66     switch (operation) {
67     case EVP_PKEY_OP_PARAMGEN:
68         if (ctx->pmeth->paramgen_init != NULL)
69             ret = ctx->pmeth->paramgen_init(ctx);
70         break;
71     case EVP_PKEY_OP_KEYGEN:
72         if (ctx->pmeth->keygen_init != NULL)
73             ret = ctx->pmeth->keygen_init(ctx);
74         break;
75     }
76 #endif
77
78  end:
79     if (ret <= 0)
80         ctx->operation = EVP_PKEY_OP_UNDEFINED;
81     return ret;
82
83  not_supported:
84     ERR_raise(ERR_LIB_EVP, EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
85     ret = -2;
86     goto end;
87 }
88
89 int EVP_PKEY_paramgen_init(EVP_PKEY_CTX *ctx)
90 {
91     return gen_init(ctx, EVP_PKEY_OP_PARAMGEN);
92 }
93
94 int EVP_PKEY_keygen_init(EVP_PKEY_CTX *ctx)
95 {
96     return gen_init(ctx, EVP_PKEY_OP_KEYGEN);
97 }
98
99 static int ossl_callback_to_pkey_gencb(const OSSL_PARAM params[], void *arg)
100 {
101     EVP_PKEY_CTX *ctx = arg;
102     const OSSL_PARAM *param = NULL;
103     int p = -1, n = -1;
104
105     if (ctx->pkey_gencb == NULL)
106         return 1;                /* No callback?  That's fine */
107
108     if ((param = OSSL_PARAM_locate_const(params, OSSL_GEN_PARAM_POTENTIAL))
109         == NULL
110         || !OSSL_PARAM_get_int(param, &p))
111         return 0;
112     if ((param = OSSL_PARAM_locate_const(params, OSSL_GEN_PARAM_ITERATION))
113         == NULL
114         || !OSSL_PARAM_get_int(param, &n))
115         return 0;
116
117     ctx->keygen_info[0] = p;
118     ctx->keygen_info[1] = n;
119
120     return ctx->pkey_gencb(ctx);
121 }
122
123 int EVP_PKEY_gen(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey)
124 {
125     int ret = 0;
126     OSSL_CALLBACK cb;
127     EVP_PKEY *allocated_pkey = NULL;
128
129     if (ppkey == NULL)
130         return -1;
131
132     if (ctx == NULL)
133         goto not_supported;
134
135     if ((ctx->operation & EVP_PKEY_OP_TYPE_GEN) == 0)
136         goto not_initialized;
137
138     if (*ppkey == NULL)
139         *ppkey = allocated_pkey = EVP_PKEY_new();
140
141     if (*ppkey == NULL) {
142         ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
143         return -1;
144     }
145
146     if (ctx->keymgmt == NULL || ctx->op.keymgmt.genctx == NULL)
147         goto legacy;
148
149     ret = 1;
150     if (ctx->pkey != NULL) {
151         EVP_KEYMGMT *tmp_keymgmt = ctx->keymgmt;
152         void *keydata =
153             evp_pkey_export_to_provider(ctx->pkey, ctx->libctx,
154                                         &tmp_keymgmt, ctx->propquery);
155
156         if (keydata == NULL)
157             goto not_supported;
158         ret = evp_keymgmt_gen_set_template(ctx->keymgmt,
159                                            ctx->op.keymgmt.genctx, keydata);
160     }
161
162     /*
163      * the returned value from evp_keymgmt_util_gen() is cached in *ppkey,
164      * so we so not need to save it, just check it.
165      */
166     ret = ret
167         && (evp_keymgmt_util_gen(*ppkey, ctx->keymgmt, ctx->op.keymgmt.genctx,
168                                  ossl_callback_to_pkey_gencb, ctx)
169             != NULL);
170
171 #ifndef FIPS_MODE
172     /* In case |*ppkey| was originally a legacy key */
173     if (ret)
174         evp_pkey_free_legacy(*ppkey);
175 #endif
176
177     goto end;
178
179  legacy:
180 #ifdef FIPS_MODE
181     goto not_supported;
182 #else
183     if (ctx->pkey && !evp_pkey_downgrade(ctx->pkey))
184         goto not_accessible;
185     switch (ctx->operation) {
186     case EVP_PKEY_OP_PARAMGEN:
187         ret = ctx->pmeth->paramgen(ctx, *ppkey);
188         break;
189     case EVP_PKEY_OP_KEYGEN:
190         ret = ctx->pmeth->keygen(ctx, *ppkey);
191         break;
192     default:
193         goto not_supported;
194     }
195 #endif
196
197  end:
198     if (ret <= 0) {
199         if (allocated_pkey != NULL)
200             *ppkey = NULL;
201         EVP_PKEY_free(allocated_pkey);
202     }
203     return ret;
204
205  not_supported:
206     ERR_raise(ERR_LIB_EVP, EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
207     ret = -2;
208     goto end;
209  not_initialized:
210     ERR_raise(ERR_LIB_EVP, EVP_R_OPERATON_NOT_INITIALIZED);
211     ret = -1;
212     goto end;
213 #ifndef FIPS_MODE
214  not_accessible:
215     ERR_raise(ERR_LIB_EVP, EVP_R_INACCESSIBLE_DOMAIN_PARAMETERS);
216     ret = -1;
217     goto end;
218 #endif
219 }
220
221 int EVP_PKEY_paramgen(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey)
222 {
223     if (ctx->operation != EVP_PKEY_OP_PARAMGEN) {
224         ERR_raise(ERR_LIB_EVP, EVP_R_OPERATON_NOT_INITIALIZED);
225         return -1;
226     }
227     return EVP_PKEY_gen(ctx, ppkey);
228 }
229
230 int EVP_PKEY_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey)
231 {
232     if (ctx->operation != EVP_PKEY_OP_KEYGEN) {
233         ERR_raise(ERR_LIB_EVP, EVP_R_OPERATON_NOT_INITIALIZED);
234         return -1;
235     }
236     return EVP_PKEY_gen(ctx, ppkey);
237 }
238
239 void EVP_PKEY_CTX_set_cb(EVP_PKEY_CTX *ctx, EVP_PKEY_gen_cb *cb)
240 {
241     ctx->pkey_gencb = cb;
242 }
243
244 EVP_PKEY_gen_cb *EVP_PKEY_CTX_get_cb(EVP_PKEY_CTX *ctx)
245 {
246     return ctx->pkey_gencb;
247 }
248
249 /*
250  * "translation callback" to call EVP_PKEY_CTX callbacks using BN_GENCB style
251  * callbacks.
252  */
253
254 static int trans_cb(int a, int b, BN_GENCB *gcb)
255 {
256     EVP_PKEY_CTX *ctx = BN_GENCB_get_arg(gcb);
257     ctx->keygen_info[0] = a;
258     ctx->keygen_info[1] = b;
259     return ctx->pkey_gencb(ctx);
260 }
261
262 void evp_pkey_set_cb_translate(BN_GENCB *cb, EVP_PKEY_CTX *ctx)
263 {
264     BN_GENCB_set(cb, trans_cb, ctx);
265 }
266
267 int EVP_PKEY_CTX_get_keygen_info(EVP_PKEY_CTX *ctx, int idx)
268 {
269     if (idx == -1)
270         return ctx->keygen_info_count;
271     if (idx < 0 || idx > ctx->keygen_info_count)
272         return 0;
273     return ctx->keygen_info[idx];
274 }
275
276 #ifndef FIPS_MODE
277
278 EVP_PKEY *EVP_PKEY_new_mac_key(int type, ENGINE *e,
279                                const unsigned char *key, int keylen)
280 {
281     EVP_PKEY_CTX *mac_ctx = NULL;
282     EVP_PKEY *mac_key = NULL;
283     mac_ctx = EVP_PKEY_CTX_new_id(type, e);
284     if (!mac_ctx)
285         return NULL;
286     if (EVP_PKEY_keygen_init(mac_ctx) <= 0)
287         goto merr;
288     if (EVP_PKEY_CTX_set_mac_key(mac_ctx, key, keylen) <= 0)
289         goto merr;
290     if (EVP_PKEY_keygen(mac_ctx, &mac_key) <= 0)
291         goto merr;
292  merr:
293     EVP_PKEY_CTX_free(mac_ctx);
294     return mac_key;
295 }
296
297 #endif /* FIPS_MODE */
298
299 /*- All methods below can also be used in FIPS_MODE */
300
301 static int fromdata_init(EVP_PKEY_CTX *ctx, int operation)
302 {
303     if (ctx == NULL || ctx->keytype == NULL)
304         goto not_supported;
305
306     evp_pkey_ctx_free_old_ops(ctx);
307     if (ctx->keymgmt == NULL)
308         goto not_supported;
309
310     ctx->operation = operation;
311     return 1;
312
313  not_supported:
314     ctx->operation = EVP_PKEY_OP_UNDEFINED;
315     ERR_raise(ERR_LIB_EVP, EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
316     return -2;
317 }
318
319 int EVP_PKEY_param_fromdata_init(EVP_PKEY_CTX *ctx)
320 {
321     return fromdata_init(ctx, EVP_PKEY_OP_PARAMFROMDATA);
322 }
323
324 int EVP_PKEY_key_fromdata_init(EVP_PKEY_CTX *ctx)
325 {
326     return fromdata_init(ctx, EVP_PKEY_OP_KEYFROMDATA);
327 }
328
329 int EVP_PKEY_fromdata(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey, OSSL_PARAM params[])
330 {
331     void *keydata = NULL;
332     int selection;
333
334     if (ctx == NULL || (ctx->operation & EVP_PKEY_OP_TYPE_FROMDATA) == 0) {
335         ERR_raise(ERR_LIB_EVP, EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
336         return -2;
337     }
338
339     if (ppkey == NULL)
340         return -1;
341
342     if (*ppkey == NULL)
343         *ppkey = EVP_PKEY_new();
344
345     if (*ppkey == NULL) {
346         ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
347         return -1;
348     }
349
350     if (ctx->operation == EVP_PKEY_OP_PARAMFROMDATA)
351         selection = OSSL_KEYMGMT_SELECT_ALL_PARAMETERS;
352     else
353         selection = OSSL_KEYMGMT_SELECT_ALL;
354     keydata = evp_keymgmt_util_fromdata(*ppkey, ctx->keymgmt, selection,
355                                         params);
356
357     if (keydata == NULL)
358         return 0;
359     /* keydata is cached in *ppkey, so we need not bother with it further */
360     return 1;
361 }
362
363 /*
364  * TODO(3.0) Re-evaluate the names, it's possible that we find these to be
365  * better:
366  *
367  * EVP_PKEY_param_settable()
368  * EVP_PKEY_param_gettable()
369  */
370 const OSSL_PARAM *EVP_PKEY_param_fromdata_settable(EVP_PKEY_CTX *ctx)
371 {
372     /* We call fromdata_init to get ctx->keymgmt populated */
373     if (fromdata_init(ctx, EVP_PKEY_OP_UNDEFINED))
374         return evp_keymgmt_import_types(ctx->keymgmt,
375                                         OSSL_KEYMGMT_SELECT_ALL_PARAMETERS);
376     return NULL;
377 }
378
379 const OSSL_PARAM *EVP_PKEY_key_fromdata_settable(EVP_PKEY_CTX *ctx)
380 {
381     /* We call fromdata_init to get ctx->keymgmt populated */
382     if (fromdata_init(ctx, EVP_PKEY_OP_UNDEFINED))
383         return evp_keymgmt_import_types(ctx->keymgmt,
384                                         OSSL_KEYMGMT_SELECT_ALL);
385     return NULL;
386 }