d68972c7c47b4da2876725e6692837a87cee560f
[openssl.git] / crypto / evp / pmeth_lib.c
1 /* pmeth_lib.c */
2 /* Written by Dr Stephen N Henson (shenson@bigfoot.com) 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 <openssl/objects.h>
62 #include "cryptlib.h"
63 #include <openssl/evp.h>
64 #include "asn1_locl.h"
65 #include "evp_locl.h"
66
67 typedef int sk_cmp_fn_type(const char * const *a, const char * const *b);
68 STACK *app_pkey_methods = NULL;
69
70 extern EVP_PKEY_METHOD rsa_pkey_meth, dh_pkey_meth, dsa_pkey_meth, ec_pkey_meth;
71
72 static const EVP_PKEY_METHOD *standard_methods[] =
73         {
74         &rsa_pkey_meth,
75         &dh_pkey_meth,
76         &dsa_pkey_meth,
77         &ec_pkey_meth
78         };
79
80 static int pmeth_cmp(const EVP_PKEY_METHOD * const *a,
81                 const EVP_PKEY_METHOD * const *b)
82         {
83         return ((*a)->pkey_id - (*b)->pkey_id);
84         }
85
86 const EVP_PKEY_METHOD *EVP_PKEY_meth_find(int type, ENGINE *e)
87         {
88         EVP_PKEY_METHOD tmp, *t = &tmp, **ret;
89         tmp.pkey_id = type;
90         if (app_pkey_methods)
91                 {
92                 int idx;
93                 idx = sk_find(app_pkey_methods, (char *)&tmp);
94                 if (idx >= 0)
95                         return (EVP_PKEY_METHOD *)
96                                 sk_value(app_pkey_methods, idx);
97                 }
98         ret = (EVP_PKEY_METHOD **) OBJ_bsearch((char *)&t,
99                         (char *)standard_methods,
100                         sizeof(standard_methods)/sizeof(EVP_PKEY_METHOD *),
101                         sizeof(EVP_PKEY_METHOD *),
102                         (int (*)(const void *, const void *))pmeth_cmp);
103         if (!ret || !*ret)
104                 return NULL;
105         return *ret;
106         }
107
108 static EVP_PKEY_CTX *int_ctx_new(EVP_PKEY *pkey, ENGINE *e, int id)
109         {
110         EVP_PKEY_CTX *ret;
111         const EVP_PKEY_METHOD *pmeth;
112         if (id == -1)
113                 {
114                 if (!pkey || !pkey->ameth)
115                         return NULL;
116                 id = pkey->ameth->pkey_id;
117                 }
118         pmeth = EVP_PKEY_meth_find(id, e);
119         if (pmeth == NULL)
120                 return NULL;
121         ret = OPENSSL_malloc(sizeof(EVP_PKEY_CTX));
122         ret->pmeth = pmeth;
123         ret->operation = EVP_PKEY_OP_UNDEFINED;
124         ret->pkey = pkey;
125         ret->peerkey = NULL;
126         if (pkey)
127                 CRYPTO_add(&pkey->references,1,CRYPTO_LOCK_EVP_PKEY);
128         ret->data = NULL;
129
130         if (pmeth->init)
131                 {
132                 if (pmeth->init(ret) <= 0)
133                         {
134                         EVP_PKEY_CTX_free(ret);
135                         return NULL;
136                         }
137                 }
138
139         return ret;
140         }
141
142 EVP_PKEY_METHOD* EVP_PKEY_meth_new(int id, int flags)
143         {
144         EVP_PKEY_METHOD *pmeth;
145         pmeth = OPENSSL_malloc(sizeof(EVP_PKEY_METHOD));
146         if (!pmeth)
147                 return NULL;
148
149         pmeth->pkey_id = id;
150         pmeth->flags = flags | EVP_PKEY_FLAG_DYNAMIC;
151
152         pmeth->init = 0;
153         pmeth->cleanup = 0;
154         pmeth->paramgen_init = 0;
155         pmeth->paramgen = 0;
156         pmeth->keygen_init = 0;
157         pmeth->keygen = 0;
158         pmeth->sign_init = 0;
159         pmeth->sign = 0;
160         pmeth->verify_init = 0;
161         pmeth->verify = 0;
162         pmeth->verify_recover_init = 0;
163         pmeth->verify_recover = 0;
164         pmeth->signctx_init = 0;
165         pmeth->signctx = 0;
166         pmeth->verifyctx_init = 0;
167         pmeth->verifyctx = 0;
168         pmeth->encrypt_init = 0;
169         pmeth->encrypt = 0;
170         pmeth->decrypt_init = 0;
171         pmeth->decrypt = 0;
172         pmeth->derive_init = 0;
173         pmeth->derive = 0;
174         pmeth->ctrl = 0;
175         pmeth->ctrl_str = 0;
176
177         return pmeth;
178         }
179
180 void EVP_PKEY_meth_free(EVP_PKEY_METHOD *pmeth)
181         {
182         if (pmeth && (pmeth->flags & EVP_PKEY_FLAG_DYNAMIC))
183                 OPENSSL_free(pmeth);
184         }
185
186 EVP_PKEY_CTX *EVP_PKEY_CTX_new(EVP_PKEY *pkey, ENGINE *e)
187         {
188         return int_ctx_new(pkey, e, -1);
189         }
190
191 EVP_PKEY_CTX *EVP_PKEY_CTX_new_id(int id, ENGINE *e)
192         {
193         return int_ctx_new(NULL, e, id);
194         }
195
196 int EVP_PKEY_meth_add0(const EVP_PKEY_METHOD *pmeth)
197         {
198         if (app_pkey_methods == NULL)
199                 {
200                 app_pkey_methods = sk_new((sk_cmp_fn_type *)pmeth_cmp);
201                 if (!app_pkey_methods)
202                         return 0;
203                 }
204         if (!sk_push(app_pkey_methods, (char *)pmeth))
205                 return 0;
206         sk_sort(app_pkey_methods);
207         return 1;
208         }
209
210 void EVP_PKEY_CTX_free(EVP_PKEY_CTX *ctx)
211         {
212         if (ctx->pmeth && ctx->pmeth->cleanup)
213                 ctx->pmeth->cleanup(ctx);
214         if (ctx->pkey)
215                 EVP_PKEY_free(ctx->pkey);
216         if (ctx->peerkey)
217                 EVP_PKEY_free(ctx->peerkey);
218         OPENSSL_free(ctx);
219         }
220
221 int EVP_PKEY_CTX_ctrl(EVP_PKEY_CTX *ctx, int keytype, int optype,
222                                 int cmd, int p1, void *p2)
223         {
224         int ret;
225         if (!ctx || !ctx->pmeth || !ctx->pmeth->ctrl)
226                 {
227                 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_COMMAND_NOT_SUPPORTED);
228                 return -2;
229                 }
230         if ((keytype != -1) && (ctx->pmeth->pkey_id != keytype))
231                 return -1;
232
233         if (ctx->operation == EVP_PKEY_OP_UNDEFINED)
234                 {
235                 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_NO_OPERATION_SET);
236                 return -1;
237                 }
238
239         if ((optype != -1) && !(ctx->operation & optype))
240                 {
241                 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_INVALID_OPERATION);
242                 return -1;
243                 }
244
245         ret = ctx->pmeth->ctrl(ctx, cmd, p1, p2);
246
247         if (ret == -2)
248                 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_COMMAND_NOT_SUPPORTED);
249
250         return ret;
251
252         }
253
254 int EVP_PKEY_CTX_ctrl_str(EVP_PKEY_CTX *ctx,
255                                         const char *name, const char *value)
256         {
257         if (!ctx || !ctx->pmeth || !ctx->pmeth->ctrl_str)
258                 {
259                 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL_STR,
260                                                 EVP_R_COMMAND_NOT_SUPPORTED);
261                 return -2;
262                 }
263         if (!strcmp(name, "digest"))
264                 {
265                 const EVP_MD *md;
266                 if (!value || !(md = EVP_get_digestbyname(value)))
267                         {
268                         EVPerr(EVP_F_EVP_PKEY_CTX_CTRL_STR,
269                                                 EVP_R_INVALID_DIGEST);
270                         return 0;
271                         }
272                 return EVP_PKEY_CTX_set_signature_md(ctx, md);
273                 }
274         return ctx->pmeth->ctrl_str(ctx, name, value);
275         }
276
277 void EVP_PKEY_CTX_set_data(EVP_PKEY_CTX *ctx, void *data)
278         {
279         ctx->data = data;
280         }
281
282 void *EVP_PKEY_CTX_get_data(EVP_PKEY_CTX *ctx)
283         {
284         return ctx->data;
285         }
286
287 void EVP_PKEY_CTX_set_app_data(EVP_PKEY_CTX *ctx, void *data)
288         {
289         ctx->app_data = data;
290         }
291
292 void *EVP_PKEY_CTX_get_app_data(EVP_PKEY_CTX *ctx)
293         {
294         return ctx->app_data;
295         }
296
297 void EVP_PKEY_meth_set_init(EVP_PKEY_METHOD *pmeth,
298         int (*init)(EVP_PKEY_CTX *ctx))
299         {
300         pmeth->init = init;
301         }
302
303 void EVP_PKEY_meth_set_cleanup(EVP_PKEY_METHOD *pmeth,
304         void (*cleanup)(EVP_PKEY_CTX *ctx))
305         {
306         pmeth->cleanup = cleanup;
307         }
308
309 void EVP_PKEY_meth_set_paramgen(EVP_PKEY_METHOD *pmeth,
310         int (*paramgen_init)(EVP_PKEY_CTX *ctx),
311         int (*paramgen)(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey))
312         {
313         pmeth->paramgen_init = paramgen_init;
314         pmeth->paramgen = paramgen;
315         }
316
317 void EVP_PKEY_meth_set_keygen(EVP_PKEY_METHOD *pmeth,
318         int (*keygen_init)(EVP_PKEY_CTX *ctx),
319         int (*keygen)(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey))
320         {
321         pmeth->keygen_init = keygen_init;
322         pmeth->keygen = keygen;
323         }
324
325 void EVP_PKEY_meth_set_sign(EVP_PKEY_METHOD *pmeth,
326         int (*sign_init)(EVP_PKEY_CTX *ctx),
327         int (*sign)(EVP_PKEY_CTX *ctx, unsigned char *sig, int *siglen,
328                                         const unsigned char *tbs, int tbslen))
329         {
330         pmeth->sign_init = sign_init;
331         pmeth->sign = sign;
332         }
333
334 void EVP_PKEY_meth_set_verify(EVP_PKEY_METHOD *pmeth,
335         int (*verify_init)(EVP_PKEY_CTX *ctx),
336         int (*verify)(EVP_PKEY_CTX *ctx, const unsigned char *sig, int siglen,
337                                         const unsigned char *tbs, int tbslen))
338         {
339         pmeth->verify_init = verify_init;
340         pmeth->verify = verify;
341         }
342
343 void EVP_PKEY_meth_set_verify_recover(EVP_PKEY_METHOD *pmeth,
344         int (*verify_recover_init)(EVP_PKEY_CTX *ctx),
345         int (*verify_recover)(EVP_PKEY_CTX *ctx,
346                                         unsigned char *sig, int *siglen,
347                                         const unsigned char *tbs, int tbslen))
348         {
349         pmeth->verify_recover_init = verify_recover_init;
350         pmeth->verify_recover = verify_recover;
351         }
352
353 void EVP_PKEY_meth_set_signctx(EVP_PKEY_METHOD *pmeth,
354         int (*signctx_init)(EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx),
355         int (*signctx)(EVP_PKEY_CTX *ctx, unsigned char *sig, int *siglen,
356                                         EVP_MD_CTX *mctx))
357         {
358         pmeth->signctx_init = signctx_init;
359         pmeth->signctx = signctx;
360         }
361
362 void EVP_PKEY_meth_set_verifyctx(EVP_PKEY_METHOD *pmeth,
363         int (*verifyctx_init)(EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx),
364         int (*verifyctx)(EVP_PKEY_CTX *ctx, const unsigned char *sig,int siglen,
365                                         EVP_MD_CTX *mctx))
366         {
367         pmeth->verifyctx_init = verifyctx_init;
368         pmeth->verifyctx = verifyctx;
369         }
370
371 void EVP_PKEY_meth_set_encrypt(EVP_PKEY_METHOD *pmeth,
372         int (*encrypt_init)(EVP_PKEY_CTX *ctx),
373         int (*encrypt)(EVP_PKEY_CTX *ctx, unsigned char *out, int *outlen,
374                                         const unsigned char *in, int inlen))
375         {
376         pmeth->encrypt_init = encrypt_init;
377         pmeth->encrypt = encrypt;
378         }
379
380 void EVP_PKEY_meth_set_decrypt(EVP_PKEY_METHOD *pmeth,
381         int (*decrypt_init)(EVP_PKEY_CTX *ctx),
382         int (*decrypt)(EVP_PKEY_CTX *ctx, unsigned char *out, int *outlen,
383                                         const unsigned char *in, int inlen))
384         {
385         pmeth->decrypt_init = decrypt_init;
386         pmeth->decrypt = decrypt;
387         }
388
389 void EVP_PKEY_meth_set_derive(EVP_PKEY_METHOD *pmeth,
390         int (*derive_init)(EVP_PKEY_CTX *ctx),
391         int (*derive)(EVP_PKEY_CTX *ctx, unsigned char *key, int *keylen))
392         {
393         pmeth->derive_init = derive_init;
394         pmeth->derive = derive;
395         }
396
397 void EVP_PKEY_meth_set_ctrl(EVP_PKEY_METHOD *pmeth,
398         int (*ctrl)(EVP_PKEY_CTX *ctx, int type, int p1, void *p2),
399         int (*ctrl_str)(EVP_PKEY_CTX *ctx, const char *type, const char *value))
400         {
401         pmeth->ctrl = ctrl;
402         pmeth->ctrl_str = ctrl_str;
403         }