eeee53a2efbf26f4bf3747b340f283c3d6b1c197
[openssl.git] / crypto / evp / pmeth_lib.c
1 /* pmeth_lib.c */
2 /*
3  * Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL project
4  * 2006.
5  */
6 /* ====================================================================
7  * Copyright (c) 2006 The OpenSSL Project.  All rights reserved.
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions
11  * are met:
12  *
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  *
16  * 2. Redistributions in binary form must reproduce the above copyright
17  *    notice, this list of conditions and the following disclaimer in
18  *    the documentation and/or other materials provided with the
19  *    distribution.
20  *
21  * 3. All advertising materials mentioning features or use of this
22  *    software must display the following acknowledgment:
23  *    "This product includes software developed by the OpenSSL Project
24  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
25  *
26  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
27  *    endorse or promote products derived from this software without
28  *    prior written permission. For written permission, please contact
29  *    licensing@OpenSSL.org.
30  *
31  * 5. Products derived from this software may not be called "OpenSSL"
32  *    nor may "OpenSSL" appear in their names without prior written
33  *    permission of the OpenSSL Project.
34  *
35  * 6. Redistributions of any form whatsoever must retain the following
36  *    acknowledgment:
37  *    "This product includes software developed by the OpenSSL Project
38  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
39  *
40  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
41  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
42  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
43  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
44  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
45  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
46  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
47  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
49  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
50  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
51  * OF THE POSSIBILITY OF SUCH DAMAGE.
52  * ====================================================================
53  *
54  * This product includes cryptographic software written by Eric Young
55  * (eay@cryptsoft.com).  This product includes software written by Tim
56  * Hudson (tjh@cryptsoft.com).
57  *
58  */
59
60 #include <stdio.h>
61 #include <stdlib.h>
62 #include "cryptlib.h"
63 #include <openssl/objects.h>
64 #include <openssl/evp.h>
65 #ifndef OPENSSL_NO_ENGINE
66 # include <openssl/engine.h>
67 #endif
68 #include "internal/asn1_int.h"
69 #include "internal/evp_int.h"
70
71 typedef int sk_cmp_fn_type(const char *const *a, const char *const *b);
72
73 DECLARE_STACK_OF(EVP_PKEY_METHOD)
74 STACK_OF(EVP_PKEY_METHOD) *app_pkey_methods = NULL;
75
76 extern const EVP_PKEY_METHOD rsa_pkey_meth, dh_pkey_meth, dsa_pkey_meth;
77 extern const EVP_PKEY_METHOD ec_pkey_meth, hmac_pkey_meth, cmac_pkey_meth;
78 extern const EVP_PKEY_METHOD dhx_pkey_meth;
79
80 static const EVP_PKEY_METHOD *standard_methods[] = {
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         int idx;
119         idx = sk_EVP_PKEY_METHOD_find(app_pkey_methods, &tmp);
120         if (idx >= 0)
121             return sk_EVP_PKEY_METHOD_value(app_pkey_methods, idx);
122     }
123     ret = OBJ_bsearch_pmeth(&t, standard_methods,
124                             sizeof(standard_methods) /
125                             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         if (!pkey || !pkey->ameth)
137             return NULL;
138         id = pkey->ameth->pkey_id;
139     }
140 #ifndef OPENSSL_NO_ENGINE
141     if (pkey && pkey->engine)
142         e = pkey->engine;
143     /* Try to find an ENGINE which implements this method */
144     if (e) {
145         if (!ENGINE_init(e)) {
146             EVPerr(EVP_F_INT_CTX_NEW, ERR_R_ENGINE_LIB);
147             return NULL;
148         }
149     } else
150         e = ENGINE_get_pkey_meth_engine(id);
151
152     /*
153      * If an ENGINE handled this method look it up. Othewise use internal
154      * tables.
155      */
156
157     if (e)
158         pmeth = ENGINE_get_pkey_meth(e, id);
159     else
160 #endif
161         pmeth = EVP_PKEY_meth_find(id);
162
163     if (pmeth == NULL) {
164         EVPerr(EVP_F_INT_CTX_NEW, EVP_R_UNSUPPORTED_ALGORITHM);
165         return NULL;
166     }
167
168     ret = OPENSSL_malloc(sizeof(*ret));
169     if (!ret) {
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         if (pmeth->init(ret) <= 0) {
189             EVP_PKEY_CTX_free(ret);
190             return NULL;
191         }
192     }
193
194     return ret;
195 }
196
197 EVP_PKEY_METHOD *EVP_PKEY_meth_new(int id, int flags)
198 {
199     EVP_PKEY_METHOD *pmeth;
200
201     pmeth = OPENSSL_malloc(sizeof(*pmeth));
202     if (!pmeth)
203         return NULL;
204
205     memset(pmeth, 0, sizeof(*pmeth));
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         EVPerr(EVP_F_EVP_PKEY_CTX_DUP, ERR_R_ENGINE_LIB);
314         return 0;
315     }
316 #endif
317     rctx = OPENSSL_malloc(sizeof(*rctx));
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         app_pkey_methods = sk_EVP_PKEY_METHOD_new(pmeth_cmp);
352         if (!app_pkey_methods)
353             return 0;
354     }
355     if (!sk_EVP_PKEY_METHOD_push(app_pkey_methods, pmeth))
356         return 0;
357     sk_EVP_PKEY_METHOD_sort(app_pkey_methods);
358     return 1;
359 }
360
361 void EVP_PKEY_CTX_free(EVP_PKEY_CTX *ctx)
362 {
363     if (ctx == NULL)
364         return;
365     if (ctx->pmeth && ctx->pmeth->cleanup)
366         ctx->pmeth->cleanup(ctx);
367     EVP_PKEY_free(ctx->pkey);
368     EVP_PKEY_free(ctx->peerkey);
369 #ifndef OPENSSL_NO_ENGINE
370     if (ctx->engine)
371         /*
372          * The EVP_PKEY_CTX we used belongs to an ENGINE, release the
373          * functional reference we held for this reason.
374          */
375         ENGINE_finish(ctx->engine);
376 #endif
377     OPENSSL_free(ctx);
378 }
379
380 int EVP_PKEY_CTX_ctrl(EVP_PKEY_CTX *ctx, int keytype, int optype,
381                       int cmd, int p1, void *p2)
382 {
383     int ret;
384     if (!ctx || !ctx->pmeth || !ctx->pmeth->ctrl) {
385         EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_COMMAND_NOT_SUPPORTED);
386         return -2;
387     }
388     if ((keytype != -1) && (ctx->pmeth->pkey_id != keytype))
389         return -1;
390
391     if (ctx->operation == EVP_PKEY_OP_UNDEFINED) {
392         EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_NO_OPERATION_SET);
393         return -1;
394     }
395
396     if ((optype != -1) && !(ctx->operation & optype)) {
397         EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_INVALID_OPERATION);
398         return -1;
399     }
400
401     ret = ctx->pmeth->ctrl(ctx, cmd, p1, p2);
402
403     if (ret == -2)
404         EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_COMMAND_NOT_SUPPORTED);
405
406     return ret;
407
408 }
409
410 int EVP_PKEY_CTX_ctrl_str(EVP_PKEY_CTX *ctx,
411                           const char *name, const char *value)
412 {
413     if (!ctx || !ctx->pmeth || !ctx->pmeth->ctrl_str) {
414         EVPerr(EVP_F_EVP_PKEY_CTX_CTRL_STR, EVP_R_COMMAND_NOT_SUPPORTED);
415         return -2;
416     }
417     if (!strcmp(name, "digest")) {
418         const EVP_MD *md;
419         if (!value || !(md = EVP_get_digestbyname(value))) {
420             EVPerr(EVP_F_EVP_PKEY_CTX_CTRL_STR, EVP_R_INVALID_DIGEST);
421             return 0;
422         }
423         return EVP_PKEY_CTX_set_signature_md(ctx, md);
424     }
425     return ctx->pmeth->ctrl_str(ctx, name, value);
426 }
427
428 int EVP_PKEY_CTX_get_operation(EVP_PKEY_CTX *ctx)
429 {
430     return ctx->operation;
431 }
432
433 void EVP_PKEY_CTX_set0_keygen_info(EVP_PKEY_CTX *ctx, int *dat, int datlen)
434 {
435     ctx->keygen_info = dat;
436     ctx->keygen_info_count = datlen;
437 }
438
439 void EVP_PKEY_CTX_set_data(EVP_PKEY_CTX *ctx, void *data)
440 {
441     ctx->data = data;
442 }
443
444 void *EVP_PKEY_CTX_get_data(EVP_PKEY_CTX *ctx)
445 {
446     return ctx->data;
447 }
448
449 EVP_PKEY *EVP_PKEY_CTX_get0_pkey(EVP_PKEY_CTX *ctx)
450 {
451     return ctx->pkey;
452 }
453
454 EVP_PKEY *EVP_PKEY_CTX_get0_peerkey(EVP_PKEY_CTX *ctx)
455 {
456     return ctx->peerkey;
457 }
458
459 void EVP_PKEY_CTX_set_app_data(EVP_PKEY_CTX *ctx, void *data)
460 {
461     ctx->app_data = data;
462 }
463
464 void *EVP_PKEY_CTX_get_app_data(EVP_PKEY_CTX *ctx)
465 {
466     return ctx->app_data;
467 }
468
469 void EVP_PKEY_meth_set_init(EVP_PKEY_METHOD *pmeth,
470                             int (*init) (EVP_PKEY_CTX *ctx))
471 {
472     pmeth->init = init;
473 }
474
475 void EVP_PKEY_meth_set_copy(EVP_PKEY_METHOD *pmeth,
476                             int (*copy) (EVP_PKEY_CTX *dst,
477                                          EVP_PKEY_CTX *src))
478 {
479     pmeth->copy = copy;
480 }
481
482 void EVP_PKEY_meth_set_cleanup(EVP_PKEY_METHOD *pmeth,
483                                void (*cleanup) (EVP_PKEY_CTX *ctx))
484 {
485     pmeth->cleanup = cleanup;
486 }
487
488 void EVP_PKEY_meth_set_paramgen(EVP_PKEY_METHOD *pmeth,
489                                 int (*paramgen_init) (EVP_PKEY_CTX *ctx),
490                                 int (*paramgen) (EVP_PKEY_CTX *ctx,
491                                                  EVP_PKEY *pkey))
492 {
493     pmeth->paramgen_init = paramgen_init;
494     pmeth->paramgen = paramgen;
495 }
496
497 void EVP_PKEY_meth_set_keygen(EVP_PKEY_METHOD *pmeth,
498                               int (*keygen_init) (EVP_PKEY_CTX *ctx),
499                               int (*keygen) (EVP_PKEY_CTX *ctx,
500                                              EVP_PKEY *pkey))
501 {
502     pmeth->keygen_init = keygen_init;
503     pmeth->keygen = keygen;
504 }
505
506 void EVP_PKEY_meth_set_sign(EVP_PKEY_METHOD *pmeth,
507                             int (*sign_init) (EVP_PKEY_CTX *ctx),
508                             int (*sign) (EVP_PKEY_CTX *ctx,
509                                          unsigned char *sig, size_t *siglen,
510                                          const unsigned char *tbs,
511                                          size_t tbslen))
512 {
513     pmeth->sign_init = sign_init;
514     pmeth->sign = sign;
515 }
516
517 void EVP_PKEY_meth_set_verify(EVP_PKEY_METHOD *pmeth,
518                               int (*verify_init) (EVP_PKEY_CTX *ctx),
519                               int (*verify) (EVP_PKEY_CTX *ctx,
520                                              const unsigned char *sig,
521                                              size_t siglen,
522                                              const unsigned char *tbs,
523                                              size_t tbslen))
524 {
525     pmeth->verify_init = verify_init;
526     pmeth->verify = verify;
527 }
528
529 void EVP_PKEY_meth_set_verify_recover(EVP_PKEY_METHOD *pmeth,
530                                       int (*verify_recover_init) (EVP_PKEY_CTX
531                                                                   *ctx),
532                                       int (*verify_recover) (EVP_PKEY_CTX
533                                                              *ctx,
534                                                              unsigned char
535                                                              *sig,
536                                                              size_t *siglen,
537                                                              const unsigned
538                                                              char *tbs,
539                                                              size_t tbslen))
540 {
541     pmeth->verify_recover_init = verify_recover_init;
542     pmeth->verify_recover = verify_recover;
543 }
544
545 void EVP_PKEY_meth_set_signctx(EVP_PKEY_METHOD *pmeth,
546                                int (*signctx_init) (EVP_PKEY_CTX *ctx,
547                                                     EVP_MD_CTX *mctx),
548                                int (*signctx) (EVP_PKEY_CTX *ctx,
549                                                unsigned char *sig,
550                                                size_t *siglen,
551                                                EVP_MD_CTX *mctx))
552 {
553     pmeth->signctx_init = signctx_init;
554     pmeth->signctx = signctx;
555 }
556
557 void EVP_PKEY_meth_set_verifyctx(EVP_PKEY_METHOD *pmeth,
558                                  int (*verifyctx_init) (EVP_PKEY_CTX *ctx,
559                                                         EVP_MD_CTX *mctx),
560                                  int (*verifyctx) (EVP_PKEY_CTX *ctx,
561                                                    const unsigned char *sig,
562                                                    int siglen,
563                                                    EVP_MD_CTX *mctx))
564 {
565     pmeth->verifyctx_init = verifyctx_init;
566     pmeth->verifyctx = verifyctx;
567 }
568
569 void EVP_PKEY_meth_set_encrypt(EVP_PKEY_METHOD *pmeth,
570                                int (*encrypt_init) (EVP_PKEY_CTX *ctx),
571                                int (*encryptfn) (EVP_PKEY_CTX *ctx,
572                                                  unsigned char *out,
573                                                  size_t *outlen,
574                                                  const unsigned char *in,
575                                                  size_t inlen))
576 {
577     pmeth->encrypt_init = encrypt_init;
578     pmeth->encrypt = encryptfn;
579 }
580
581 void EVP_PKEY_meth_set_decrypt(EVP_PKEY_METHOD *pmeth,
582                                int (*decrypt_init) (EVP_PKEY_CTX *ctx),
583                                int (*decrypt) (EVP_PKEY_CTX *ctx,
584                                                unsigned char *out,
585                                                size_t *outlen,
586                                                const unsigned char *in,
587                                                size_t inlen))
588 {
589     pmeth->decrypt_init = decrypt_init;
590     pmeth->decrypt = decrypt;
591 }
592
593 void EVP_PKEY_meth_set_derive(EVP_PKEY_METHOD *pmeth,
594                               int (*derive_init) (EVP_PKEY_CTX *ctx),
595                               int (*derive) (EVP_PKEY_CTX *ctx,
596                                              unsigned char *key,
597                                              size_t *keylen))
598 {
599     pmeth->derive_init = derive_init;
600     pmeth->derive = derive;
601 }
602
603 void EVP_PKEY_meth_set_ctrl(EVP_PKEY_METHOD *pmeth,
604                             int (*ctrl) (EVP_PKEY_CTX *ctx, int type, int p1,
605                                          void *p2),
606                             int (*ctrl_str) (EVP_PKEY_CTX *ctx,
607                                              const char *type,
608                                              const char *value))
609 {
610     pmeth->ctrl = ctrl;
611     pmeth->ctrl_str = ctrl_str;
612 }