cefaec36f2aaf283bfcceee79c265cd9f46cbc50
[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                 CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
234                 ENGINEerr(ENGINE_F_ENGINE_LOAD_PRIVATE_KEY,
235                         ENGINE_R_NOT_INITIALISED);
236                 return 0;
237                 }
238         CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
239         if (!e->load_privkey)
240                 {
241                 ENGINEerr(ENGINE_F_ENGINE_LOAD_PRIVATE_KEY,
242                         ENGINE_R_NO_LOAD_FUNCTION);
243                 return 0;
244                 }
245         pkey = e->load_privkey(key_id, passphrase);
246         if (!pkey)
247                 {
248                 ENGINEerr(ENGINE_F_ENGINE_LOAD_PRIVATE_KEY,
249                         ENGINE_R_FAILED_LOADING_PRIVATE_KEY);
250                 return 0;
251                 }
252         return pkey;
253         }
254
255 EVP_PKEY *ENGINE_load_public_key(ENGINE *e, const char *key_id,
256         const char *passphrase)
257         {
258         EVP_PKEY *pkey;
259
260         if(e == NULL)
261                 {
262                 ENGINEerr(ENGINE_F_ENGINE_LOAD_PUBLIC_KEY,
263                         ERR_R_PASSED_NULL_PARAMETER);
264                 return 0;
265                 }
266         CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
267         if(e->funct_ref == 0)
268                 {
269                 CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
270                 ENGINEerr(ENGINE_F_ENGINE_LOAD_PUBLIC_KEY,
271                         ENGINE_R_NOT_INITIALISED);
272                 return 0;
273                 }
274         CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
275         if (!e->load_pubkey)
276                 {
277                 ENGINEerr(ENGINE_F_ENGINE_LOAD_PUBLIC_KEY,
278                         ENGINE_R_NO_LOAD_FUNCTION);
279                 return 0;
280                 }
281         pkey = e->load_pubkey(key_id, passphrase);
282         if (!pkey)
283                 {
284                 ENGINEerr(ENGINE_F_ENGINE_LOAD_PUBLIC_KEY,
285                         ENGINE_R_FAILED_LOADING_PUBLIC_KEY);
286                 return 0;
287                 }
288         return pkey;
289         }
290
291 int ENGINE_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f)())
292         {
293         int ctrl_exists, ref_exists;
294         if(e == NULL)
295                 {
296                 ENGINEerr(ENGINE_F_ENGINE_CTRL,ERR_R_PASSED_NULL_PARAMETER);
297                 return 0;
298                 }
299         CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
300         ref_exists = ((e->struct_ref > 0) ? 1 : 0);
301         ctrl_exists = (e->ctrl ? 1 : 0);
302         CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
303         if(!ref_exists)
304                 {
305                 ENGINEerr(ENGINE_F_ENGINE_CTRL,ENGINE_R_NO_REFERENCE);
306                 return 0;
307                 }
308         if (!ctrl_exists)
309                 {
310                 ENGINEerr(ENGINE_F_ENGINE_CTRL,ENGINE_R_NO_CONTROL_FUNCTION);
311                 return 0;
312                 }
313         return e->ctrl(cmd, i, p, f);
314         }
315
316 static ENGINE *engine_get_default_type(ENGINE_TYPE t)
317         {
318         ENGINE *ret = NULL;
319
320         /* engine_def_check is lean and mean and won't replace any
321          * prior default engines ... so we must ensure that it is always
322          * the first function to get to touch the default values. */
323         engine_def_check();
324         CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
325         switch(t)
326                 {
327         case ENGINE_TYPE_RSA:
328                 ret = engine_def_rsa; break;
329         case ENGINE_TYPE_DSA:
330                 ret = engine_def_dsa; break;
331         case ENGINE_TYPE_DH:
332                 ret = engine_def_dh; break;
333         case ENGINE_TYPE_RAND:
334                 ret = engine_def_rand; break;
335         case ENGINE_TYPE_BN_MOD_EXP:
336                 ret = engine_def_bn_mod_exp; break;
337         case ENGINE_TYPE_BN_MOD_EXP_CRT:
338                 ret = engine_def_bn_mod_exp_crt; break;
339                 }
340         /* Unforunately we can't do this work outside the lock with a
341          * call to ENGINE_init() because that would leave a race
342          * condition open. */
343         if(ret)
344                 {
345                 ret->struct_ref++;
346                 ret->funct_ref++;
347                 }
348         CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
349         return ret;
350         }
351
352 ENGINE *ENGINE_get_default_RSA(void)
353         {
354         return engine_get_default_type(ENGINE_TYPE_RSA);
355         }
356
357 ENGINE *ENGINE_get_default_DSA(void)
358         {
359         return engine_get_default_type(ENGINE_TYPE_DSA);
360         }
361
362 ENGINE *ENGINE_get_default_DH(void)
363         {
364         return engine_get_default_type(ENGINE_TYPE_DH);
365         }
366
367 ENGINE *ENGINE_get_default_RAND(void)
368         {
369         return engine_get_default_type(ENGINE_TYPE_RAND);
370         }
371
372 ENGINE *ENGINE_get_default_BN_mod_exp(void)
373         {
374         return engine_get_default_type(ENGINE_TYPE_BN_MOD_EXP);
375         }
376
377 ENGINE *ENGINE_get_default_BN_mod_exp_crt(void)
378         {
379         return engine_get_default_type(ENGINE_TYPE_BN_MOD_EXP_CRT);
380         }
381
382 static int engine_set_default_type(ENGINE_TYPE t, ENGINE *e)
383         {
384         ENGINE *old = NULL;
385
386         if(e == NULL)
387                 {
388                 ENGINEerr(ENGINE_F_ENGINE_SET_DEFAULT_TYPE,
389                         ERR_R_PASSED_NULL_PARAMETER);
390                 return 0;
391                 }
392         /* engine_def_check is lean and mean and won't replace any
393          * prior default engines ... so we must ensure that it is always
394          * the first function to get to touch the default values. */
395         engine_def_check();
396         /* Attempt to get a functional reference (we need one anyway, but
397          * also, 'e' may be just a structural reference being passed in so
398          * this call may actually be the first). */
399         if(!ENGINE_init(e))
400                 {
401                 ENGINEerr(ENGINE_F_ENGINE_SET_DEFAULT_TYPE,
402                         ENGINE_R_INIT_FAILED);
403                 return 0;
404                 }
405         CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
406         switch(t)
407                 {
408         case ENGINE_TYPE_RSA:
409                 old = engine_def_rsa;
410                 engine_def_rsa = e; break;
411         case ENGINE_TYPE_DSA:
412                 old = engine_def_dsa;
413                 engine_def_dsa = e; break;
414         case ENGINE_TYPE_DH:
415                 old = engine_def_dh;
416                 engine_def_dh = e; break;
417         case ENGINE_TYPE_RAND:
418                 old = engine_def_rand;
419                 engine_def_rand = e; break;
420         case ENGINE_TYPE_BN_MOD_EXP:
421                 old = engine_def_bn_mod_exp;
422                 engine_def_bn_mod_exp = e; break;
423         case ENGINE_TYPE_BN_MOD_EXP_CRT:
424                 old = engine_def_bn_mod_exp_crt;
425                 engine_def_bn_mod_exp_crt = e; break;
426                 }
427         CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
428         /* If we've replaced a previous value, then we need to remove the
429          * functional reference we had. */
430         if(old && !ENGINE_finish(old))
431                 {
432                 ENGINEerr(ENGINE_F_ENGINE_SET_DEFAULT_TYPE,
433                         ENGINE_R_FINISH_FAILED);
434                 return 0;
435                 }
436         return 1;
437         }
438
439 int ENGINE_set_default_RSA(ENGINE *e)
440         {
441         return engine_set_default_type(ENGINE_TYPE_RSA, e);
442         }
443
444 int ENGINE_set_default_DSA(ENGINE *e)
445         {
446         return engine_set_default_type(ENGINE_TYPE_DSA, e);
447         }
448
449 int ENGINE_set_default_DH(ENGINE *e)
450         {
451         return engine_set_default_type(ENGINE_TYPE_DH, e);
452         }
453
454 int ENGINE_set_default_RAND(ENGINE *e)
455         {
456         return engine_set_default_type(ENGINE_TYPE_RAND, e);
457         }
458
459 int ENGINE_set_default_BN_mod_exp(ENGINE *e)
460         {
461         return engine_set_default_type(ENGINE_TYPE_BN_MOD_EXP, e);
462         }
463
464 int ENGINE_set_default_BN_mod_exp_crt(ENGINE *e)
465         {
466         return engine_set_default_type(ENGINE_TYPE_BN_MOD_EXP_CRT, e);
467         }
468
469 int ENGINE_set_default(ENGINE *e, unsigned int flags)
470         {
471         if((flags & ENGINE_METHOD_RSA) && e->rsa_meth &&
472                         !ENGINE_set_default_RSA(e))
473                 return 0;
474         if((flags & ENGINE_METHOD_DSA) && e->dsa_meth &&
475                         !ENGINE_set_default_DSA(e))
476                 return 0;
477         if((flags & ENGINE_METHOD_DH) && e->dh_meth &&
478                         !ENGINE_set_default_DH(e))
479                 return 0;
480         if((flags & ENGINE_METHOD_RAND) && e->rand_meth &&
481                         !ENGINE_set_default_RAND(e))
482                 return 0;
483         if((flags & ENGINE_METHOD_BN_MOD_EXP) && e->bn_mod_exp &&
484                         !ENGINE_set_default_BN_mod_exp(e))
485                 return 0;
486         if((flags & ENGINE_METHOD_BN_MOD_EXP_CRT) && e->bn_mod_exp_crt &&
487                         !ENGINE_set_default_BN_mod_exp_crt(e))
488                 return 0;
489         return 1;
490         }
491