crypto/engine/engine_list.c

   1 /* crypto/engine/engine_list.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 /* The linked-list of pointers to engine types. engine_list_head
  65  * incorporates an implicit structural reference but engine_list_tail
  66  * does not - the latter is a computational niceity and only points
  67  * to something that is already pointed to by its predecessor in the
  68  * list (or engine_list_head itself). In the same way, the use of the
  69  * "prev" pointer in each ENGINE is to save excessive list iteration,
  70  * it doesn't correspond to an extra structural reference. Hence,
  71  * engine_list_head, and each non-null "next" pointer account for
  72  * the list itself assuming exactly 1 structural reference on each
  73  * list member. */
  74 static ENGINE *engine_list_head = NULL;
  75 static ENGINE *engine_list_tail = NULL;
  76 /* A boolean switch, used to ensure we only initialise once. This
  77  * is needed because the engine list may genuinely become empty during
  78  * use (so we can't use engine_list_head as an indicator for example. */
  79 static int engine_list_flag = 0;
  80
  81 /* These static functions starting with a lower case "engine_" always
  82  * take place when CRYPTO_LOCK_ENGINE has been locked up. */
  83 static int engine_list_add(ENGINE *e)
  84         {
  85         int conflict = 0;
  86         ENGINE *iterator = NULL;
  87
  88         if(e == NULL)
  89                 {
  90                 ENGINEerr(ENGINE_F_ENGINE_LIST_ADD,
  91                         ERR_R_PASSED_NULL_PARAMETER);
  92                 return 0;
  93                 }
  94         iterator = engine_list_head;
  95         while(iterator && !conflict)
  96                 {
  97                 conflict = (strcmp(iterator->id, e->id) == 0);
  98                 iterator = iterator->next;
  99                 }
 100         if(conflict)
 101                 {
 102                 ENGINEerr(ENGINE_F_ENGINE_LIST_ADD,
 103                         ENGINE_R_CONFLICTING_ENGINE_ID);
 104                 return 0;
 105                 }
 106         if(engine_list_head == NULL)
 107                 {
 108                 /* We are adding to an empty list. */
 109                 if(engine_list_tail)
 110                         {
 111                         ENGINEerr(ENGINE_F_ENGINE_LIST_ADD,
 112                                 ENGINE_R_INTERNAL_LIST_ERROR);
 113                         return 0;
 114                         }
 115                 engine_list_head = e;
 116                 e->prev = NULL;
 117                 }
 118         else
 119                 {
 120                 /* We are adding to the tail of an existing list. */
 121                 if((engine_list_tail == NULL) ||
 122                                 (engine_list_tail->next != NULL))
 123                         {
 124                         ENGINEerr(ENGINE_F_ENGINE_LIST_ADD,
 125                                 ENGINE_R_INTERNAL_LIST_ERROR);
 126                         return 0;
 127                         }
 128                 engine_list_tail->next = e;
 129                 e->prev = engine_list_tail;
 130                 }
 131         /* Having the engine in the list assumes a structural
 132          * reference. */
 133         e->struct_ref++;
 134         /* However it came to be, e is the last item in the list. */
 135         engine_list_tail = e;
 136         e->next = NULL;
 137         return 1;
 138         }
 139
 140 static int engine_list_remove(ENGINE *e)
 141         {
 142         ENGINE *iterator;
 143
 144         if(e == NULL)
 145                 {
 146                 ENGINEerr(ENGINE_F_ENGINE_LIST_REMOVE,
 147                         ERR_R_PASSED_NULL_PARAMETER);
 148                 return 0;
 149                 }
 150         /* We need to check that e is in our linked list! */
 151         iterator = engine_list_head;
 152         while(iterator && (iterator != e))
 153                 iterator = iterator->next;
 154         if(iterator == NULL)
 155                 {
 156                 ENGINEerr(ENGINE_F_ENGINE_LIST_REMOVE,
 157                         ENGINE_R_ENGINE_IS_NOT_IN_LIST);
 158                 return 0;
 159                 }
 160         /* un-link e from the chain. */
 161         if(e->next)
 162                 e->next->prev = e->prev;
 163         if(e->prev)
 164                 e->prev->next = e->next;
 165         /* Correct our head/tail if necessary. */
 166         if(engine_list_head == e)
 167                 engine_list_head = e->next;
 168         if(engine_list_tail == e)
 169                 engine_list_tail = e->prev;
 170         /* remove our structural reference. */
 171         e->struct_ref--;
 172         return 1;
 173         }
 174
 175 /* This check always takes place with CRYPTO_LOCK_ENGINE locked up
 176  * so we're synchronised, but we can't call anything that tries to
 177  * lock it again! :-) NB: For convenience (and code-clarity) we
 178  * don't output errors for failures of the engine_list_add function
 179  * as it will generate errors itself. */
 180 static int engine_internal_check(void)
 181         {
 182         if(engine_list_flag)
 183                 return 1;
 184         /* This is our first time up, we need to populate the list
 185          * with our statically compiled-in engines. */
 186         if(!engine_list_add(ENGINE_openssl()))
 187                 return 0;
 188         engine_list_flag = 1;
 189         return 1;
 190         }
 191
 192 /* Get the first/last "ENGINE" type available. */
 193 ENGINE *ENGINE_get_first(void)
 194         {
 195         ENGINE *ret = NULL;
 196
 197         CRYPTO_r_lock(CRYPTO_LOCK_ENGINE);
 198         if(engine_internal_check())
 199                 {
 200                 ret = engine_list_head;
 201                 if(ret)
 202                         ret->struct_ref++;
 203                 }
 204         CRYPTO_r_unlock(CRYPTO_LOCK_ENGINE);
 205         return ret;
 206         }
 207 ENGINE *ENGINE_get_last(void)
 208         {
 209         ENGINE *ret = NULL;
 210
 211         CRYPTO_r_lock(CRYPTO_LOCK_ENGINE);
 212         if(engine_internal_check())
 213                 {
 214                 ret = engine_list_tail;
 215                 if(ret)
 216                         ret->struct_ref++;
 217                 }
 218         CRYPTO_r_unlock(CRYPTO_LOCK_ENGINE);
 219         return ret;
 220         }
 221
 222 /* Iterate to the next/previous "ENGINE" type (NULL = end of the list). */
 223 ENGINE *ENGINE_get_next(ENGINE *e)
 224         {
 225         ENGINE *ret = NULL;
 226         if(e == NULL)
 227                 {
 228                 ENGINEerr(ENGINE_F_ENGINE_GET_NEXT,
 229                         ERR_R_PASSED_NULL_PARAMETER);
 230                 return 0;
 231                 }
 232         CRYPTO_r_lock(CRYPTO_LOCK_ENGINE);
 233         ret = e->next;
 234         if(ret)
 235                 /* Return a valid structural refernce to the next ENGINE */
 236                 ret->struct_ref++;
 237         CRYPTO_r_unlock(CRYPTO_LOCK_ENGINE);
 238         /* Release the structural reference to the previous ENGINE */
 239         ENGINE_free(e);
 240         return ret;
 241         }
 242 ENGINE *ENGINE_get_prev(ENGINE *e)
 243         {
 244         ENGINE *ret = NULL;
 245         if(e == NULL)
 246                 {
 247                 ENGINEerr(ENGINE_F_ENGINE_GET_PREV,
 248                         ERR_R_PASSED_NULL_PARAMETER);
 249                 return 0;
 250                 }
 251         CRYPTO_r_lock(CRYPTO_LOCK_ENGINE);
 252         ret = e->prev;
 253         if(ret)
 254                 /* Return a valid structural reference to the next ENGINE */
 255                 ret->struct_ref++;
 256         CRYPTO_r_unlock(CRYPTO_LOCK_ENGINE);
 257         /* Release the structural reference to the previous ENGINE */
 258         ENGINE_free(e);
 259         return ret;
 260         }
 261
 262 /* Add another "ENGINE" type into the list. */
 263 int ENGINE_add(ENGINE *e)
 264         {
 265         int to_return = 1;
 266         if(e == NULL)
 267                 {
 268                 ENGINEerr(ENGINE_F_ENGINE_ADD,
 269                         ERR_R_PASSED_NULL_PARAMETER);
 270                 return 0;
 271                 }
 272         if((e->id == NULL) || (e->name == NULL))
 273                 {
 274                 ENGINEerr(ENGINE_F_ENGINE_ADD,
 275                         ENGINE_R_ID_OR_NAME_MISSING);
 276                 }
 277         CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
 278         if(!engine_internal_check() || !engine_list_add(e))
 279                 {
 280                 ENGINEerr(ENGINE_F_ENGINE_ADD,
 281                         ENGINE_R_INTERNAL_LIST_ERROR);
 282                 to_return = 0;
 283                 }
 284         CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
 285         return to_return;
 286         }
 287
 288 /* Remove an existing "ENGINE" type from the array. */
 289 int ENGINE_remove(ENGINE *e)
 290         {
 291         int to_return = 1;
 292         if(e == NULL)
 293                 {
 294                 ENGINEerr(ENGINE_F_ENGINE_REMOVE,
 295                         ERR_R_PASSED_NULL_PARAMETER);
 296                 return 0;
 297                 }
 298         CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
 299         if(!engine_internal_check() || !engine_list_remove(e))
 300                 {
 301                 ENGINEerr(ENGINE_F_ENGINE_REMOVE,
 302                         ENGINE_R_INTERNAL_LIST_ERROR);
 303                 to_return = 0;
 304                 }
 305         CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
 306         return to_return;
 307         }
 308
 309 ENGINE *ENGINE_by_id(const char *id)
 310         {
 311         ENGINE *iterator = NULL;
 312         if(id == NULL)
 313                 {
 314                 ENGINEerr(ENGINE_F_ENGINE_BY_ID,
 315                         ERR_R_PASSED_NULL_PARAMETER);
 316                 return NULL;
 317                 }
 318         CRYPTO_r_lock(CRYPTO_LOCK_ENGINE);
 319         if(!engine_internal_check())
 320                 ENGINEerr(ENGINE_F_ENGINE_BY_ID,
 321                         ENGINE_R_INTERNAL_LIST_ERROR);
 322         else
 323                 {
 324                 iterator = engine_list_head;
 325                 while(iterator && (strcmp(id, iterator->id) != 0))
 326                         iterator = iterator->next;
 327                 if(iterator)
 328                         /* We need to return a structural reference */
 329                         iterator->struct_ref++;
 330                 }
 331         CRYPTO_r_unlock(CRYPTO_LOCK_ENGINE);
 332         if(iterator == NULL)
 333                 ENGINEerr(ENGINE_F_ENGINE_BY_ID,
 334                         ENGINE_R_NO_SUCH_ENGINE);
 335         return iterator;
 336         }
 337
 338 ENGINE *ENGINE_new(void)
 339         {
 340         ENGINE *ret;
 341
 342         ret = (ENGINE *)OPENSSL_malloc(sizeof(ENGINE));
 343         if(ret == NULL)
 344                 {
 345                 ENGINEerr(ENGINE_F_ENGINE_NEW, ERR_R_MALLOC_FAILURE);
 346                 return NULL;
 347                 }
 348         memset(ret, 0, sizeof(ENGINE));
 349         ret->struct_ref = 1;
 350         return ret;
 351         }
 352
 353 int ENGINE_free(ENGINE *e)
 354         {
 355         int i;
 356
 357         if(e == NULL)
 358                 {
 359                 ENGINEerr(ENGINE_F_ENGINE_FREE,
 360                         ERR_R_PASSED_NULL_PARAMETER);
 361                 return 0;
 362                 }
 363         i = CRYPTO_add(&e->struct_ref,-1,CRYPTO_LOCK_ENGINE);
 364 #ifdef REF_PRINT
 365         REF_PRINT("ENGINE",e);
 366 #endif
 367         if (i > 0) return 1;
 368 #ifdef REF_CHECK
 369         if (i < 0)
 370                 {
 371                 fprintf(stderr,"ENGINE_free, bad reference count\n");
 372                 abort();
 373                 }
 374 #endif
 375         OPENSSL_free(e);
 376         return 1;
 377         }
 378
 379 int ENGINE_set_id(ENGINE *e, const char *id)
 380         {
 381         if(id == NULL)
 382                 {
 383                 ENGINEerr(ENGINE_F_ENGINE_SET_ID,
 384                         ERR_R_PASSED_NULL_PARAMETER);
 385                 return 0;
 386                 }
 387         e->id = id;
 388         return 1;
 389         }
 390
 391 int ENGINE_set_name(ENGINE *e, const char *name)
 392         {
 393         if(name == NULL)
 394                 {
 395                 ENGINEerr(ENGINE_F_ENGINE_SET_NAME,
 396                         ERR_R_PASSED_NULL_PARAMETER);
 397                 return 0;
 398                 }
 399         e->name = name;
 400         return 1;
 401         }
 402
 403 int ENGINE_set_RSA(ENGINE *e, const RSA_METHOD *rsa_meth)
 404         {
 405 #ifndef OPENSSL_NO_RSA
 406         e->rsa_meth = rsa_meth;
 407         return 1;
 408 #else
 409         return 0;
 410 #endif
 411         }
 412
 413 int ENGINE_set_DSA(ENGINE *e, const DSA_METHOD *dsa_meth)
 414         {
 415 #ifndef OPENSSL_NO_DSA
 416         e->dsa_meth = dsa_meth;
 417         return 1;
 418 #else
 419         return 0;
 420 #endif
 421         }
 422
 423 int ENGINE_set_DH(ENGINE *e, const DH_METHOD *dh_meth)
 424         {
 425 #ifndef OPENSSL_NO_DH
 426         e->dh_meth = dh_meth;
 427         return 1;
 428 #else
 429         return 0;
 430 #endif
 431         }
 432
 433 int ENGINE_set_RAND(ENGINE *e, const RAND_METHOD *rand_meth)
 434         {
 435         e->rand_meth = rand_meth;
 436         return 1;
 437         }
 438
 439 int ENGINE_set_BN_mod_exp(ENGINE *e, BN_MOD_EXP bn_mod_exp)
 440         {
 441         e->bn_mod_exp = bn_mod_exp;
 442         return 1;
 443         }
 444
 445 int ENGINE_set_BN_mod_exp_crt(ENGINE *e, BN_MOD_EXP_CRT bn_mod_exp_crt)
 446         {
 447         e->bn_mod_exp_crt = bn_mod_exp_crt;
 448         return 1;
 449         }
 450
 451 int ENGINE_set_init_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR init_f)
 452         {
 453         e->init = init_f;
 454         return 1;
 455         }
 456
 457 int ENGINE_set_finish_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR finish_f)
 458         {
 459         e->finish = finish_f;
 460         return 1;
 461         }
 462
 463 int ENGINE_set_ctrl_function(ENGINE *e, ENGINE_CTRL_FUNC_PTR ctrl_f)
 464         {
 465         e->ctrl = ctrl_f;
 466         return 1;
 467         }
 468
 469 int ENGINE_set_load_privkey_function(ENGINE *e, ENGINE_LOAD_KEY_PTR loadpriv_f)
 470         {
 471         e->load_privkey = loadpriv_f;
 472         return 1;
 473         }
 474
 475 int ENGINE_set_load_pubkey_function(ENGINE *e, ENGINE_LOAD_KEY_PTR loadpub_f)
 476         {
 477         e->load_pubkey = loadpub_f;
 478         return 1;
 479         }
 480
 481 int ENGINE_set_flags(ENGINE *e, int flags)
 482         {
 483         e->flags = flags;
 484         return 1;
 485         }
 486
 487 int ENGINE_set_cmd_defns(ENGINE *e, const ENGINE_CMD_DEFN *defns)
 488         {
 489         e->cmd_defns = defns;
 490         return 1;
 491         }
 492
 493 int ENGINE_cpy(ENGINE *dest, const ENGINE *src)
 494         {
 495         if(ENGINE_set_id(dest, ENGINE_get_id(src)) &&
 496                         ENGINE_set_name(dest, ENGINE_get_name(src)) &&
 497 #ifndef OPENSSL_NO_RSA
 498                         ENGINE_set_RSA(dest, ENGINE_get_RSA(src)) &&
 499 #endif
 500 #ifndef OPENSSL_NO_RSA
 501                         ENGINE_set_DSA(dest, ENGINE_get_DSA(src)) &&
 502 #endif
 503 #ifndef OPENSSL_NO_RSA
 504                         ENGINE_set_DH(dest, ENGINE_get_DH(src)) &&
 505 #endif
 506                         ENGINE_set_RAND(dest, ENGINE_get_RAND(src)) &&
 507                         ENGINE_set_BN_mod_exp(dest,
 508                                         ENGINE_get_BN_mod_exp(src)) &&
 509                         ENGINE_set_BN_mod_exp_crt(dest,
 510                                         ENGINE_get_BN_mod_exp_crt(src)) &&
 511                         ENGINE_set_init_function(dest,
 512                                         ENGINE_get_init_function(src)) &&
 513                         ENGINE_set_finish_function(dest,
 514                                         ENGINE_get_finish_function(src)) &&
 515                         ENGINE_set_ctrl_function(dest,
 516                                         ENGINE_get_ctrl_function(src)) &&
 517                         ENGINE_set_load_privkey_function(dest,
 518                                         ENGINE_get_load_privkey_function(src)) &&
 519                         ENGINE_set_load_pubkey_function(dest,
 520                                         ENGINE_get_load_pubkey_function(src)) &&
 521                         ENGINE_set_flags(dest, ENGINE_get_flags(src)) &&
 522                         ENGINE_set_cmd_defns(dest, ENGINE_get_cmd_defns(src)))
 523                 return 1;
 524         return 0;
 525         }
 526
 527 const char *ENGINE_get_id(const ENGINE *e)
 528         {
 529         return e->id;
 530         }
 531
 532 const char *ENGINE_get_name(const ENGINE *e)
 533         {
 534         return e->name;
 535         }
 536
 537 const RSA_METHOD *ENGINE_get_RSA(const ENGINE *e)
 538         {
 539         return e->rsa_meth;
 540         }
 541
 542 const DSA_METHOD *ENGINE_get_DSA(const ENGINE *e)
 543         {
 544         return e->dsa_meth;
 545         }
 546
 547 const DH_METHOD *ENGINE_get_DH(const ENGINE *e)
 548         {
 549         return e->dh_meth;
 550         }
 551
 552 const RAND_METHOD *ENGINE_get_RAND(const ENGINE *e)
 553         {
 554         return e->rand_meth;
 555         }
 556
 557 BN_MOD_EXP ENGINE_get_BN_mod_exp(const ENGINE *e)
 558         {
 559         return e->bn_mod_exp;
 560         }
 561
 562 BN_MOD_EXP_CRT ENGINE_get_BN_mod_exp_crt(const ENGINE *e)
 563         {
 564         return e->bn_mod_exp_crt;
 565         }
 566
 567 ENGINE_GEN_INT_FUNC_PTR ENGINE_get_init_function(const ENGINE *e)
 568         {
 569         return e->init;
 570         }
 571
 572 ENGINE_GEN_INT_FUNC_PTR ENGINE_get_finish_function(const ENGINE *e)
 573         {
 574         return e->finish;
 575         }
 576
 577 ENGINE_CTRL_FUNC_PTR ENGINE_get_ctrl_function(const ENGINE *e)
 578         {
 579         return e->ctrl;
 580         }
 581
 582 ENGINE_LOAD_KEY_PTR ENGINE_get_load_privkey_function(const ENGINE *e)
 583         {
 584         return e->load_privkey;
 585         }
 586
 587 ENGINE_LOAD_KEY_PTR ENGINE_get_load_pubkey_function(const ENGINE *e)
 588         {
 589         return e->load_pubkey;
 590         }
 591
 592 int ENGINE_get_flags(const ENGINE *e)
 593         {
 594         return e->flags;
 595         }
 596
 597 const ENGINE_CMD_DEFN *ENGINE_get_cmd_defns(const ENGINE *e)
 598         {
 599         return e->cmd_defns;
 600         }