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