4139a16e76dcec990b8c2b087350e8db683a73b9
[openssl.git] / crypto / engine / eng_dyn.c
1 /* crypto/engine/eng_dyn.c */
2 /* Written by Geoff Thorpe (geoff@geoffthorpe.net) for the OpenSSL
3  * project 2001.
4  */
5 /* ====================================================================
6  * Copyright (c) 1999-2001 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
60 #include <stdio.h>
61 #include <openssl/crypto.h>
62 #include "cryptlib.h"
63 #include "eng_int.h"
64 #include <openssl/engine.h>
65 #include <openssl/dso.h>
66
67 /* Shared libraries implementing ENGINEs for use by the "dynamic" ENGINE loader
68  * should implement the hook-up functions with the following prototypes. */
69
70 /* Our ENGINE handlers */
71 static int dynamic_init(ENGINE *e);
72 static int dynamic_finish(ENGINE *e);
73 static int dynamic_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f)());
74 /* Predeclare our context type */
75 typedef struct st_dynamic_data_ctx dynamic_data_ctx;
76 /* The implementation for the important control command */
77 static int dynamic_load(ENGINE *e, dynamic_data_ctx *ctx);
78
79 #define DYNAMIC_CMD_SO_PATH             ENGINE_CMD_BASE
80 #define DYNAMIC_CMD_NO_VCHECK           (ENGINE_CMD_BASE + 1)
81 #define DYNAMIC_CMD_ID                  (ENGINE_CMD_BASE + 2)
82 #define DYNAMIC_CMD_LIST_ADD            (ENGINE_CMD_BASE + 3)
83 #define DYNAMIC_CMD_LOAD                (ENGINE_CMD_BASE + 4)
84
85 /* The constants used when creating the ENGINE */
86 static const char *engine_dynamic_id = "dynamic";
87 static const char *engine_dynamic_name = "Dynamic engine loading support";
88 static const ENGINE_CMD_DEFN dynamic_cmd_defns[] = {
89         {DYNAMIC_CMD_SO_PATH,
90                 "SO_PATH",
91                 "Specifies the path to the new ENGINE shared library",
92                 ENGINE_CMD_FLAG_STRING},
93         {DYNAMIC_CMD_NO_VCHECK,
94                 "NO_VCHECK",
95                 "Specifies to continue even if version checking fails (boolean)",
96                 ENGINE_CMD_FLAG_NUMERIC},
97         {DYNAMIC_CMD_ID,
98                 "ID",
99                 "Specifies an ENGINE id name for loading",
100                 ENGINE_CMD_FLAG_STRING},
101         {DYNAMIC_CMD_LIST_ADD,
102                 "LIST_ADD",
103                 "Whether to add a loaded ENGINE to the internal list (0=no,1=yes,2=mandatory)",
104                 ENGINE_CMD_FLAG_NUMERIC},
105         {DYNAMIC_CMD_LOAD,
106                 "LOAD",
107                 "Load up the ENGINE specified by other settings",
108                 ENGINE_CMD_FLAG_NO_INPUT},
109         {0, NULL, NULL, 0}
110         };
111 static const ENGINE_CMD_DEFN dynamic_cmd_defns_empty[] = {
112         {0, NULL, NULL, 0}
113         };
114
115 /* Loading code stores state inside the ENGINE structure via the "ex_data"
116  * element. We load all our state into a single structure and use that as a
117  * single context in the "ex_data" stack. */
118 struct st_dynamic_data_ctx
119         {
120         /* The DSO object we load that supplies the ENGINE code */
121         DSO *dynamic_dso;
122         /* The function pointer to the version checking shared library function */
123         dynamic_v_check_fn v_check;
124         /* The function pointer to the engine-binding shared library function */
125         dynamic_bind_engine bind_engine;
126         /* The default name/path for loading the shared library */
127         const char *DYNAMIC_LIBNAME;
128         /* Whether to continue loading on a version check failure */
129         int no_vcheck;
130         /* If non-NULL, stipulates the 'id' of the ENGINE to be loaded */
131         const char *engine_id;
132         /* If non-zero, a successfully loaded ENGINE should be added to the internal
133          * ENGINE list. If 2, the add must succeed or the entire load should fail. */
134         int list_add_value;
135         /* The symbol name for the version checking function */
136         const char *DYNAMIC_F1;
137         /* The symbol name for the "initialise ENGINE structure" function */
138         const char *DYNAMIC_F2;
139         };
140
141 /* This is the "ex_data" index we obtain and reserve for use with our context
142  * structure. */
143 static int dynamic_ex_data_idx = -1;
144
145 /* Because our ex_data element may or may not get allocated depending on whether
146  * a "first-use" occurs before the ENGINE is freed, we have a memory leak
147  * problem to solve. We can't declare a "new" handler for the ex_data as we
148  * don't want a dynamic_data_ctx in *all* ENGINE structures of all types (this
149  * is a bug in the design of CRYPTO_EX_DATA). As such, we just declare a "free"
150  * handler and that will get called if an ENGINE is being destroyed and there
151  * was an ex_data element corresponding to our context type. */
152 static void dynamic_data_ctx_free_func(void *parent, void *ptr,
153                         CRYPTO_EX_DATA *ad, int idx, long argl, void *argp)
154         {
155         if(ptr)
156                 {
157                 dynamic_data_ctx *ctx = (dynamic_data_ctx *)ptr;
158                 if(ctx->dynamic_dso)
159                         DSO_free(ctx->dynamic_dso);
160                 if(ctx->DYNAMIC_LIBNAME)
161                         OPENSSL_free((void*)ctx->DYNAMIC_LIBNAME);
162                 if(ctx->engine_id)
163                         OPENSSL_free((void*)ctx->engine_id);
164                 OPENSSL_free(ctx);
165                 }
166         }
167
168 /* Construct the per-ENGINE context. We create it blindly and then use a lock to
169  * check for a race - if so, all but one of the threads "racing" will have
170  * wasted their time. The alternative involves creating everything inside the
171  * lock which is far worse. */
172 static int dynamic_set_data_ctx(ENGINE *e, dynamic_data_ctx **ctx)
173         {
174         dynamic_data_ctx *c;
175         c = OPENSSL_malloc(sizeof(dynamic_data_ctx));
176         if(!c)
177                 {
178                 ENGINEerr(ENGINE_F_SET_DATA_CTX,ERR_R_MALLOC_FAILURE);
179                 return 0;
180                 }
181         memset(c, 0, sizeof(dynamic_data_ctx));
182         c->dynamic_dso = NULL;
183         c->v_check = NULL;
184         c->bind_engine = NULL;
185         c->DYNAMIC_LIBNAME = NULL;
186         c->no_vcheck = 0;
187         c->engine_id = NULL;
188         c->list_add_value = 0;
189         c->DYNAMIC_F1 = "v_check";
190         c->DYNAMIC_F2 = "bind_engine";
191         CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
192         if((*ctx = (dynamic_data_ctx *)ENGINE_get_ex_data(e,
193                                 dynamic_ex_data_idx)) == NULL)
194                 {
195                 /* Good, we're the first */
196                 ENGINE_set_ex_data(e, dynamic_ex_data_idx, c);
197                 *ctx = c;
198                 c = NULL;
199                 }
200         CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
201         /* If we lost the race to set the context, c is non-NULL and *ctx is the
202          * context of the thread that won. */
203         if(c)
204                 OPENSSL_free(c);
205         return 1;
206         }
207
208 /* This function retrieves the context structure from an ENGINE's "ex_data", or
209  * if it doesn't exist yet, sets it up. */
210 static dynamic_data_ctx *dynamic_get_data_ctx(ENGINE *e)
211         {
212         dynamic_data_ctx *ctx;
213         if(dynamic_ex_data_idx < 0)
214                 {
215                 /* Create and register the ENGINE ex_data, and associate our
216                  * "free" function with it to ensure any allocated contexts get
217                  * freed when an ENGINE goes underground. */
218                 int new_idx = ENGINE_get_ex_new_index(0, NULL, NULL, NULL,
219                                         dynamic_data_ctx_free_func);
220                 if(new_idx == -1)
221                         {
222                         ENGINEerr(ENGINE_F_DYNAMIC_GET_DATA_CTX,ENGINE_R_NO_INDEX);
223                         return NULL;
224                         }
225                 CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
226                 /* Avoid a race by checking again inside this lock */
227                 if(dynamic_ex_data_idx < 0)
228                         {
229                         /* Good, someone didn't beat us to it */
230                         dynamic_ex_data_idx = new_idx;
231                         new_idx = -1;
232                         }
233                 CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
234                 /* In theory we could "give back" the index here if
235                  * (new_idx>-1), but it's not possible and wouldn't gain us much
236                  * if it were. */
237                 }
238         ctx = (dynamic_data_ctx *)ENGINE_get_ex_data(e, dynamic_ex_data_idx);
239         /* Check if the context needs to be created */
240         if((ctx == NULL) && !dynamic_set_data_ctx(e, &ctx))
241                 /* "set_data" will set errors if necessary */
242                 return NULL;
243         return ctx;
244         }
245
246 static ENGINE *engine_dynamic(void)
247         {
248         ENGINE *ret = ENGINE_new();
249         if(!ret)
250                 return NULL;
251         if(!ENGINE_set_id(ret, engine_dynamic_id) ||
252                         !ENGINE_set_name(ret, engine_dynamic_name) ||
253                         !ENGINE_set_init_function(ret, dynamic_init) ||
254                         !ENGINE_set_finish_function(ret, dynamic_finish) ||
255                         !ENGINE_set_ctrl_function(ret, dynamic_ctrl) ||
256                         !ENGINE_set_flags(ret, ENGINE_FLAGS_BY_ID_COPY) ||
257                         !ENGINE_set_cmd_defns(ret, dynamic_cmd_defns))
258                 {
259                 ENGINE_free(ret);
260                 return NULL;
261                 }
262         return ret;
263         }
264
265 void ENGINE_load_dynamic(void)
266         {
267         ENGINE *toadd = engine_dynamic();
268         if(!toadd) return;
269         ENGINE_add(toadd);
270         /* If the "add" worked, it gets a structural reference. So either way,
271          * we release our just-created reference. */
272         ENGINE_free(toadd);
273         /* If the "add" didn't work, it was probably a conflict because it was
274          * already added (eg. someone calling ENGINE_load_blah then calling
275          * ENGINE_load_builtin_engines() perhaps). */
276         ERR_clear_error();
277         }
278
279 static int dynamic_init(ENGINE *e)
280         {
281         /* We always return failure - the "dyanamic" engine itself can't be used
282          * for anything. */
283         return 0;
284         }
285
286 static int dynamic_finish(ENGINE *e)
287         {
288         /* This should never be called on account of "dynamic_init" always
289          * failing. */
290         return 0;
291         }
292
293 static int dynamic_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f)())
294         {
295         dynamic_data_ctx *ctx = dynamic_get_data_ctx(e);
296         int initialised;
297         
298         if(!ctx)
299                 {
300                 ENGINEerr(ENGINE_F_DYNAMIC_CTRL,ENGINE_R_NOT_LOADED);
301                 return 0;
302                 }
303         initialised = ((ctx->dynamic_dso == NULL) ? 0 : 1);
304         /* All our control commands require the ENGINE to be uninitialised */
305         if(initialised)
306                 {
307                 ENGINEerr(ENGINE_F_DYNAMIC_CTRL,
308                         ENGINE_R_ALREADY_LOADED);
309                 return 0;
310                 }
311         switch(cmd)
312                 {
313         case DYNAMIC_CMD_SO_PATH:
314                 /* a NULL 'p' or a string of zero-length is the same thing */
315                 if(p && (strlen((const char *)p) < 1))
316                         p = NULL;
317                 if(ctx->DYNAMIC_LIBNAME)
318                         OPENSSL_free((void*)ctx->DYNAMIC_LIBNAME);
319                 if(p)
320                         ctx->DYNAMIC_LIBNAME = BUF_strdup(p);
321                 else
322                         ctx->DYNAMIC_LIBNAME = NULL;
323                 return (ctx->DYNAMIC_LIBNAME ? 1 : 0);
324         case DYNAMIC_CMD_NO_VCHECK:
325                 ctx->no_vcheck = ((i == 0) ? 0 : 1);
326                 return 1;
327         case DYNAMIC_CMD_ID:
328                 /* a NULL 'p' or a string of zero-length is the same thing */
329                 if(p && (strlen((const char *)p) < 1))
330                         p = NULL;
331                 if(ctx->engine_id)
332                         OPENSSL_free((void*)ctx->engine_id);
333                 if(p)
334                         ctx->engine_id = BUF_strdup(p);
335                 else
336                         ctx->engine_id = NULL;
337                 return (ctx->engine_id ? 1 : 0);
338         case DYNAMIC_CMD_LIST_ADD:
339                 if((i < 0) || (i > 2))
340                         {
341                         ENGINEerr(ENGINE_F_DYNAMIC_CTRL,
342                                 ENGINE_R_INVALID_ARGUMENT);
343                         return 0;
344                         }
345                 ctx->list_add_value = (int)i;
346                 return 1;
347         case DYNAMIC_CMD_LOAD:
348                 return dynamic_load(e, ctx);
349         default:
350                 break;
351                 }
352         ENGINEerr(ENGINE_F_DYNAMIC_CTRL,ENGINE_R_CTRL_COMMAND_NOT_IMPLEMENTED);
353         return 0;
354         }
355
356 static int dynamic_load(ENGINE *e, dynamic_data_ctx *ctx)
357         {
358         ENGINE cpy;
359         dynamic_fns fns;
360
361         if(!ctx->DYNAMIC_LIBNAME || ((ctx->dynamic_dso = DSO_load(NULL,
362                                 ctx->DYNAMIC_LIBNAME, NULL, 0)) == NULL))
363                 {
364                 ENGINEerr(ENGINE_F_DYNAMIC_LOAD,
365                         ENGINE_R_DSO_NOT_FOUND);
366                 return 0;
367                 }
368         /* We have to find a bind function otherwise it'll always end badly */
369         if(!(ctx->bind_engine = (dynamic_bind_engine)DSO_bind_func(
370                                         ctx->dynamic_dso, ctx->DYNAMIC_F2)))
371                 {
372                 ctx->bind_engine = NULL;
373                 DSO_free(ctx->dynamic_dso);
374                 ctx->dynamic_dso = NULL;
375                 ENGINEerr(ENGINE_F_DYNAMIC_LOAD,
376                         ENGINE_R_DSO_FAILURE);
377                 return 0;
378                 }
379         /* Do we perform version checking? */
380         if(!ctx->no_vcheck)
381                 {
382                 unsigned long vcheck_res = 0;
383                 /* Now we try to find a version checking function and decide how
384                  * to cope with failure if/when it fails. */
385                 ctx->v_check = (dynamic_v_check_fn)DSO_bind_func(
386                                 ctx->dynamic_dso, ctx->DYNAMIC_F1);
387                 if(ctx->v_check)
388                         vcheck_res = ctx->v_check(OSSL_DYNAMIC_VERSION);
389                 /* We fail if the version checker veto'd the load *or* if it is
390                  * deferring to us (by returning its version) and we think it is
391                  * too old. */
392                 if(vcheck_res < OSSL_DYNAMIC_OLDEST)
393                         {
394                         /* Fail */
395                         ctx->bind_engine = NULL;
396                         ctx->v_check = NULL;
397                         DSO_free(ctx->dynamic_dso);
398                         ctx->dynamic_dso = NULL;
399                         ENGINEerr(ENGINE_F_DYNAMIC_LOAD,
400                                 ENGINE_R_VERSION_INCOMPATIBILITY);
401                         return 0;
402                         }
403                 }
404         /* First binary copy the ENGINE structure so that we can roll back if
405          * the hand-over fails */
406         memcpy(&cpy, e, sizeof(ENGINE));
407         /* Provide the ERR, "ex_data", memory, and locking callbacks so the
408          * loaded library uses our state rather than its own. FIXME: As noted in
409          * engine.h, much of this would be simplified if each area of code
410          * provided its own "summary" structure of all related callbacks. It
411          * would also increase opaqueness. */
412         fns.err_fns = ERR_get_implementation();
413         fns.ex_data_fns = CRYPTO_get_ex_data_implementation();
414         CRYPTO_get_mem_functions(&fns.mem_fns.malloc_cb,
415                                 &fns.mem_fns.realloc_cb,
416                                 &fns.mem_fns.free_cb);
417         fns.lock_fns.lock_locking_cb = CRYPTO_get_locking_callback();
418         fns.lock_fns.lock_add_lock_cb = CRYPTO_get_add_lock_callback();
419         fns.lock_fns.dynlock_create_cb = CRYPTO_get_dynlock_create_callback();
420         fns.lock_fns.dynlock_lock_cb = CRYPTO_get_dynlock_lock_callback();
421         fns.lock_fns.dynlock_destroy_cb = CRYPTO_get_dynlock_destroy_callback();
422         /* Now that we've loaded the dynamic engine, make sure no "dynamic"
423          * ENGINE elements will show through. */
424         engine_set_all_null(e);
425
426         /* Try to bind the ENGINE onto our own ENGINE structure */
427         if(!ctx->bind_engine(e, ctx->engine_id, &fns))
428                 {
429                 ctx->bind_engine = NULL;
430                 ctx->v_check = NULL;
431                 DSO_free(ctx->dynamic_dso);
432                 ctx->dynamic_dso = NULL;
433                 ENGINEerr(ENGINE_F_DYNAMIC_LOAD,ENGINE_R_INIT_FAILED);
434                 /* Copy the original ENGINE structure back */
435                 memcpy(e, &cpy, sizeof(ENGINE));
436                 return 0;
437                 }
438         /* Do we try to add this ENGINE to the internal list too? */
439         if(ctx->list_add_value > 0)
440                 {
441                 if(!ENGINE_add(e))
442                         {
443                         /* Do we tolerate this or fail? */
444                         if(ctx->list_add_value > 1)
445                                 {
446                                 /* Fail - NB: By this time, it's too late to
447                                  * rollback, and trying to do so allows the
448                                  * bind_engine() code to have created leaks. We
449                                  * just have to fail where we are, after the
450                                  * ENGINE has changed. */
451                                 ENGINEerr(ENGINE_F_DYNAMIC_LOAD,
452                                         ENGINE_R_CONFLICTING_ENGINE_ID);
453                                 return 0;
454                                 }
455                         /* Tolerate */
456                         ERR_clear_error();
457                         }
458                 }
459         return 1;
460         }