34cde676681e918a8136d2662488f4a9a8a39570
[openssl.git] / crypto / evp / pmeth_fn.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/objects.h>
13 #include <openssl/evp.h>
14 #include "internal/cryptlib.h"
15 #include "crypto/evp.h"
16 #include "internal/provider.h"
17 #include "evp_local.h"
18
19 static int evp_pkey_asym_cipher_init(EVP_PKEY_CTX *ctx, int operation)
20 {
21     int ret = 0;
22     void *provkey = NULL;
23     EVP_ASYM_CIPHER *cipher = NULL;
24     EVP_KEYMGMT *tmp_keymgmt = NULL;
25     const char *supported_ciph = NULL;
26
27     if (ctx == NULL) {
28         EVPerr(0, EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
29         return -2;
30     }
31
32     evp_pkey_ctx_free_old_ops(ctx);
33     ctx->operation = operation;
34
35     /*
36      * TODO when we stop falling back to legacy, this and the ERR_pop_to_mark()
37      * calls can be removed.
38      */
39     ERR_set_mark();
40
41     if (ctx->keytype == NULL || ctx->engine != NULL)
42         goto legacy;
43
44     /* Ensure that the key is provided.  If not, go legacy */
45     tmp_keymgmt = ctx->keymgmt;
46     provkey = evp_pkey_make_provided(ctx->pkey, ctx->libctx,
47                                      &tmp_keymgmt, ctx->propquery, 0);
48     if (provkey == NULL)
49         goto legacy;
50     if (!EVP_KEYMGMT_up_ref(tmp_keymgmt)) {
51         ERR_clear_last_mark();
52         ERR_raise(ERR_LIB_EVP, EVP_R_INITIALIZATION_ERROR);
53         goto err;
54     }
55     EVP_KEYMGMT_free(ctx->keymgmt);
56     ctx->keymgmt = tmp_keymgmt;
57
58     if (ctx->keymgmt->query_operation_name != NULL)
59         supported_ciph =
60             ctx->keymgmt->query_operation_name(OSSL_OP_ASYM_CIPHER);
61
62     /*
63      * If we didn't get a supported ciph, assume there is one with the
64      * same name as the key type.
65      */
66     if (supported_ciph == NULL)
67         supported_ciph = ctx->keytype;
68
69     /*
70      * Because we cleared out old ops, we shouldn't need to worry about
71      * checking if cipher is already there.
72      */
73     cipher =
74         EVP_ASYM_CIPHER_fetch(ctx->libctx, supported_ciph, ctx->propquery);
75
76     if (cipher == NULL
77         || (EVP_KEYMGMT_provider(ctx->keymgmt)
78             != EVP_ASYM_CIPHER_provider(cipher))) {
79         /*
80          * We don't need to free ctx->keymgmt here, as it's not necessarily
81          * tied to this operation.  It will be freed by EVP_PKEY_CTX_free().
82          */
83         EVP_ASYM_CIPHER_free(cipher);
84         goto legacy;
85     }
86
87     /*
88      * TODO remove this when legacy is gone
89      * If we don't have the full support we need with provided methods,
90      * let's go see if legacy does.
91      */
92     ERR_pop_to_mark();
93
94     /* No more legacy from here down to legacy: */
95
96     ctx->op.ciph.cipher = cipher;
97     ctx->op.ciph.ciphprovctx = cipher->newctx(ossl_provider_ctx(cipher->prov));
98     if (ctx->op.ciph.ciphprovctx == NULL) {
99         /* The provider key can stay in the cache */
100         EVPerr(0, EVP_R_INITIALIZATION_ERROR);
101         goto err;
102     }
103
104     switch (operation) {
105     case EVP_PKEY_OP_ENCRYPT:
106         if (cipher->encrypt_init == NULL) {
107             EVPerr(0, EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
108             ret = -2;
109             goto err;
110         }
111         ret = cipher->encrypt_init(ctx->op.ciph.ciphprovctx, provkey);
112         break;
113     case EVP_PKEY_OP_DECRYPT:
114         if (cipher->decrypt_init == NULL) {
115             EVPerr(0, EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
116             ret = -2;
117             goto err;
118         }
119         ret = cipher->decrypt_init(ctx->op.ciph.ciphprovctx, provkey);
120         break;
121     default:
122         EVPerr(0, EVP_R_INITIALIZATION_ERROR);
123         goto err;
124     }
125
126     if (ret <= 0) {
127         cipher->freectx(ctx->op.ciph.ciphprovctx);
128         ctx->op.ciph.ciphprovctx = NULL;
129         goto err;
130     }
131     return 1;
132
133  legacy:
134     /*
135      * TODO remove this when legacy is gone
136      * If we don't have the full support we need with provided methods,
137      * let's go see if legacy does.
138      */
139     ERR_pop_to_mark();
140
141     if (ctx->pmeth == NULL || ctx->pmeth->encrypt == NULL) {
142         EVPerr(0, EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
143         return -2;
144     }
145     switch(ctx->operation) {
146     case EVP_PKEY_OP_ENCRYPT:
147         if (ctx->pmeth->encrypt_init == NULL)
148             return 1;
149         ret = ctx->pmeth->encrypt_init(ctx);
150         break;
151     case EVP_PKEY_OP_DECRYPT:
152         if (ctx->pmeth->decrypt_init == NULL)
153             return 1;
154         ret = ctx->pmeth->decrypt_init(ctx);
155         break;
156     default:
157         EVPerr(0, EVP_R_INITIALIZATION_ERROR);
158         ret = -1;
159     }
160
161  err:
162     if (ret <= 0)
163         ctx->operation = EVP_PKEY_OP_UNDEFINED;
164     return ret;
165 }
166
167 int EVP_PKEY_encrypt_init(EVP_PKEY_CTX *ctx)
168 {
169     return evp_pkey_asym_cipher_init(ctx, EVP_PKEY_OP_ENCRYPT);
170 }
171
172 int EVP_PKEY_encrypt(EVP_PKEY_CTX *ctx,
173                      unsigned char *out, size_t *outlen,
174                      const unsigned char *in, size_t inlen)
175 {
176     int ret;
177
178     if (ctx == NULL) {
179         EVPerr(0, EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
180         return -2;
181     }
182
183     if (ctx->operation != EVP_PKEY_OP_ENCRYPT) {
184         EVPerr(0, EVP_R_OPERATON_NOT_INITIALIZED);
185         return -1;
186     }
187
188     if (ctx->op.ciph.ciphprovctx == NULL)
189         goto legacy;
190
191     ret = ctx->op.ciph.cipher->encrypt(ctx->op.ciph.ciphprovctx, out, outlen,
192                                        (out == NULL ? 0 : *outlen), in, inlen);
193     return ret;
194
195  legacy:
196     if (ctx->pmeth == NULL || ctx->pmeth->encrypt == NULL) {
197         EVPerr(EVP_F_EVP_PKEY_ENCRYPT,
198                EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
199         return -2;
200     }
201     M_check_autoarg(ctx, out, outlen, EVP_F_EVP_PKEY_ENCRYPT)
202         return ctx->pmeth->encrypt(ctx, out, outlen, in, inlen);
203 }
204
205 int EVP_PKEY_decrypt_init(EVP_PKEY_CTX *ctx)
206 {
207     return evp_pkey_asym_cipher_init(ctx, EVP_PKEY_OP_DECRYPT);
208 }
209
210 int EVP_PKEY_decrypt(EVP_PKEY_CTX *ctx,
211                      unsigned char *out, size_t *outlen,
212                      const unsigned char *in, size_t inlen)
213 {
214     int ret;
215
216     if (ctx == NULL) {
217         EVPerr(0, EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
218         return -2;
219     }
220
221     if (ctx->operation != EVP_PKEY_OP_DECRYPT) {
222         EVPerr(0, EVP_R_OPERATON_NOT_INITIALIZED);
223         return -1;
224     }
225
226     if (ctx->op.ciph.ciphprovctx == NULL)
227         goto legacy;
228
229     ret = ctx->op.ciph.cipher->decrypt(ctx->op.ciph.ciphprovctx, out, outlen,
230                                        (out == NULL ? 0 : *outlen), in, inlen);
231     return ret;
232
233  legacy:
234     if (ctx->pmeth == NULL || ctx->pmeth->decrypt == NULL) {
235         EVPerr(EVP_F_EVP_PKEY_DECRYPT,
236                EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
237         return -2;
238     }
239     M_check_autoarg(ctx, out, outlen, EVP_F_EVP_PKEY_DECRYPT)
240         return ctx->pmeth->decrypt(ctx, out, outlen, in, inlen);
241 }
242
243
244 static EVP_ASYM_CIPHER *evp_asym_cipher_new(OSSL_PROVIDER *prov)
245 {
246     EVP_ASYM_CIPHER *cipher = OPENSSL_zalloc(sizeof(EVP_ASYM_CIPHER));
247
248     if (cipher == NULL) {
249         ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
250         return NULL;
251     }
252
253     cipher->lock = CRYPTO_THREAD_lock_new();
254     if (cipher->lock == NULL) {
255         ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
256         OPENSSL_free(cipher);
257         return NULL;
258     }
259     cipher->prov = prov;
260     ossl_provider_up_ref(prov);
261     cipher->refcnt = 1;
262
263     return cipher;
264 }
265
266 static void *evp_asym_cipher_from_dispatch(int name_id,
267                                            const OSSL_DISPATCH *fns,
268                                            OSSL_PROVIDER *prov)
269 {
270     EVP_ASYM_CIPHER *cipher = NULL;
271     int ctxfncnt = 0, encfncnt = 0, decfncnt = 0;
272     int gparamfncnt = 0, sparamfncnt = 0;
273
274     if ((cipher = evp_asym_cipher_new(prov)) == NULL) {
275         ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
276         goto err;
277     }
278
279     cipher->name_id = name_id;
280
281     for (; fns->function_id != 0; fns++) {
282         switch (fns->function_id) {
283         case OSSL_FUNC_ASYM_CIPHER_NEWCTX:
284             if (cipher->newctx != NULL)
285                 break;
286             cipher->newctx = OSSL_get_OP_asym_cipher_newctx(fns);
287             ctxfncnt++;
288             break;
289         case OSSL_FUNC_ASYM_CIPHER_ENCRYPT_INIT:
290             if (cipher->encrypt_init != NULL)
291                 break;
292             cipher->encrypt_init = OSSL_get_OP_asym_cipher_encrypt_init(fns);
293             encfncnt++;
294             break;
295         case OSSL_FUNC_ASYM_CIPHER_ENCRYPT:
296             if (cipher->encrypt != NULL)
297                 break;
298             cipher->encrypt = OSSL_get_OP_asym_cipher_encrypt(fns);
299             encfncnt++;
300             break;
301         case OSSL_FUNC_ASYM_CIPHER_DECRYPT_INIT:
302             if (cipher->decrypt_init != NULL)
303                 break;
304             cipher->decrypt_init = OSSL_get_OP_asym_cipher_decrypt_init(fns);
305             decfncnt++;
306             break;
307         case OSSL_FUNC_ASYM_CIPHER_DECRYPT:
308             if (cipher->decrypt != NULL)
309                 break;
310             cipher->decrypt = OSSL_get_OP_asym_cipher_decrypt(fns);
311             decfncnt++;
312             break;
313         case OSSL_FUNC_ASYM_CIPHER_FREECTX:
314             if (cipher->freectx != NULL)
315                 break;
316             cipher->freectx = OSSL_get_OP_asym_cipher_freectx(fns);
317             ctxfncnt++;
318             break;
319         case OSSL_FUNC_ASYM_CIPHER_DUPCTX:
320             if (cipher->dupctx != NULL)
321                 break;
322             cipher->dupctx = OSSL_get_OP_asym_cipher_dupctx(fns);
323             break;
324         case OSSL_FUNC_ASYM_CIPHER_GET_CTX_PARAMS:
325             if (cipher->get_ctx_params != NULL)
326                 break;
327             cipher->get_ctx_params
328                 = OSSL_get_OP_asym_cipher_get_ctx_params(fns);
329             gparamfncnt++;
330             break;
331         case OSSL_FUNC_ASYM_CIPHER_GETTABLE_CTX_PARAMS:
332             if (cipher->gettable_ctx_params != NULL)
333                 break;
334             cipher->gettable_ctx_params
335                 = OSSL_get_OP_asym_cipher_gettable_ctx_params(fns);
336             gparamfncnt++;
337             break;
338         case OSSL_FUNC_ASYM_CIPHER_SET_CTX_PARAMS:
339             if (cipher->set_ctx_params != NULL)
340                 break;
341             cipher->set_ctx_params
342                 = OSSL_get_OP_asym_cipher_set_ctx_params(fns);
343             sparamfncnt++;
344             break;
345         case OSSL_FUNC_ASYM_CIPHER_SETTABLE_CTX_PARAMS:
346             if (cipher->settable_ctx_params != NULL)
347                 break;
348             cipher->settable_ctx_params
349                 = OSSL_get_OP_asym_cipher_settable_ctx_params(fns);
350             sparamfncnt++;
351             break;
352         }
353     }
354     if (ctxfncnt != 2
355         || (encfncnt != 0 && encfncnt != 2)
356         || (decfncnt != 0 && decfncnt != 2)
357         || (encfncnt != 2 && decfncnt != 2)
358         || (gparamfncnt != 0 && gparamfncnt != 2)
359         || (sparamfncnt != 0 && sparamfncnt != 2)) {
360         /*
361          * In order to be a consistent set of functions we must have at least
362          * a set of context functions (newctx and freectx) as well as a pair of
363          * "cipher" functions: (encrypt_init, encrypt) or
364          * (decrypt_init decrypt). set_ctx_params and settable_ctx_params are
365          * optional, but if one of them is present then the other one must also
366          * be present. The same applies to get_ctx_params and
367          * gettable_ctx_params. The dupctx function is optional.
368          */
369         ERR_raise(ERR_LIB_EVP, EVP_R_INVALID_PROVIDER_FUNCTIONS);
370         goto err;
371     }
372
373     return cipher;
374  err:
375     EVP_ASYM_CIPHER_free(cipher);
376     return NULL;
377 }
378
379 void EVP_ASYM_CIPHER_free(EVP_ASYM_CIPHER *cipher)
380 {
381     if (cipher != NULL) {
382         int i;
383
384         CRYPTO_DOWN_REF(&cipher->refcnt, &i, cipher->lock);
385         if (i > 0)
386             return;
387         ossl_provider_free(cipher->prov);
388         CRYPTO_THREAD_lock_free(cipher->lock);
389         OPENSSL_free(cipher);
390     }
391 }
392
393 int EVP_ASYM_CIPHER_up_ref(EVP_ASYM_CIPHER *cipher)
394 {
395     int ref = 0;
396
397     CRYPTO_UP_REF(&cipher->refcnt, &ref, cipher->lock);
398     return 1;
399 }
400
401 OSSL_PROVIDER *EVP_ASYM_CIPHER_provider(const EVP_ASYM_CIPHER *cipher)
402 {
403     return cipher->prov;
404 }
405
406 EVP_ASYM_CIPHER *EVP_ASYM_CIPHER_fetch(OPENSSL_CTX *ctx, const char *algorithm,
407                                        const char *properties)
408 {
409     return evp_generic_fetch(ctx, OSSL_OP_ASYM_CIPHER, algorithm, properties,
410                              evp_asym_cipher_from_dispatch,
411                              (int (*)(void *))EVP_ASYM_CIPHER_up_ref,
412                              (void (*)(void *))EVP_ASYM_CIPHER_free);
413 }
414
415 int EVP_ASYM_CIPHER_is_a(const EVP_ASYM_CIPHER *cipher, const char *name)
416 {
417     return evp_is_a(cipher->prov, cipher->name_id, NULL, name);
418 }
419
420 int EVP_ASYM_CIPHER_number(const EVP_ASYM_CIPHER *cipher)
421 {
422     return cipher->name_id;
423 }
424
425 void EVP_ASYM_CIPHER_do_all_provided(OPENSSL_CTX *libctx,
426                                      void (*fn)(EVP_ASYM_CIPHER *cipher,
427                                                 void *arg),
428                                      void *arg)
429 {
430     evp_generic_do_all(libctx, OSSL_OP_ASYM_CIPHER,
431                        (void (*)(void *, void *))fn, arg,
432                        evp_asym_cipher_from_dispatch,
433                        (void (*)(void *))EVP_ASYM_CIPHER_free);
434 }
435
436
437 void EVP_ASYM_CIPHER_names_do_all(const EVP_ASYM_CIPHER *cipher,
438                                   void (*fn)(const char *name, void *data),
439                                   void *data)
440 {
441     if (cipher->prov != NULL)
442         evp_names_do_all(cipher->prov, cipher->name_id, fn, data);
443 }
444