crypto/dist/heimdal/lib/hcrypto/engine.c

   1 /*
   2  * Copyright (c) 2006 Kungliga Tekniska Högskolan
   3  * (Royal Institute of Technology, Stockholm, Sweden).
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  *
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * 3. Neither the name of the Institute nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33
  34 #ifdef HAVE_CONFIG_H
  35 #include <config.h>
  36 #endif
  37
  38 __RCSID("$Heimdal: engine.c 20828 2007-06-03 05:10:20Z lha $"
  39         "$NetBSD$");
  40
  41 #include <stdio.h>
  42 #include <stdlib.h>
  43 #include <string.h>
  44
  45 #include <engine.h>
  46
  47 #ifdef HAVE_DLFCN_H
  48 #include <dlfcn.h>
  49 #ifndef RTLD_NOW
  50 #define RTLD_NOW 0
  51 #endif
  52 #endif
  53
  54 struct hc_engine {
  55     int references;
  56     char *name;
  57     char *id;
  58     void (*destroy)(ENGINE *);
  59     const RSA_METHOD *rsa;
  60     const DH_METHOD *dh;
  61     const RAND_METHOD *rand;
  62 };
  63
  64 int
  65 ENGINE_finish(ENGINE *engine)
  66 {
  67     if (engine->references-- <= 0)
  68         abort();
  69     if (engine->references > 0)
  70         return 1;
  71
  72     if (engine->name)
  73         free(engine->name);
  74     if (engine->id)
  75         free(engine->id);
  76     if(engine->destroy)
  77         (*engine->destroy)(engine);
  78
  79     memset(engine, 0, sizeof(engine));
  80     engine->references = -1;
  81
  82
  83     free(engine);
  84     return 1;
  85 }
  86
  87 int
  88 ENGINE_up_ref(ENGINE *engine)
  89 {
  90     if (engine->references < 0)
  91         abort();
  92     engine->references++;
  93     return 1;
  94 }
  95
  96 int
  97 ENGINE_set_id(ENGINE *engine, const char *id)
  98 {
  99     engine->id = strdup(id);
 100     return (engine->id == NULL) ? 0 : 1;
 101 }
 102
 103 int
 104 ENGINE_set_name(ENGINE *engine, const char *name)
 105 {
 106     engine->name = strdup(name);
 107     return (engine->name == NULL) ? 0 : 1;
 108 }
 109
 110 int
 111 ENGINE_set_RSA(ENGINE *engine, const RSA_METHOD *method)
 112 {
 113     engine->rsa = method;
 114     return 1;
 115 }
 116
 117 int
 118 ENGINE_set_DH(ENGINE *engine, const DH_METHOD *method)
 119 {
 120     engine->dh = method;
 121     return 1;
 122 }
 123
 124 int
 125 ENGINE_set_destroy_function(ENGINE *e, void (*destroy)(ENGINE *))
 126 {
 127     e->destroy = destroy;
 128     return 1;
 129 }
 130
 131 const char *
 132 ENGINE_get_id(const ENGINE *engine)
 133 {
 134     return engine->id;
 135 }
 136
 137 const char *
 138 ENGINE_get_name(const ENGINE *engine)
 139 {
 140     return engine->name;
 141 }
 142
 143 const RSA_METHOD *
 144 ENGINE_get_RSA(const ENGINE *engine)
 145 {
 146     return engine->rsa;
 147 }
 148
 149 const DH_METHOD *
 150 ENGINE_get_DH(const ENGINE *engine)
 151 {
 152     return engine->dh;
 153 }
 154
 155 const RAND_METHOD *
 156 ENGINE_get_RAND(const ENGINE *engine)
 157 {
 158     return engine->rand;
 159 }
 160
 161 /*
 162  *
 163  */
 164
 165 #define SG_default_engine(type)                 \
 166 static ENGINE *type##_engine;                   \
 167 int                                             \
 168 ENGINE_set_default_##type(ENGINE *engine)       \
 169 {                                               \
 170     if (type##_engine)                          \
 171         ENGINE_finish(type##_engine);           \
 172     type##_engine = engine;                     \
 173     if (type##_engine)                          \
 174         ENGINE_up_ref(type##_engine);           \
 175     return 1;                                   \
 176 }                                               \
 177 ENGINE *                                        \
 178 ENGINE_get_default_##type(void)                 \
 179 {                                               \
 180     if (type##_engine)                          \
 181         ENGINE_up_ref(type##_engine);           \
 182     return type##_engine;                       \
 183 }
 184
 185 SG_default_engine(RSA)
 186 SG_default_engine(DH)
 187
 188 #undef SG_default_engine
 189
 190 /*
 191  *
 192  */
 193
 194 static ENGINE **engines;
 195 static unsigned int num_engines;
 196
 197 static int
 198 add_engine(ENGINE *engine)
 199 {
 200     ENGINE **d, *dup;
 201
 202     dup = ENGINE_by_id(engine->id);
 203     if (dup) {
 204         ENGINE_finish(dup);
 205         return 0;
 206     }
 207
 208     d = realloc(engines, (num_engines + 1) * sizeof(*engines));
 209     if (d == NULL)
 210         return 1;
 211     engines = d;
 212     engines[num_engines++] = engine;
 213
 214     return 1;
 215 }
 216
 217 void
 218 ENGINE_load_builtin_engines(void)
 219 {
 220     ENGINE *engine;
 221     int ret;
 222
 223     engine = calloc(1, sizeof(*engine));
 224     if (engine == NULL)
 225         return;
 226
 227     ENGINE_set_id(engine, "builtin");
 228     ENGINE_set_name(engine,
 229                     "Heimdal crypto builtin engine version " PACKAGE_VERSION);
 230     ENGINE_set_RSA(engine, RSA_imath_method());
 231     ENGINE_set_DH(engine, DH_imath_method());
 232
 233     ret = add_engine(engine);
 234     if (ret != 1)
 235         ENGINE_finish(engine);
 236 }
 237
 238 ENGINE *
 239 ENGINE_by_dso(const char *path, const char *id)
 240 {
 241 #ifdef HAVE_DLOPEN
 242     ENGINE *engine;
 243     void *handle;
 244     int ret;
 245
 246     engine = calloc(1, sizeof(*engine));
 247     if (engine == NULL)
 248         return NULL;
 249
 250     handle = dlopen(path, RTLD_NOW);
 251     if (handle == NULL) {
 252         /* printf("error: %s\n", dlerror()); */
 253         free(engine);
 254         return NULL;
 255     }
 256
 257     {
 258         unsigned long version;
 259         openssl_v_check v_check;
 260
 261         v_check = (openssl_v_check)dlsym(handle, "v_check");
 262         if (v_check == NULL) {
 263             dlclose(handle);
 264             free(engine);
 265             return NULL;
 266         }
 267
 268         version = (*v_check)(OPENSSL_DYNAMIC_VERSION);
 269         if (version == 0) {
 270             dlclose(handle);
 271             free(engine);
 272             return NULL;
 273         }
 274     }
 275
 276     {
 277         openssl_bind_engine bind_engine;
 278
 279         bind_engine = (openssl_bind_engine)dlsym(handle, "bind_engine");
 280         if (bind_engine == NULL) {
 281             dlclose(handle);
 282             free(engine);
 283             return NULL;
 284         }
 285
 286         ret = (*bind_engine)(engine, id, NULL); /* XXX fix third arg */
 287         if (ret != 1) {
 288             dlclose(handle);
 289             free(engine);
 290             return NULL;
 291         }
 292     }
 293
 294     ENGINE_up_ref(engine);
 295
 296     ret = add_engine(engine);
 297     if (ret != 1) {
 298         dlclose(handle);
 299         ENGINE_finish(engine);
 300         return NULL;
 301     }
 302
 303     return engine;
 304 #else
 305     return NULL;
 306 #endif
 307 }
 308
 309 ENGINE *
 310 ENGINE_by_id(const char *id)
 311 {
 312     int i;
 313
 314     for (i = 0; i < num_engines; i++) {
 315         if (strcmp(id, engines[i]->id) == 0) {
 316             ENGINE_up_ref(engines[i]);
 317             return engines[i];
 318         }
 319     }
 320     return NULL;
 321 }
 322
 323 void
 324 ENGINE_add_conf_module(void)
 325 {
 326 }