Enc doesn't support AEAD ciphers.
[openssl.git] / crypto / evp / pmeth_lib.c
1 /* pmeth_lib.c */
2 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
3  * project 2006.
4  */
5 /* ====================================================================
6  * Copyright (c) 2006 The OpenSSL Project.  All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  *
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer. 
14  *
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in
17  *    the documentation and/or other materials provided with the
18  *    distribution.
19  *
20  * 3. All advertising materials mentioning features or use of this
21  *    software must display the following acknowledgment:
22  *    "This product includes software developed by the OpenSSL Project
23  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
24  *
25  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
26  *    endorse or promote products derived from this software without
27  *    prior written permission. For written permission, please contact
28  *    licensing@OpenSSL.org.
29  *
30  * 5. Products derived from this software may not be called "OpenSSL"
31  *    nor may "OpenSSL" appear in their names without prior written
32  *    permission of the OpenSSL Project.
33  *
34  * 6. Redistributions of any form whatsoever must retain the following
35  *    acknowledgment:
36  *    "This product includes software developed by the OpenSSL Project
37  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
38  *
39  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
40  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
41  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
42  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
43  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
44  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
45  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
46  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
48  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
49  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
50  * OF THE POSSIBILITY OF SUCH DAMAGE.
51  * ====================================================================
52  *
53  * This product includes cryptographic software written by Eric Young
54  * (eay@cryptsoft.com).  This product includes software written by Tim
55  * Hudson (tjh@cryptsoft.com).
56  *
57  */
58
59 #include <stdio.h>
60 #include <stdlib.h>
61 #include "cryptlib.h"
62 #include <openssl/objects.h>
63 #include <openssl/evp.h>
64 #ifndef OPENSSL_NO_ENGINE
65 #include <openssl/engine.h>
66 #endif
67 #include "asn1_locl.h"
68 #include "evp_locl.h"
69
70 typedef int sk_cmp_fn_type(const char * const *a, const char * const *b);
71
72 DECLARE_STACK_OF(EVP_PKEY_METHOD)
73 STACK_OF(EVP_PKEY_METHOD) *app_pkey_methods = NULL;
74
75 extern const EVP_PKEY_METHOD rsa_pkey_meth, dh_pkey_meth, dsa_pkey_meth;
76 extern const EVP_PKEY_METHOD ec_pkey_meth, hmac_pkey_meth, cmac_pkey_meth;
77 extern const EVP_PKEY_METHOD dhx_pkey_meth;
78
79 static const EVP_PKEY_METHOD *standard_methods[] =
80         {
81 #ifndef OPENSSL_NO_RSA
82         &rsa_pkey_meth,
83 #endif
84 #ifndef OPENSSL_NO_DH
85         &dh_pkey_meth,
86 #endif
87 #ifndef OPENSSL_NO_DSA
88         &dsa_pkey_meth,
89 #endif
90 #ifndef OPENSSL_NO_EC
91         &ec_pkey_meth,
92 #endif
93         &hmac_pkey_meth,
94         &cmac_pkey_meth,
95 #ifndef OPENSSL_NO_DH
96         &dhx_pkey_meth
97 #endif
98         };
99
100 DECLARE_OBJ_BSEARCH_CMP_FN(const EVP_PKEY_METHOD *, const EVP_PKEY_METHOD *,
101                            pmeth);
102
103 static int pmeth_cmp(const EVP_PKEY_METHOD * const *a,
104                      const EVP_PKEY_METHOD * const *b)
105         {
106         return ((*a)->pkey_id - (*b)->pkey_id);
107         }
108
109 IMPLEMENT_OBJ_BSEARCH_CMP_FN(const EVP_PKEY_METHOD *, const EVP_PKEY_METHOD *,
110                              pmeth);
111
112 const EVP_PKEY_METHOD *EVP_PKEY_meth_find(int type)
113         {
114         EVP_PKEY_METHOD tmp;
115         const EVP_PKEY_METHOD *t = &tmp, **ret;
116         tmp.pkey_id = type;
117         if (app_pkey_methods)
118                 {
119                 int idx;
120                 idx = sk_EVP_PKEY_METHOD_find(app_pkey_methods, &tmp);
121                 if (idx >= 0)
122                         return sk_EVP_PKEY_METHOD_value(app_pkey_methods, idx);
123                 }
124         ret = OBJ_bsearch_pmeth(&t, standard_methods,
125                           sizeof(standard_methods)/sizeof(EVP_PKEY_METHOD *));
126         if (!ret || !*ret)
127                 return NULL;
128         return *ret;
129         }
130
131 static EVP_PKEY_CTX *int_ctx_new(EVP_PKEY *pkey, ENGINE *e, int id)
132         {
133         EVP_PKEY_CTX *ret;
134         const EVP_PKEY_METHOD *pmeth;
135         if (id == -1)
136                 {
137                 if (!pkey || !pkey->ameth)
138                         return NULL;
139                 id = pkey->ameth->pkey_id;
140                 }
141 #ifndef OPENSSL_NO_ENGINE
142         if (pkey && pkey->engine)
143                 e = pkey->engine;
144         /* Try to find an ENGINE which implements this method */
145         if (e)
146                 {
147                 if (!ENGINE_init(e))
148                         {
149                         EVPerr(EVP_F_INT_CTX_NEW,ERR_R_ENGINE_LIB);
150                         return NULL;
151                         }
152                 }
153         else
154                 e = ENGINE_get_pkey_meth_engine(id);
155
156         /* If an ENGINE handled this method look it up. Othewise
157          * use internal tables.
158          */
159
160         if (e)
161                 pmeth = ENGINE_get_pkey_meth(e, id);
162         else
163 #endif
164                 pmeth = EVP_PKEY_meth_find(id);
165
166         if (pmeth == NULL)
167                 {
168                 EVPerr(EVP_F_INT_CTX_NEW,EVP_R_UNSUPPORTED_ALGORITHM);
169                 return NULL;
170                 }
171
172         ret = OPENSSL_malloc(sizeof(EVP_PKEY_CTX));
173         if (!ret)
174                 {
175 #ifndef OPENSSL_NO_ENGINE
176                 if (e)
177                         ENGINE_finish(e);
178 #endif
179                 EVPerr(EVP_F_INT_CTX_NEW,ERR_R_MALLOC_FAILURE);
180                 return NULL;
181                 }
182         ret->engine = e;
183         ret->pmeth = pmeth;
184         ret->operation = EVP_PKEY_OP_UNDEFINED;
185         ret->pkey = pkey;
186         ret->peerkey = NULL;
187         ret->pkey_gencb = 0;
188         if (pkey)
189                 CRYPTO_add(&pkey->references,1,CRYPTO_LOCK_EVP_PKEY);
190         ret->data = NULL;
191
192         if (pmeth->init)
193                 {
194                 if (pmeth->init(ret) <= 0)
195                         {
196                         EVP_PKEY_CTX_free(ret);
197                         return NULL;
198                         }
199                 }
200
201         return ret;
202         }
203
204 EVP_PKEY_METHOD* EVP_PKEY_meth_new(int id, int flags)
205         {
206         EVP_PKEY_METHOD *pmeth;
207         pmeth = OPENSSL_malloc(sizeof(EVP_PKEY_METHOD));
208         if (!pmeth)
209                 return NULL;
210
211         memset(pmeth, 0, sizeof(EVP_PKEY_METHOD));
212
213         pmeth->pkey_id = id;
214         pmeth->flags = flags | EVP_PKEY_FLAG_DYNAMIC;
215
216         pmeth->init = 0;
217         pmeth->copy = 0;
218         pmeth->cleanup = 0;
219         pmeth->paramgen_init = 0;
220         pmeth->paramgen = 0;
221         pmeth->keygen_init = 0;
222         pmeth->keygen = 0;
223         pmeth->sign_init = 0;
224         pmeth->sign = 0;
225         pmeth->verify_init = 0;
226         pmeth->verify = 0;
227         pmeth->verify_recover_init = 0;
228         pmeth->verify_recover = 0;
229         pmeth->signctx_init = 0;
230         pmeth->signctx = 0;
231         pmeth->verifyctx_init = 0;
232         pmeth->verifyctx = 0;
233         pmeth->encrypt_init = 0;
234         pmeth->encrypt = 0;
235         pmeth->decrypt_init = 0;
236         pmeth->decrypt = 0;
237         pmeth->derive_init = 0;
238         pmeth->derive = 0;
239         pmeth->ctrl = 0;
240         pmeth->ctrl_str = 0;
241
242         return pmeth;
243         }
244
245 void EVP_PKEY_meth_get0_info(int *ppkey_id, int *pflags,
246                                 const EVP_PKEY_METHOD *meth)
247         {
248         if (ppkey_id)
249                 *ppkey_id = meth->pkey_id;
250         if (pflags)
251                 *pflags = meth->flags;
252         }
253
254 void EVP_PKEY_meth_copy(EVP_PKEY_METHOD *dst, const EVP_PKEY_METHOD *src)
255         {
256
257         dst->init = src->init;
258         dst->copy = src->copy;
259         dst->cleanup = src->cleanup;
260
261         dst->paramgen_init = src->paramgen_init;
262         dst->paramgen = src->paramgen;
263
264         dst->keygen_init = src->keygen_init;
265         dst->keygen = src->keygen;
266
267         dst->sign_init = src->sign_init;
268         dst->sign = src->sign;
269
270         dst->verify_init = src->verify_init;
271         dst->verify = src->verify;
272
273         dst->verify_recover_init = src->verify_recover_init;
274         dst->verify_recover = src->verify_recover;
275
276         dst->signctx_init = src->signctx_init;
277         dst->signctx = src->signctx;
278
279         dst->verifyctx_init = src->verifyctx_init;
280         dst->verifyctx = src->verifyctx;
281
282         dst->encrypt_init = src->encrypt_init;
283         dst->encrypt = src->encrypt;
284
285         dst->decrypt_init = src->decrypt_init;
286         dst->decrypt = src->decrypt;
287
288         dst->derive_init = src->derive_init;
289         dst->derive = src->derive;
290
291         dst->ctrl = src->ctrl;
292         dst->ctrl_str = src->ctrl_str;
293         }
294
295 void EVP_PKEY_meth_free(EVP_PKEY_METHOD *pmeth)
296         {
297         if (pmeth && (pmeth->flags & EVP_PKEY_FLAG_DYNAMIC))
298                 OPENSSL_free(pmeth);
299         }
300
301 EVP_PKEY_CTX *EVP_PKEY_CTX_new(EVP_PKEY *pkey, ENGINE *e)
302         {
303         return int_ctx_new(pkey, e, -1);
304         }
305
306 EVP_PKEY_CTX *EVP_PKEY_CTX_new_id(int id, ENGINE *e)
307         {
308         return int_ctx_new(NULL, e, id);
309         }
310
311 EVP_PKEY_CTX *EVP_PKEY_CTX_dup(EVP_PKEY_CTX *pctx)
312         {
313         EVP_PKEY_CTX *rctx;
314         if (!pctx->pmeth || !pctx->pmeth->copy)
315                 return NULL;
316 #ifndef OPENSSL_NO_ENGINE
317         /* Make sure it's safe to copy a pkey context using an ENGINE */
318         if (pctx->engine && !ENGINE_init(pctx->engine))
319                 {
320                 EVPerr(EVP_F_EVP_PKEY_CTX_DUP,ERR_R_ENGINE_LIB);
321                 return 0;
322                 }
323 #endif
324         rctx = OPENSSL_malloc(sizeof(EVP_PKEY_CTX));
325         if (!rctx)
326                 return NULL;
327
328         rctx->pmeth = pctx->pmeth;
329 #ifndef OPENSSL_NO_ENGINE
330         rctx->engine = pctx->engine;
331 #endif
332
333         if (pctx->pkey)
334                 CRYPTO_add(&pctx->pkey->references,1,CRYPTO_LOCK_EVP_PKEY);
335
336         rctx->pkey = pctx->pkey;
337
338         if (pctx->peerkey)
339                 CRYPTO_add(&pctx->peerkey->references,1,CRYPTO_LOCK_EVP_PKEY);
340
341         rctx->peerkey = pctx->peerkey;
342
343         rctx->data = NULL;
344         rctx->app_data = NULL;
345         rctx->operation = pctx->operation;
346
347         if (pctx->pmeth->copy(rctx, pctx) > 0)
348                 return rctx;
349
350         EVP_PKEY_CTX_free(rctx);
351         return NULL;
352
353         }
354
355 int EVP_PKEY_meth_add0(const EVP_PKEY_METHOD *pmeth)
356         {
357         if (app_pkey_methods == NULL)
358                 {
359                 app_pkey_methods = sk_EVP_PKEY_METHOD_new(pmeth_cmp);
360                 if (!app_pkey_methods)
361                         return 0;
362                 }
363         if (!sk_EVP_PKEY_METHOD_push(app_pkey_methods, pmeth))
364                 return 0;
365         sk_EVP_PKEY_METHOD_sort(app_pkey_methods);
366         return 1;
367         }
368
369 void EVP_PKEY_CTX_free(EVP_PKEY_CTX *ctx)
370         {
371         if (ctx == NULL)
372                 return;
373         if (ctx->pmeth && ctx->pmeth->cleanup)
374                 ctx->pmeth->cleanup(ctx);
375         if (ctx->pkey)
376                 EVP_PKEY_free(ctx->pkey);
377         if (ctx->peerkey)
378                 EVP_PKEY_free(ctx->peerkey);
379 #ifndef OPENSSL_NO_ENGINE
380         if(ctx->engine)
381                 /* The EVP_PKEY_CTX we used belongs to an ENGINE, release the
382                  * functional reference we held for this reason. */
383                 ENGINE_finish(ctx->engine);
384 #endif
385         OPENSSL_free(ctx);
386         }
387
388 int EVP_PKEY_CTX_ctrl(EVP_PKEY_CTX *ctx, int keytype, int optype,
389                                 int cmd, int p1, void *p2)
390         {
391         int ret;
392         if (!ctx || !ctx->pmeth || !ctx->pmeth->ctrl)
393                 {
394                 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_COMMAND_NOT_SUPPORTED);
395                 return -2;
396                 }
397         if ((keytype != -1) && (ctx->pmeth->pkey_id != keytype))
398                 return -1;
399
400         if (ctx->operation == EVP_PKEY_OP_UNDEFINED)
401                 {
402                 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_NO_OPERATION_SET);
403                 return -1;
404                 }
405
406         if ((optype != -1) && !(ctx->operation & optype))
407                 {
408                 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_INVALID_OPERATION);
409                 return -1;
410                 }
411
412         ret = ctx->pmeth->ctrl(ctx, cmd, p1, p2);
413
414         if (ret == -2)
415                 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_COMMAND_NOT_SUPPORTED);
416
417         return ret;
418
419         }
420
421 int EVP_PKEY_CTX_ctrl_str(EVP_PKEY_CTX *ctx,
422                                         const char *name, const char *value)
423         {
424         if (!ctx || !ctx->pmeth || !ctx->pmeth->ctrl_str)
425                 {
426                 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL_STR,
427                                                 EVP_R_COMMAND_NOT_SUPPORTED);
428                 return -2;
429                 }
430         if (!strcmp(name, "digest"))
431                 {
432                 const EVP_MD *md;
433                 if (!value || !(md = EVP_get_digestbyname(value)))
434                         {
435                         EVPerr(EVP_F_EVP_PKEY_CTX_CTRL_STR,
436                                                 EVP_R_INVALID_DIGEST);
437                         return 0;
438                         }
439                 return EVP_PKEY_CTX_set_signature_md(ctx, md);
440                 }
441         return ctx->pmeth->ctrl_str(ctx, name, value);
442         }
443
444 int EVP_PKEY_CTX_get_operation(EVP_PKEY_CTX *ctx)
445         {
446         return ctx->operation;
447         }
448
449 void EVP_PKEY_CTX_set0_keygen_info(EVP_PKEY_CTX *ctx, int *dat, int datlen)
450         {
451         ctx->keygen_info = dat;
452         ctx->keygen_info_count = datlen;
453         }
454
455 void EVP_PKEY_CTX_set_data(EVP_PKEY_CTX *ctx, void *data)
456         {
457         ctx->data = data;
458         }
459
460 void *EVP_PKEY_CTX_get_data(EVP_PKEY_CTX *ctx)
461         {
462         return ctx->data;
463         }
464
465 EVP_PKEY *EVP_PKEY_CTX_get0_pkey(EVP_PKEY_CTX *ctx)
466         {
467         return ctx->pkey;
468         }
469
470 EVP_PKEY *EVP_PKEY_CTX_get0_peerkey(EVP_PKEY_CTX *ctx)
471         {
472         return ctx->peerkey;
473         }
474         
475 void EVP_PKEY_CTX_set_app_data(EVP_PKEY_CTX *ctx, void *data)
476         {
477         ctx->app_data = data;
478         }
479
480 void *EVP_PKEY_CTX_get_app_data(EVP_PKEY_CTX *ctx)
481         {
482         return ctx->app_data;
483         }
484
485 void EVP_PKEY_meth_set_init(EVP_PKEY_METHOD *pmeth,
486         int (*init)(EVP_PKEY_CTX *ctx))
487         {
488         pmeth->init = init;
489         }
490
491 void EVP_PKEY_meth_set_copy(EVP_PKEY_METHOD *pmeth,
492         int (*copy)(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src))
493         {
494         pmeth->copy = copy;
495         }
496
497 void EVP_PKEY_meth_set_cleanup(EVP_PKEY_METHOD *pmeth,
498         void (*cleanup)(EVP_PKEY_CTX *ctx))
499         {
500         pmeth->cleanup = cleanup;
501         }
502
503 void EVP_PKEY_meth_set_paramgen(EVP_PKEY_METHOD *pmeth,
504         int (*paramgen_init)(EVP_PKEY_CTX *ctx),
505         int (*paramgen)(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey))
506         {
507         pmeth->paramgen_init = paramgen_init;
508         pmeth->paramgen = paramgen;
509         }
510
511 void EVP_PKEY_meth_set_keygen(EVP_PKEY_METHOD *pmeth,
512         int (*keygen_init)(EVP_PKEY_CTX *ctx),
513         int (*keygen)(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey))
514         {
515         pmeth->keygen_init = keygen_init;
516         pmeth->keygen = keygen;
517         }
518
519 void EVP_PKEY_meth_set_sign(EVP_PKEY_METHOD *pmeth,
520         int (*sign_init)(EVP_PKEY_CTX *ctx),
521         int (*sign)(EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
522                                         const unsigned char *tbs, size_t tbslen))
523         {
524         pmeth->sign_init = sign_init;
525         pmeth->sign = sign;
526         }
527
528 void EVP_PKEY_meth_set_verify(EVP_PKEY_METHOD *pmeth,
529         int (*verify_init)(EVP_PKEY_CTX *ctx),
530         int (*verify)(EVP_PKEY_CTX *ctx, const unsigned char *sig, size_t siglen,
531                                         const unsigned char *tbs, size_t tbslen))
532         {
533         pmeth->verify_init = verify_init;
534         pmeth->verify = verify;
535         }
536
537 void EVP_PKEY_meth_set_verify_recover(EVP_PKEY_METHOD *pmeth,
538         int (*verify_recover_init)(EVP_PKEY_CTX *ctx),
539         int (*verify_recover)(EVP_PKEY_CTX *ctx,
540                                         unsigned char *sig, size_t *siglen,
541                                         const unsigned char *tbs, size_t tbslen))
542         {
543         pmeth->verify_recover_init = verify_recover_init;
544         pmeth->verify_recover = verify_recover;
545         }
546
547 void EVP_PKEY_meth_set_signctx(EVP_PKEY_METHOD *pmeth,
548         int (*signctx_init)(EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx),
549         int (*signctx)(EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
550                                         EVP_MD_CTX *mctx))
551         {
552         pmeth->signctx_init = signctx_init;
553         pmeth->signctx = signctx;
554         }
555
556 void EVP_PKEY_meth_set_verifyctx(EVP_PKEY_METHOD *pmeth,
557         int (*verifyctx_init)(EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx),
558         int (*verifyctx)(EVP_PKEY_CTX *ctx, const unsigned char *sig,int siglen,
559                                         EVP_MD_CTX *mctx))
560         {
561         pmeth->verifyctx_init = verifyctx_init;
562         pmeth->verifyctx = verifyctx;
563         }
564
565 void EVP_PKEY_meth_set_encrypt(EVP_PKEY_METHOD *pmeth,
566         int (*encrypt_init)(EVP_PKEY_CTX *ctx),
567         int (*encryptfn)(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
568                                         const unsigned char *in, size_t inlen))
569         {
570         pmeth->encrypt_init = encrypt_init;
571         pmeth->encrypt = encryptfn;
572         }
573
574 void EVP_PKEY_meth_set_decrypt(EVP_PKEY_METHOD *pmeth,
575         int (*decrypt_init)(EVP_PKEY_CTX *ctx),
576         int (*decrypt)(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
577                                         const unsigned char *in, size_t inlen))
578         {
579         pmeth->decrypt_init = decrypt_init;
580         pmeth->decrypt = decrypt;
581         }
582
583 void EVP_PKEY_meth_set_derive(EVP_PKEY_METHOD *pmeth,
584         int (*derive_init)(EVP_PKEY_CTX *ctx),
585         int (*derive)(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen))
586         {
587         pmeth->derive_init = derive_init;
588         pmeth->derive = derive;
589         }
590
591 void EVP_PKEY_meth_set_ctrl(EVP_PKEY_METHOD *pmeth,
592         int (*ctrl)(EVP_PKEY_CTX *ctx, int type, int p1, void *p2),
593         int (*ctrl_str)(EVP_PKEY_CTX *ctx, const char *type, const char *value))
594         {
595         pmeth->ctrl = ctrl;
596         pmeth->ctrl_str = ctrl_str;
597         }