781494d1a96bbde8bb3bb124455afb1c57b1584e
[openssl.git] / crypto / engine / engine_lib.c
1 /* crypto/engine/engine_lib.c */
2 /* Written by Geoff Thorpe (geoff@geoffthorpe.net) for the OpenSSL
3  * project 2000.
4  */
5 /* ====================================================================
6  * Copyright (c) 1999 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 <openssl/crypto.h>
60 #include "cryptlib.h"
61 #include "engine_int.h"
62 #include <openssl/engine.h>
63
64 /* These pointers each have their own "functional reference" when they
65  * are non-NULL. Similarly, when they are retrieved by a call to
66  * ENGINE_get_default_[RSA|DSA|...] the returned pointer is also a
67  * reference and the caller is responsible for freeing that when they
68  * are finished with it (with a call to ENGINE_finish() *NOT* just
69  * ENGINE_free()!!!!!!). */
70 static ENGINE *engine_def_rsa = NULL;
71 static ENGINE *engine_def_dsa = NULL;
72 static ENGINE *engine_def_dh = NULL;
73 static ENGINE *engine_def_rand = NULL;
74 static ENGINE *engine_def_bn_mod_exp = NULL;
75 static ENGINE *engine_def_bn_mod_exp_crt = NULL;
76 /* A static "once-only" flag used to control if/when the above were
77  * initialised to suitable start-up defaults. */
78 static int engine_def_flag = 0;
79
80 /* This is used in certain static utility functions to save code
81  * repetition for per-algorithm functions. */
82 typedef enum {
83         ENGINE_TYPE_RSA,
84         ENGINE_TYPE_DSA,
85         ENGINE_TYPE_DH,
86         ENGINE_TYPE_RAND,
87         ENGINE_TYPE_BN_MOD_EXP,
88         ENGINE_TYPE_BN_MOD_EXP_CRT
89         } ENGINE_TYPE;
90
91 static void engine_def_check_util(ENGINE **def, ENGINE *val)
92         {
93         *def = val;
94         val->struct_ref++;
95         val->funct_ref++;
96         }
97
98 /* In a slight break with convention - this static function must be
99  * called *outside* any locking of CRYPTO_LOCK_ENGINE. */
100 static void engine_def_check(void)
101         {
102         ENGINE *e;
103         if(engine_def_flag)
104                 return;
105         e = ENGINE_get_first();
106         if(e == NULL)
107                 /* The list is empty ... not much we can do! */
108                 return;
109         /* We have a structural reference, see if getting a functional
110          * reference is possible. This is done to cope with init errors
111          * in the engine - the following locked code does a bunch of
112          * manual "ENGINE_init"s which do *not* allow such an init
113          * error so this is worth doing. */
114         if(ENGINE_init(e))
115                 {
116                 CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
117                 /* Doing another check here prevents an obvious race
118                  * condition because the whole function itself cannot
119                  * be locked. */
120                 if(engine_def_flag)
121                         goto skip_set_defaults;
122                 /* OK, we got a functional reference, so we get one each
123                  * for the defaults too. */
124                 engine_def_check_util(&engine_def_rsa, e);
125                 engine_def_check_util(&engine_def_dsa, e);
126                 engine_def_check_util(&engine_def_dh, e);
127                 engine_def_check_util(&engine_def_rand, e);
128                 engine_def_check_util(&engine_def_bn_mod_exp, e);
129                 engine_def_check_util(&engine_def_bn_mod_exp_crt, e);
130                 engine_def_flag = 1;
131 skip_set_defaults:
132                 CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
133                 /* The "if" needs to be balanced out. */
134                 ENGINE_finish(e);
135                 }
136         /* We need to balance out the fact we obtained a structural
137          * reference to begin with from ENGINE_get_first(). */
138         ENGINE_free(e);
139         }
140
141 /* Initialise a engine type for use (or up its functional reference count
142  * if it's already in use). */
143 int ENGINE_init(ENGINE *e)
144         {
145         int to_return = 1;
146
147         if(e == NULL)
148                 {
149                 ENGINEerr(ENGINE_F_ENGINE_INIT,ERR_R_PASSED_NULL_PARAMETER);
150                 return 0;
151                 }
152         CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
153         if((e->funct_ref == 0) && e->init)
154                 /* This is the first functional reference and the engine
155                  * requires initialisation so we do it now. */
156                 to_return = e->init();
157         if(to_return)
158                 {
159                 /* OK, we return a functional reference which is also a
160                  * structural reference. */
161                 e->struct_ref++;
162                 e->funct_ref++;
163                 }
164         CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
165         return to_return;
166         }
167
168 /* Free a functional reference to a engine type */
169 int ENGINE_finish(ENGINE *e)
170         {
171         int to_return = 1;
172
173         if(e == NULL)
174                 {
175                 ENGINEerr(ENGINE_F_ENGINE_FINISH,ERR_R_PASSED_NULL_PARAMETER);
176                 return 0;
177                 }
178         CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
179         if((e->funct_ref == 1) && e->finish)
180 #if 0
181                 /* This is the last functional reference and the engine
182                  * requires cleanup so we do it now. */
183                 to_return = e->finish();
184         if(to_return)
185                 {
186                 /* Cleanup the functional reference which is also a
187                  * structural reference. */
188                 e->struct_ref--;
189                 e->funct_ref--;
190                 }
191         CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
192 #else
193                 /* I'm going to deliberately do a convoluted version of this
194                  * piece of code because we don't want "finish" functions
195                  * being called inside a locked block of code, if at all
196                  * possible. I'd rather have this call take an extra couple
197                  * of ticks than have throughput serialised on a externally-
198                  * provided callback function that may conceivably never come
199                  * back. :-( */
200                 {
201                 CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
202                 /* CODE ALERT: This *IS* supposed to be "=" and NOT "==" :-) */
203                 if((to_return = e->finish()))
204                         {
205                         CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
206                         /* Cleanup the functional reference which is also a
207                          * structural reference. */
208                         e->struct_ref--;
209                         e->funct_ref--;
210                         CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
211                         }
212                 }
213         else
214                 CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
215 #endif
216         return to_return;
217         }
218
219 EVP_PKEY *ENGINE_load_private_key(ENGINE *e, const char *key_id,
220         const char *passphrase)
221         {
222         EVP_PKEY *pkey;
223
224         if(e == NULL)
225                 {
226                 ENGINEerr(ENGINE_F_ENGINE_LOAD_PRIVATE_KEY,
227                         ERR_R_PASSED_NULL_PARAMETER);
228                 return 0;
229                 }
230         CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
231         if(e->funct_ref == 0)
232                 {
233                 ENGINEerr(ENGINE_F_ENGINE_LOAD_PRIVATE_KEY,
234                         ENGINE_R_NOT_INITIALISED);
235                 return 0;
236                 }
237         if (!e->load_privkey)
238                 {
239                 ENGINEerr(ENGINE_F_ENGINE_LOAD_PRIVATE_KEY,
240                         ENGINE_R_NO_LOAD_FUNCTION);
241                 return 0;
242                 }
243         CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
244         pkey = e->load_privkey(key_id, passphrase);
245         if (!pkey)
246                 {
247                 ENGINEerr(ENGINE_F_ENGINE_LOAD_PRIVATE_KEY,
248                         ENGINE_R_FAILED_LOADING_PRIVATE_KEY);
249                 return 0;
250                 }
251         return pkey;
252         }
253
254 EVP_PKEY *ENGINE_load_public_key(ENGINE *e, const char *key_id,
255         const char *passphrase)
256         {
257         EVP_PKEY *pkey;
258
259         if(e == NULL)
260                 {
261                 ENGINEerr(ENGINE_F_ENGINE_LOAD_PUBLIC_KEY,
262                         ERR_R_PASSED_NULL_PARAMETER);
263                 return 0;
264                 }
265         CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
266         if(e->funct_ref == 0)
267                 {
268                 ENGINEerr(ENGINE_F_ENGINE_LOAD_PUBLIC_KEY,
269                         ENGINE_R_NOT_INITIALISED);
270                 return 0;
271                 }
272         if (!e->load_pubkey)
273                 {
274                 ENGINEerr(ENGINE_F_ENGINE_LOAD_PUBLIC_KEY,
275                         ENGINE_R_NO_LOAD_FUNCTION);
276                 return 0;
277                 }
278         CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
279         pkey = e->load_pubkey(key_id, passphrase);
280         if (!pkey)
281                 {
282                 ENGINEerr(ENGINE_F_ENGINE_LOAD_PUBLIC_KEY,
283                         ENGINE_R_FAILED_LOADING_PUBLIC_KEY);
284                 return 0;
285                 }
286         return pkey;
287         }
288
289 int ENGINE_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f)())
290         {
291         int ctrl_exists;
292         if(e == NULL)
293                 {
294                 ENGINEerr(ENGINE_F_ENGINE_CTRL,ERR_R_PASSED_NULL_PARAMETER);
295                 return 0;
296                 }
297         CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
298         if(e->struct_ref == 0)
299                 {
300                 ENGINEerr(ENGINE_F_ENGINE_CTRL,ENGINE_R_NO_REFERENCE);
301                 return 0;
302                 }
303         ctrl_exists = (e->ctrl ? 1 : 0);
304         CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
305         if (!ctrl_exists)
306                 {
307                 ENGINEerr(ENGINE_F_ENGINE_CTRL,ENGINE_R_NO_CONTROL_FUNCTION);
308                 return 0;
309                 }
310         return e->ctrl(cmd, i, p, f);
311         }
312
313 static ENGINE *engine_get_default_type(ENGINE_TYPE t)
314         {
315         ENGINE *ret = NULL;
316
317         /* engine_def_check is lean and mean and won't replace any
318          * prior default engines ... so we must ensure that it is always
319          * the first function to get to touch the default values. */
320         engine_def_check();
321         CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
322         switch(t)
323                 {
324         case ENGINE_TYPE_RSA:
325                 ret = engine_def_rsa; break;
326         case ENGINE_TYPE_DSA:
327                 ret = engine_def_dsa; break;
328         case ENGINE_TYPE_DH:
329                 ret = engine_def_dh; break;
330         case ENGINE_TYPE_RAND:
331                 ret = engine_def_rand; break;
332         case ENGINE_TYPE_BN_MOD_EXP:
333                 ret = engine_def_bn_mod_exp; break;
334         case ENGINE_TYPE_BN_MOD_EXP_CRT:
335                 ret = engine_def_bn_mod_exp_crt; break;
336                 }
337         /* Unforunately we can't do this work outside the lock with a
338          * call to ENGINE_init() because that would leave a race
339          * condition open. */
340         if(ret)
341                 {
342                 ret->struct_ref++;
343                 ret->funct_ref++;
344                 }
345         CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
346         return ret;
347         }
348
349 ENGINE *ENGINE_get_default_RSA(void)
350         {
351         return engine_get_default_type(ENGINE_TYPE_RSA);
352         }
353
354 ENGINE *ENGINE_get_default_DSA(void)
355         {
356         return engine_get_default_type(ENGINE_TYPE_DSA);
357         }
358
359 ENGINE *ENGINE_get_default_DH(void)
360         {
361         return engine_get_default_type(ENGINE_TYPE_DH);
362         }
363
364 ENGINE *ENGINE_get_default_RAND(void)
365         {
366         return engine_get_default_type(ENGINE_TYPE_RAND);
367         }
368
369 ENGINE *ENGINE_get_default_BN_mod_exp(void)
370         {
371         return engine_get_default_type(ENGINE_TYPE_BN_MOD_EXP);
372         }
373
374 ENGINE *ENGINE_get_default_BN_mod_exp_crt(void)
375         {
376         return engine_get_default_type(ENGINE_TYPE_BN_MOD_EXP_CRT);
377         }
378
379 static int engine_set_default_type(ENGINE_TYPE t, ENGINE *e)
380         {
381         ENGINE *old = NULL;
382
383         if(e == NULL)
384                 {
385                 ENGINEerr(ENGINE_F_ENGINE_SET_DEFAULT_TYPE,
386                         ERR_R_PASSED_NULL_PARAMETER);
387                 return 0;
388                 }
389         /* engine_def_check is lean and mean and won't replace any
390          * prior default engines ... so we must ensure that it is always
391          * the first function to get to touch the default values. */
392         engine_def_check();
393         /* Attempt to get a functional reference (we need one anyway, but
394          * also, 'e' may be just a structural reference being passed in so
395          * this call may actually be the first). */
396         if(!ENGINE_init(e))
397                 {
398                 ENGINEerr(ENGINE_F_ENGINE_SET_DEFAULT_TYPE,
399                         ENGINE_R_INIT_FAILED);
400                 return 0;
401                 }
402         CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
403         switch(t)
404                 {
405         case ENGINE_TYPE_RSA:
406                 old = engine_def_rsa;
407                 engine_def_rsa = e; break;
408         case ENGINE_TYPE_DSA:
409                 old = engine_def_dsa;
410                 engine_def_dsa = e; break;
411         case ENGINE_TYPE_DH:
412                 old = engine_def_dh;
413                 engine_def_dh = e; break;
414         case ENGINE_TYPE_RAND:
415                 old = engine_def_rand;
416                 engine_def_rand = e; break;
417         case ENGINE_TYPE_BN_MOD_EXP:
418                 old = engine_def_bn_mod_exp;
419                 engine_def_bn_mod_exp = e; break;
420         case ENGINE_TYPE_BN_MOD_EXP_CRT:
421                 old = engine_def_bn_mod_exp_crt;
422                 engine_def_bn_mod_exp_crt = e; break;
423                 }
424         CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
425         /* If we've replaced a previous value, then we need to remove the
426          * functional reference we had. */
427         if(old && !ENGINE_finish(old))
428                 {
429                 ENGINEerr(ENGINE_F_ENGINE_SET_DEFAULT_TYPE,
430                         ENGINE_R_FINISH_FAILED);
431                 return 0;
432                 }
433         return 1;
434         }
435
436 int ENGINE_set_default_RSA(ENGINE *e)
437         {
438         return engine_set_default_type(ENGINE_TYPE_RSA, e);
439         }
440
441 int ENGINE_set_default_DSA(ENGINE *e)
442         {
443         return engine_set_default_type(ENGINE_TYPE_DSA, e);
444         }
445
446 int ENGINE_set_default_DH(ENGINE *e)
447         {
448         return engine_set_default_type(ENGINE_TYPE_DH, e);
449         }
450
451 int ENGINE_set_default_RAND(ENGINE *e)
452         {
453         return engine_set_default_type(ENGINE_TYPE_RAND, e);
454         }
455
456 int ENGINE_set_default_BN_mod_exp(ENGINE *e)
457         {
458         return engine_set_default_type(ENGINE_TYPE_BN_MOD_EXP, e);
459         }
460
461 int ENGINE_set_default_BN_mod_exp_crt(ENGINE *e)
462         {
463         return engine_set_default_type(ENGINE_TYPE_BN_MOD_EXP_CRT, e);
464         }
465
466 int ENGINE_set_default(ENGINE *e, unsigned int flags)
467         {
468         if((flags & ENGINE_METHOD_RSA) && e->rsa_meth &&
469                         !ENGINE_set_default_RSA(e))
470                 return 0;
471         if((flags & ENGINE_METHOD_DSA) && e->dsa_meth &&
472                         !ENGINE_set_default_DSA(e))
473                 return 0;
474         if((flags & ENGINE_METHOD_DH) && e->dh_meth &&
475                         !ENGINE_set_default_DH(e))
476                 return 0;
477         if((flags & ENGINE_METHOD_RAND) && e->rand_meth &&
478                         !ENGINE_set_default_RAND(e))
479                 return 0;
480         if((flags & ENGINE_METHOD_BN_MOD_EXP) && e->bn_mod_exp &&
481                         !ENGINE_set_default_BN_mod_exp(e))
482                 return 0;
483         if((flags & ENGINE_METHOD_BN_MOD_EXP_CRT) && e->bn_mod_exp_crt &&
484                         !ENGINE_set_default_BN_mod_exp_crt(e))
485                 return 0;
486         return 1;
487         }
488