1 /* 2 * Copyright 2001-2021 The OpenSSL Project Authors. All Rights Reserved. 3 * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved 4 * 5 * Licensed under the OpenSSL license (the "License"). You may not use 6 * this file except in compliance with the License. You can obtain a copy 7 * in the file LICENSE in the source distribution or at 8 * https://www.openssl.org/source/license.html 9 */ 10 11 #include "eng_local.h" 12 13 /* 14 * The linked-list of pointers to engine types. engine_list_head incorporates 15 * an implicit structural reference but engine_list_tail does not - the 16 * latter is a computational optimization and only points to something that 17 * is already pointed to by its predecessor in the list (or engine_list_head 18 * itself). In the same way, the use of the "prev" pointer in each ENGINE is 19 * to save excessive list iteration, it doesn't correspond to an extra 20 * structural reference. Hence, engine_list_head, and each non-null "next" 21 * pointer account for the list itself assuming exactly 1 structural 22 * reference on each list member. 23 */ 24 static ENGINE *engine_list_head = NULL; 25 static ENGINE *engine_list_tail = NULL; 26 27 /* 28 * The linked list of currently loaded dynamic engines. 29 */ 30 static ENGINE *engine_dyn_list_head = NULL; 31 static ENGINE *engine_dyn_list_tail = NULL; 32 33 /* 34 * This cleanup function is only needed internally. If it should be called, 35 * we register it with the "engine_cleanup_int()" stack to be called during 36 * cleanup. 37 */ 38 39 static void engine_list_cleanup(void) 40 { 41 ENGINE *iterator = engine_list_head; 42 43 while (iterator != NULL) { 44 ENGINE_remove(iterator); 45 iterator = engine_list_head; 46 } 47 return; 48 } 49 50 /* 51 * These static functions starting with a lower case "engine_" always take 52 * place when global_engine_lock has been locked up. 53 */ 54 static int engine_list_add(ENGINE *e) 55 { 56 int conflict = 0; 57 ENGINE *iterator = NULL; 58 59 if (e == NULL) { 60 ENGINEerr(ENGINE_F_ENGINE_LIST_ADD, ERR_R_PASSED_NULL_PARAMETER); 61 return 0; 62 } 63 iterator = engine_list_head; 64 while (iterator && !conflict) { 65 conflict = (strcmp(iterator->id, e->id) == 0); 66 iterator = iterator->next; 67 } 68 if (conflict) { 69 ENGINEerr(ENGINE_F_ENGINE_LIST_ADD, ENGINE_R_CONFLICTING_ENGINE_ID); 70 return 0; 71 } 72 if (engine_list_head == NULL) { 73 /* We are adding to an empty list. */ 74 if (engine_list_tail) { 75 ENGINEerr(ENGINE_F_ENGINE_LIST_ADD, ENGINE_R_INTERNAL_LIST_ERROR); 76 return 0; 77 } 78 engine_list_head = e; 79 e->prev = NULL; 80 /* 81 * The first time the list allocates, we should register the cleanup. 82 */ 83 engine_cleanup_add_last(engine_list_cleanup); 84 } else { 85 /* We are adding to the tail of an existing list. */ 86 if ((engine_list_tail == NULL) || (engine_list_tail->next != NULL)) { 87 ENGINEerr(ENGINE_F_ENGINE_LIST_ADD, ENGINE_R_INTERNAL_LIST_ERROR); 88 return 0; 89 } 90 engine_list_tail->next = e; 91 e->prev = engine_list_tail; 92 } 93 /* 94 * Having the engine in the list assumes a structural reference. 95 */ 96 e->struct_ref++; 97 engine_ref_debug(e, 0, 1); 98 /* However it came to be, e is the last item in the list. */ 99 engine_list_tail = e; 100 e->next = NULL; 101 return 1; 102 } 103 104 static int engine_list_remove(ENGINE *e) 105 { 106 ENGINE *iterator; 107 108 if (e == NULL) { 109 ENGINEerr(ENGINE_F_ENGINE_LIST_REMOVE, ERR_R_PASSED_NULL_PARAMETER); 110 return 0; 111 } 112 /* We need to check that e is in our linked list! */ 113 iterator = engine_list_head; 114 while (iterator && (iterator != e)) 115 iterator = iterator->next; 116 if (iterator == NULL) { 117 ENGINEerr(ENGINE_F_ENGINE_LIST_REMOVE, 118 ENGINE_R_ENGINE_IS_NOT_IN_LIST); 119 return 0; 120 } 121 /* un-link e from the chain. */ 122 if (e->next) 123 e->next->prev = e->prev; 124 if (e->prev) 125 e->prev->next = e->next; 126 /* Correct our head/tail if necessary. */ 127 if (engine_list_head == e) 128 engine_list_head = e->next; 129 if (engine_list_tail == e) 130 engine_list_tail = e->prev; 131 engine_free_util(e, 0); 132 return 1; 133 } 134 135 /* Add engine to dynamic engine list. */ 136 int engine_add_dynamic_id(ENGINE *e, ENGINE_DYNAMIC_ID dynamic_id, 137 int not_locked) 138 { 139 int result = 0; 140 ENGINE *iterator = NULL; 141 142 if (e == NULL) 143 return 0; 144 145 if (e->dynamic_id == NULL && dynamic_id == NULL) 146 return 0; 147 148 if (not_locked && !CRYPTO_THREAD_write_lock(global_engine_lock)) 149 return 0; 150 151 if (dynamic_id != NULL) { 152 iterator = engine_dyn_list_head; 153 while (iterator != NULL) { 154 if (iterator->dynamic_id == dynamic_id) 155 goto err; 156 iterator = iterator->next; 157 } 158 if (e->dynamic_id != NULL) 159 goto err; 160 e->dynamic_id = dynamic_id; 161 } 162 163 if (engine_dyn_list_head == NULL) { 164 /* We are adding to an empty list. */ 165 if (engine_dyn_list_tail != NULL) 166 goto err; 167 engine_dyn_list_head = e; 168 e->prev_dyn = NULL; 169 } else { 170 /* We are adding to the tail of an existing list. */ 171 if (engine_dyn_list_tail == NULL 172 || engine_dyn_list_tail->next_dyn != NULL) 173 goto err; 174 engine_dyn_list_tail->next_dyn = e; 175 e->prev_dyn = engine_dyn_list_tail; 176 } 177 178 engine_dyn_list_tail = e; 179 e->next_dyn = NULL; 180 result = 1; 181 182 err: 183 if (not_locked) 184 CRYPTO_THREAD_unlock(global_engine_lock); 185 return result; 186 } 187 188 /* Remove engine from dynamic engine list. */ 189 void engine_remove_dynamic_id(ENGINE *e, int not_locked) 190 { 191 if (e == NULL || e->dynamic_id == NULL) 192 return; 193 194 if (not_locked && !CRYPTO_THREAD_write_lock(global_engine_lock)) 195 return; 196 197 e->dynamic_id = NULL; 198 199 /* un-link e from the chain. */ 200 if (e->next_dyn != NULL) 201 e->next_dyn->prev_dyn = e->prev_dyn; 202 if (e->prev_dyn != NULL) 203 e->prev_dyn->next_dyn = e->next_dyn; 204 /* Correct our head/tail if necessary. */ 205 if (engine_dyn_list_head == e) 206 engine_dyn_list_head = e->next_dyn; 207 if (engine_dyn_list_tail == e) 208 engine_dyn_list_tail = e->prev_dyn; 209 210 if (not_locked) 211 CRYPTO_THREAD_unlock(global_engine_lock); 212 } 213 214 /* Get the first/last "ENGINE" type available. */ 215 ENGINE *ENGINE_get_first(void) 216 { 217 ENGINE *ret; 218 219 if (!RUN_ONCE(&engine_lock_init, do_engine_lock_init)) { 220 ENGINEerr(ENGINE_F_ENGINE_GET_FIRST, ERR_R_MALLOC_FAILURE); 221 return NULL; 222 } 223 224 CRYPTO_THREAD_write_lock(global_engine_lock); 225 ret = engine_list_head; 226 if (ret) { 227 ret->struct_ref++; 228 engine_ref_debug(ret, 0, 1); 229 } 230 CRYPTO_THREAD_unlock(global_engine_lock); 231 return ret; 232 } 233 234 ENGINE *ENGINE_get_last(void) 235 { 236 ENGINE *ret; 237 238 if (!RUN_ONCE(&engine_lock_init, do_engine_lock_init)) { 239 ENGINEerr(ENGINE_F_ENGINE_GET_LAST, ERR_R_MALLOC_FAILURE); 240 return NULL; 241 } 242 243 CRYPTO_THREAD_write_lock(global_engine_lock); 244 ret = engine_list_tail; 245 if (ret) { 246 ret->struct_ref++; 247 engine_ref_debug(ret, 0, 1); 248 } 249 CRYPTO_THREAD_unlock(global_engine_lock); 250 return ret; 251 } 252 253 /* Iterate to the next/previous "ENGINE" type (NULL = end of the list). */ 254 ENGINE *ENGINE_get_next(ENGINE *e) 255 { 256 ENGINE *ret = NULL; 257 if (e == NULL) { 258 ENGINEerr(ENGINE_F_ENGINE_GET_NEXT, ERR_R_PASSED_NULL_PARAMETER); 259 return 0; 260 } 261 CRYPTO_THREAD_write_lock(global_engine_lock); 262 ret = e->next; 263 if (ret) { 264 /* Return a valid structural reference to the next ENGINE */ 265 ret->struct_ref++; 266 engine_ref_debug(ret, 0, 1); 267 } 268 CRYPTO_THREAD_unlock(global_engine_lock); 269 /* Release the structural reference to the previous ENGINE */ 270 ENGINE_free(e); 271 return ret; 272 } 273 274 ENGINE *ENGINE_get_prev(ENGINE *e) 275 { 276 ENGINE *ret = NULL; 277 if (e == NULL) { 278 ENGINEerr(ENGINE_F_ENGINE_GET_PREV, ERR_R_PASSED_NULL_PARAMETER); 279 return 0; 280 } 281 CRYPTO_THREAD_write_lock(global_engine_lock); 282 ret = e->prev; 283 if (ret) { 284 /* Return a valid structural reference to the next ENGINE */ 285 ret->struct_ref++; 286 engine_ref_debug(ret, 0, 1); 287 } 288 CRYPTO_THREAD_unlock(global_engine_lock); 289 /* Release the structural reference to the previous ENGINE */ 290 ENGINE_free(e); 291 return ret; 292 } 293 294 /* Add another "ENGINE" type into the list. */ 295 int ENGINE_add(ENGINE *e) 296 { 297 int to_return = 1; 298 if (e == NULL) { 299 ENGINEerr(ENGINE_F_ENGINE_ADD, ERR_R_PASSED_NULL_PARAMETER); 300 return 0; 301 } 302 if ((e->id == NULL) || (e->name == NULL)) { 303 ENGINEerr(ENGINE_F_ENGINE_ADD, ENGINE_R_ID_OR_NAME_MISSING); 304 return 0; 305 } 306 CRYPTO_THREAD_write_lock(global_engine_lock); 307 if (!engine_list_add(e)) { 308 ENGINEerr(ENGINE_F_ENGINE_ADD, ENGINE_R_INTERNAL_LIST_ERROR); 309 to_return = 0; 310 } 311 CRYPTO_THREAD_unlock(global_engine_lock); 312 return to_return; 313 } 314 315 /* Remove an existing "ENGINE" type from the array. */ 316 int ENGINE_remove(ENGINE *e) 317 { 318 int to_return = 1; 319 if (e == NULL) { 320 ENGINEerr(ENGINE_F_ENGINE_REMOVE, ERR_R_PASSED_NULL_PARAMETER); 321 return 0; 322 } 323 CRYPTO_THREAD_write_lock(global_engine_lock); 324 if (!engine_list_remove(e)) { 325 ENGINEerr(ENGINE_F_ENGINE_REMOVE, ENGINE_R_INTERNAL_LIST_ERROR); 326 to_return = 0; 327 } 328 CRYPTO_THREAD_unlock(global_engine_lock); 329 return to_return; 330 } 331 332 static void engine_cpy(ENGINE *dest, const ENGINE *src) 333 { 334 dest->id = src->id; 335 dest->name = src->name; 336 #ifndef OPENSSL_NO_RSA 337 dest->rsa_meth = src->rsa_meth; 338 #endif 339 #ifndef OPENSSL_NO_DSA 340 dest->dsa_meth = src->dsa_meth; 341 #endif 342 #ifndef OPENSSL_NO_DH 343 dest->dh_meth = src->dh_meth; 344 #endif 345 #ifndef OPENSSL_NO_EC 346 dest->ec_meth = src->ec_meth; 347 #endif 348 dest->rand_meth = src->rand_meth; 349 dest->ciphers = src->ciphers; 350 dest->digests = src->digests; 351 dest->pkey_meths = src->pkey_meths; 352 dest->destroy = src->destroy; 353 dest->init = src->init; 354 dest->finish = src->finish; 355 dest->ctrl = src->ctrl; 356 dest->load_privkey = src->load_privkey; 357 dest->load_pubkey = src->load_pubkey; 358 dest->cmd_defns = src->cmd_defns; 359 dest->flags = src->flags; 360 dest->dynamic_id = src->dynamic_id; 361 engine_add_dynamic_id(dest, NULL, 0); 362 } 363 364 ENGINE *ENGINE_by_id(const char *id) 365 { 366 ENGINE *iterator; 367 char *load_dir = NULL; 368 if (id == NULL) { 369 ENGINEerr(ENGINE_F_ENGINE_BY_ID, ERR_R_PASSED_NULL_PARAMETER); 370 return NULL; 371 } 372 if (!RUN_ONCE(&engine_lock_init, do_engine_lock_init)) { 373 ENGINEerr(ENGINE_F_ENGINE_BY_ID, ERR_R_MALLOC_FAILURE); 374 return NULL; 375 } 376 377 CRYPTO_THREAD_write_lock(global_engine_lock); 378 iterator = engine_list_head; 379 while (iterator && (strcmp(id, iterator->id) != 0)) 380 iterator = iterator->next; 381 if (iterator != NULL) { 382 /* 383 * We need to return a structural reference. If this is an ENGINE 384 * type that returns copies, make a duplicate - otherwise increment 385 * the existing ENGINE's reference count. 386 */ 387 if (iterator->flags & ENGINE_FLAGS_BY_ID_COPY) { 388 ENGINE *cp = ENGINE_new(); 389 if (cp == NULL) 390 iterator = NULL; 391 else { 392 engine_cpy(cp, iterator); 393 iterator = cp; 394 } 395 } else { 396 iterator->struct_ref++; 397 engine_ref_debug(iterator, 0, 1); 398 } 399 } 400 CRYPTO_THREAD_unlock(global_engine_lock); 401 if (iterator != NULL) 402 return iterator; 403 /* 404 * Prevent infinite recursion if we're looking for the dynamic engine. 405 */ 406 if (strcmp(id, "dynamic")) { 407 if ((load_dir = ossl_safe_getenv("OPENSSL_ENGINES")) == NULL) 408 load_dir = ENGINESDIR; 409 iterator = ENGINE_by_id("dynamic"); 410 if (!iterator || !ENGINE_ctrl_cmd_string(iterator, "ID", id, 0) || 411 !ENGINE_ctrl_cmd_string(iterator, "DIR_LOAD", "2", 0) || 412 !ENGINE_ctrl_cmd_string(iterator, "DIR_ADD", 413 load_dir, 0) || 414 !ENGINE_ctrl_cmd_string(iterator, "LIST_ADD", "1", 0) || 415 !ENGINE_ctrl_cmd_string(iterator, "LOAD", NULL, 0)) 416 goto notfound; 417 return iterator; 418 } 419 notfound: 420 ENGINE_free(iterator); 421 ENGINEerr(ENGINE_F_ENGINE_BY_ID, ENGINE_R_NO_SUCH_ENGINE); 422 ERR_add_error_data(2, "id=", id); 423 return NULL; 424 /* EEK! Experimental code ends */ 425 } 426 427 int ENGINE_up_ref(ENGINE *e) 428 { 429 int i; 430 if (e == NULL) { 431 ENGINEerr(ENGINE_F_ENGINE_UP_REF, ERR_R_PASSED_NULL_PARAMETER); 432 return 0; 433 } 434 CRYPTO_UP_REF(&e->struct_ref, &i, global_engine_lock); 435 return 1; 436 } 437