35b211c74cf1e2108ca7cb2538fda544dc580a51
[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;
77
78 static const EVP_PKEY_METHOD *standard_methods[] =
79         {
80 #ifndef OPENSSL_NO_RSA
81         &rsa_pkey_meth,
82 #endif
83 #ifndef OPENSSL_NO_DH
84         &dh_pkey_meth,
85 #endif
86 #ifndef OPENSSL_NO_DSA
87         &dsa_pkey_meth,
88 #endif
89 #ifndef OPENSSL_NO_EC
90         &ec_pkey_meth,
91 #endif
92         &hmac_pkey_meth,
93         };
94
95 DECLARE_OBJ_BSEARCH_CMP_FN(const EVP_PKEY_METHOD *, const EVP_PKEY_METHOD *,
96                            pmeth);
97
98 static int pmeth_cmp(const EVP_PKEY_METHOD * const *a,
99                      const EVP_PKEY_METHOD * const *b)
100         {
101         return ((*a)->pkey_id - (*b)->pkey_id);
102         }
103
104 IMPLEMENT_OBJ_BSEARCH_CMP_FN(const EVP_PKEY_METHOD *, const EVP_PKEY_METHOD *,
105                              pmeth);
106
107 const EVP_PKEY_METHOD *EVP_PKEY_meth_find(int type)
108         {
109         EVP_PKEY_METHOD tmp;
110         const EVP_PKEY_METHOD *t = &tmp, **ret;
111         tmp.pkey_id = type;
112         if (app_pkey_methods)
113                 {
114                 int idx;
115                 idx = sk_EVP_PKEY_METHOD_find(app_pkey_methods, &tmp);
116                 if (idx >= 0)
117                         return sk_EVP_PKEY_METHOD_value(app_pkey_methods, idx);
118                 }
119         ret = OBJ_bsearch_pmeth(&t, standard_methods,
120                           sizeof(standard_methods)/sizeof(EVP_PKEY_METHOD *));
121         if (!ret || !*ret)
122                 return NULL;
123         return *ret;
124         }
125
126 static EVP_PKEY_CTX *int_ctx_new(EVP_PKEY *pkey, ENGINE *e, int id)
127         {
128         EVP_PKEY_CTX *ret;
129         const EVP_PKEY_METHOD *pmeth;
130         if (id == -1)
131                 {
132                 if (!pkey || !pkey->ameth)
133                         return NULL;
134                 id = pkey->ameth->pkey_id;
135                 }
136 #ifndef OPENSSL_NO_ENGINE
137         if (pkey && pkey->engine)
138                 e = pkey->engine;
139         /* Try to find an ENGINE which implements this method */
140         if (e)
141                 {
142                 if (!ENGINE_init(e))
143                         {
144                         EVPerr(EVP_F_INT_CTX_NEW,ERR_R_ENGINE_LIB);
145                         return NULL;
146                         }
147                 }
148         else
149                 e = ENGINE_get_pkey_meth_engine(id);
150
151         /* If an ENGINE handled this method look it up. Othewise
152          * use internal tables.
153          */
154
155         if (e)
156                 pmeth = ENGINE_get_pkey_meth(e, id);
157         else
158 #endif
159                 pmeth = EVP_PKEY_meth_find(id);
160
161         if (pmeth == NULL)
162                 {
163                 EVPerr(EVP_F_INT_CTX_NEW,EVP_R_UNSUPPORTED_ALGORITHM);
164                 return NULL;
165                 }
166
167         ret = OPENSSL_malloc(sizeof(EVP_PKEY_CTX));
168         if (!ret)
169                 {
170 #ifndef OPENSSL_NO_ENGINE
171                 if (e)
172                         ENGINE_finish(e);
173 #endif
174                 EVPerr(EVP_F_INT_CTX_NEW,ERR_R_MALLOC_FAILURE);
175                 return NULL;
176                 }
177         ret->engine = e;
178         ret->pmeth = pmeth;
179         ret->operation = EVP_PKEY_OP_UNDEFINED;
180         ret->pkey = pkey;
181         ret->peerkey = NULL;
182         ret->pkey_gencb = 0;
183         if (pkey)
184                 CRYPTO_add(&pkey->references,1,CRYPTO_LOCK_EVP_PKEY);
185         ret->data = NULL;
186
187         if (pmeth->init)
188                 {
189                 if (pmeth->init(ret) <= 0)
190                         {
191                         EVP_PKEY_CTX_free(ret);
192                         return NULL;
193                         }
194                 }
195
196         return ret;
197         }
198
199 EVP_PKEY_METHOD* EVP_PKEY_meth_new(int id, int flags)
200         {
201         EVP_PKEY_METHOD *pmeth;
202         pmeth = OPENSSL_malloc(sizeof(EVP_PKEY_METHOD));
203         if (!pmeth)
204                 return NULL;
205
206         pmeth->pkey_id = id;
207         pmeth->flags = flags | EVP_PKEY_FLAG_DYNAMIC;
208
209         pmeth->init = 0;
210         pmeth->copy = 0;
211         pmeth->cleanup = 0;
212         pmeth->paramgen_init = 0;
213         pmeth->paramgen = 0;
214         pmeth->keygen_init = 0;
215         pmeth->keygen = 0;
216         pmeth->sign_init = 0;
217         pmeth->sign = 0;
218         pmeth->verify_init = 0;
219         pmeth->verify = 0;
220         pmeth->verify_recover_init = 0;
221         pmeth->verify_recover = 0;
222         pmeth->signctx_init = 0;
223         pmeth->signctx = 0;
224         pmeth->verifyctx_init = 0;
225         pmeth->verifyctx = 0;
226         pmeth->encrypt_init = 0;
227         pmeth->encrypt = 0;
228         pmeth->decrypt_init = 0;
229         pmeth->decrypt = 0;
230         pmeth->derive_init = 0;
231         pmeth->derive = 0;
232         pmeth->ctrl = 0;
233         pmeth->ctrl_str = 0;
234
235         return pmeth;
236         }
237
238 void EVP_PKEY_meth_get0_info(int *ppkey_id, int *pflags,
239                                 const EVP_PKEY_METHOD *meth)
240         {
241         if (ppkey_id)
242                 *ppkey_id = meth->pkey_id;
243         if (pflags)
244                 *pflags = meth->flags;
245         }
246
247 void EVP_PKEY_meth_copy(EVP_PKEY_METHOD *dst, const EVP_PKEY_METHOD *src)
248         {
249
250         dst->init = src->init;
251         dst->copy = src->copy;
252         dst->cleanup = src->cleanup;
253
254         dst->paramgen_init = src->paramgen_init;
255         dst->paramgen = src->paramgen;
256
257         dst->keygen_init = src->keygen_init;
258         dst->keygen = src->keygen;
259
260         dst->sign_init = src->sign_init;
261         dst->sign = src->sign;
262
263         dst->verify_init = src->verify_init;
264         dst->verify = src->verify;
265
266         dst->verify_recover_init = src->verify_recover_init;
267         dst->verify_recover = src->verify_recover;
268
269         dst->signctx_init = src->signctx_init;
270         dst->signctx = src->signctx;
271
272         dst->verifyctx_init = src->verifyctx_init;
273         dst->verifyctx = src->verifyctx;
274
275         dst->encrypt_init = src->encrypt_init;
276         dst->encrypt = src->encrypt;
277
278         dst->decrypt_init = src->decrypt_init;
279         dst->decrypt = src->decrypt;
280
281         dst->derive_init = src->derive_init;
282         dst->derive = src->derive;
283
284         dst->ctrl = src->ctrl;
285         dst->ctrl_str = src->ctrl_str;
286         }
287
288 void EVP_PKEY_meth_free(EVP_PKEY_METHOD *pmeth)
289         {
290         if (pmeth && (pmeth->flags & EVP_PKEY_FLAG_DYNAMIC))
291                 OPENSSL_free(pmeth);
292         }
293
294 EVP_PKEY_CTX *EVP_PKEY_CTX_new(EVP_PKEY *pkey, ENGINE *e)
295         {
296         return int_ctx_new(pkey, e, -1);
297         }
298
299 EVP_PKEY_CTX *EVP_PKEY_CTX_new_id(int id, ENGINE *e)
300         {
301         return int_ctx_new(NULL, e, id);
302         }
303
304 EVP_PKEY_CTX *EVP_PKEY_CTX_dup(EVP_PKEY_CTX *pctx)
305         {
306         EVP_PKEY_CTX *rctx;
307         if (!pctx->pmeth || !pctx->pmeth->copy)
308                 return NULL;
309 #ifndef OPENSSL_NO_ENGINE
310         /* Make sure it's safe to copy a pkey context using an ENGINE */
311         if (pctx->engine && !ENGINE_init(pctx->engine))
312                 {
313                 EVPerr(EVP_F_EVP_PKEY_CTX_DUP,ERR_R_ENGINE_LIB);
314                 return 0;
315                 }
316 #endif
317         rctx = OPENSSL_malloc(sizeof(EVP_PKEY_CTX));
318         if (!rctx)
319                 return NULL;
320
321         rctx->pmeth = pctx->pmeth;
322 #ifndef OPENSSL_NO_ENGINE
323         rctx->engine = pctx->engine;
324 #endif
325
326         if (pctx->pkey)
327                 CRYPTO_add(&pctx->pkey->references,1,CRYPTO_LOCK_EVP_PKEY);
328
329         rctx->pkey = pctx->pkey;
330
331         if (pctx->peerkey)
332                 CRYPTO_add(&pctx->peerkey->references,1,CRYPTO_LOCK_EVP_PKEY);
333
334         rctx->peerkey = pctx->peerkey;
335
336         rctx->data = NULL;
337         rctx->app_data = NULL;
338         rctx->operation = pctx->operation;
339
340         if (pctx->pmeth->copy(rctx, pctx) > 0)
341                 return rctx;
342
343         EVP_PKEY_CTX_free(rctx);
344         return NULL;
345
346         }
347
348 int EVP_PKEY_meth_add0(const EVP_PKEY_METHOD *pmeth)
349         {
350         if (app_pkey_methods == NULL)
351                 {
352                 app_pkey_methods = sk_EVP_PKEY_METHOD_new(pmeth_cmp);
353                 if (!app_pkey_methods)
354                         return 0;
355                 }
356         if (!sk_EVP_PKEY_METHOD_push(app_pkey_methods, pmeth))
357                 return 0;
358         sk_EVP_PKEY_METHOD_sort(app_pkey_methods);
359         return 1;
360         }
361
362 void EVP_PKEY_CTX_free(EVP_PKEY_CTX *ctx)
363         {
364         if (ctx == NULL)
365                 return;
366         if (ctx->pmeth && ctx->pmeth->cleanup)
367                 ctx->pmeth->cleanup(ctx);
368         if (ctx->pkey)
369                 EVP_PKEY_free(ctx->pkey);
370         if (ctx->peerkey)
371                 EVP_PKEY_free(ctx->peerkey);
372 #ifndef OPENSSL_NO_ENGINE
373         if(ctx->engine)
374                 /* The EVP_PKEY_CTX we used belongs to an ENGINE, release the
375                  * functional reference we held for this reason. */
376                 ENGINE_finish(ctx->engine);
377 #endif
378         OPENSSL_free(ctx);
379         }
380
381 int EVP_PKEY_CTX_ctrl(EVP_PKEY_CTX *ctx, int keytype, int optype,
382                                 int cmd, int p1, void *p2)
383         {
384         int ret;
385         if (!ctx || !ctx->pmeth || !ctx->pmeth->ctrl)
386                 {
387                 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_COMMAND_NOT_SUPPORTED);
388                 return -2;
389                 }
390         if ((keytype != -1) && (ctx->pmeth->pkey_id != keytype))
391                 return -1;
392
393         if (ctx->operation == EVP_PKEY_OP_UNDEFINED)
394                 {
395                 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_NO_OPERATION_SET);
396                 return -1;
397                 }
398
399         if ((optype != -1) && !(ctx->operation & optype))
400                 {
401                 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_INVALID_OPERATION);
402                 return -1;
403                 }
404
405         ret = ctx->pmeth->ctrl(ctx, cmd, p1, p2);
406
407         if (ret == -2)
408                 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_COMMAND_NOT_SUPPORTED);
409
410         return ret;
411
412         }
413
414 int EVP_PKEY_CTX_ctrl_str(EVP_PKEY_CTX *ctx,
415                                         const char *name, const char *value)
416         {
417         if (!ctx || !ctx->pmeth || !ctx->pmeth->ctrl_str)
418                 {
419                 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL_STR,
420                                                 EVP_R_COMMAND_NOT_SUPPORTED);
421                 return -2;
422                 }
423         if (!strcmp(name, "digest"))
424                 {
425                 const EVP_MD *md;
426                 if (!value || !(md = EVP_get_digestbyname(value)))
427                         {
428                         EVPerr(EVP_F_EVP_PKEY_CTX_CTRL_STR,
429                                                 EVP_R_INVALID_DIGEST);
430                         return 0;
431                         }
432                 return EVP_PKEY_CTX_set_signature_md(ctx, md);
433                 }
434         return ctx->pmeth->ctrl_str(ctx, name, value);
435         }
436
437 int EVP_PKEY_CTX_get_operation(EVP_PKEY_CTX *ctx)
438         {
439         return ctx->operation;
440         }
441
442 void EVP_PKEY_CTX_set0_keygen_info(EVP_PKEY_CTX *ctx, int *dat, int datlen)
443         {
444         ctx->keygen_info = dat;
445         ctx->keygen_info_count = datlen;
446         }
447
448 void EVP_PKEY_CTX_set_data(EVP_PKEY_CTX *ctx, void *data)
449         {
450         ctx->data = data;
451         }
452
453 void *EVP_PKEY_CTX_get_data(EVP_PKEY_CTX *ctx)
454         {
455         return ctx->data;
456         }
457
458 EVP_PKEY *EVP_PKEY_CTX_get0_pkey(EVP_PKEY_CTX *ctx)
459         {
460         return ctx->pkey;
461         }
462
463 EVP_PKEY *EVP_PKEY_CTX_get0_peerkey(EVP_PKEY_CTX *ctx)
464         {
465         return ctx->peerkey;
466         }
467         
468 void EVP_PKEY_CTX_set_app_data(EVP_PKEY_CTX *ctx, void *data)
469         {
470         ctx->app_data = data;
471         }
472
473 void *EVP_PKEY_CTX_get_app_data(EVP_PKEY_CTX *ctx)
474         {
475         return ctx->app_data;
476         }
477
478 void EVP_PKEY_meth_set_init(EVP_PKEY_METHOD *pmeth,
479         int (*init)(EVP_PKEY_CTX *ctx))
480         {
481         pmeth->init = init;
482         }
483
484 void EVP_PKEY_meth_set_copy(EVP_PKEY_METHOD *pmeth,
485         int (*copy)(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src))
486         {
487         pmeth->copy = copy;
488         }
489
490 void EVP_PKEY_meth_set_cleanup(EVP_PKEY_METHOD *pmeth,
491         void (*cleanup)(EVP_PKEY_CTX *ctx))
492         {
493         pmeth->cleanup = cleanup;
494         }
495
496 void EVP_PKEY_meth_set_paramgen(EVP_PKEY_METHOD *pmeth,
497         int (*paramgen_init)(EVP_PKEY_CTX *ctx),
498         int (*paramgen)(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey))
499         {
500         pmeth->paramgen_init = paramgen_init;
501         pmeth->paramgen = paramgen;
502         }
503
504 void EVP_PKEY_meth_set_keygen(EVP_PKEY_METHOD *pmeth,
505         int (*keygen_init)(EVP_PKEY_CTX *ctx),
506         int (*keygen)(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey))
507         {
508         pmeth->keygen_init = keygen_init;
509         pmeth->keygen = keygen;
510         }
511
512 void EVP_PKEY_meth_set_sign(EVP_PKEY_METHOD *pmeth,
513         int (*sign_init)(EVP_PKEY_CTX *ctx),
514         int (*sign)(EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
515                                         const unsigned char *tbs, size_t tbslen))
516         {
517         pmeth->sign_init = sign_init;
518         pmeth->sign = sign;
519         }
520
521 void EVP_PKEY_meth_set_verify(EVP_PKEY_METHOD *pmeth,
522         int (*verify_init)(EVP_PKEY_CTX *ctx),
523         int (*verify)(EVP_PKEY_CTX *ctx, const unsigned char *sig, size_t siglen,
524                                         const unsigned char *tbs, size_t tbslen))
525         {
526         pmeth->verify_init = verify_init;
527         pmeth->verify = verify;
528         }
529
530 void EVP_PKEY_meth_set_verify_recover(EVP_PKEY_METHOD *pmeth,
531         int (*verify_recover_init)(EVP_PKEY_CTX *ctx),
532         int (*verify_recover)(EVP_PKEY_CTX *ctx,
533                                         unsigned char *sig, size_t *siglen,
534                                         const unsigned char *tbs, size_t tbslen))
535         {
536         pmeth->verify_recover_init = verify_recover_init;
537         pmeth->verify_recover = verify_recover;
538         }
539
540 void EVP_PKEY_meth_set_signctx(EVP_PKEY_METHOD *pmeth,
541         int (*signctx_init)(EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx),
542         int (*signctx)(EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
543                                         EVP_MD_CTX *mctx))
544         {
545         pmeth->signctx_init = signctx_init;
546         pmeth->signctx = signctx;
547         }
548
549 void EVP_PKEY_meth_set_verifyctx(EVP_PKEY_METHOD *pmeth,
550         int (*verifyctx_init)(EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx),
551         int (*verifyctx)(EVP_PKEY_CTX *ctx, const unsigned char *sig,int siglen,
552                                         EVP_MD_CTX *mctx))
553         {
554         pmeth->verifyctx_init = verifyctx_init;
555         pmeth->verifyctx = verifyctx;
556         }
557
558 void EVP_PKEY_meth_set_encrypt(EVP_PKEY_METHOD *pmeth,
559         int (*encrypt_init)(EVP_PKEY_CTX *ctx),
560         int (*encryptfn)(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
561                                         const unsigned char *in, size_t inlen))
562         {
563         pmeth->encrypt_init = encrypt_init;
564         pmeth->encrypt = encryptfn;
565         }
566
567 void EVP_PKEY_meth_set_decrypt(EVP_PKEY_METHOD *pmeth,
568         int (*decrypt_init)(EVP_PKEY_CTX *ctx),
569         int (*decrypt)(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
570                                         const unsigned char *in, size_t inlen))
571         {
572         pmeth->decrypt_init = decrypt_init;
573         pmeth->decrypt = decrypt;
574         }
575
576 void EVP_PKEY_meth_set_derive(EVP_PKEY_METHOD *pmeth,
577         int (*derive_init)(EVP_PKEY_CTX *ctx),
578         int (*derive)(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen))
579         {
580         pmeth->derive_init = derive_init;
581         pmeth->derive = derive;
582         }
583
584 void EVP_PKEY_meth_set_ctrl(EVP_PKEY_METHOD *pmeth,
585         int (*ctrl)(EVP_PKEY_CTX *ctx, int type, int p1, void *p2),
586         int (*ctrl_str)(EVP_PKEY_CTX *ctx, const char *type, const char *value))
587         {
588         pmeth->ctrl = ctrl;
589         pmeth->ctrl_str = ctrl_str;
590         }