| /* |
| * Copyright (C) 2008-2020 Tobias Brunner |
| * Copyright (C) 2008 Martin Willi |
| * HSR Hochschule fuer Technik Rapperswil |
| * |
| * This program is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License as published by the |
| * Free Software Foundation; either version 2 of the License, or (at your |
| * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>. |
| * |
| * This program is distributed in the hope that it will be useful, but |
| * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY |
| * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * for more details. |
| */ |
| |
| #include <library.h> |
| #include <utils/debug.h> |
| #include <threading/thread.h> |
| #include <threading/mutex.h> |
| #include <threading/thread_value.h> |
| |
| #include <openssl/err.h> |
| #include <openssl/evp.h> |
| #include <openssl/conf.h> |
| #include <openssl/rand.h> |
| #include <openssl/crypto.h> |
| #ifndef OPENSSL_NO_ENGINE |
| #include <openssl/engine.h> |
| #endif |
| |
| #include "openssl_plugin.h" |
| #include "openssl_util.h" |
| #include "openssl_crypter.h" |
| #include "openssl_hasher.h" |
| #include "openssl_sha1_prf.h" |
| #include "openssl_diffie_hellman.h" |
| #include "openssl_ec_diffie_hellman.h" |
| #include "openssl_rsa_private_key.h" |
| #include "openssl_rsa_public_key.h" |
| #include "openssl_ec_private_key.h" |
| #include "openssl_ec_public_key.h" |
| #include "openssl_x509.h" |
| #include "openssl_crl.h" |
| #include "openssl_pkcs7.h" |
| #include "openssl_pkcs12.h" |
| #include "openssl_rng.h" |
| #include "openssl_hmac.h" |
| #include "openssl_aead.h" |
| #include "openssl_x_diffie_hellman.h" |
| #include "openssl_ed_public_key.h" |
| #include "openssl_ed_private_key.h" |
| #include "openssl_xof.h" |
| |
| #ifndef FIPS_MODE |
| #define FIPS_MODE 0 |
| #endif |
| |
| typedef struct private_openssl_plugin_t private_openssl_plugin_t; |
| |
| /** |
| * private data of openssl_plugin |
| */ |
| struct private_openssl_plugin_t { |
| |
| /** |
| * public functions |
| */ |
| openssl_plugin_t public; |
| }; |
| |
| /** |
| * OpenSSL is thread-safe since 1.1.0 |
| */ |
| #if OPENSSL_VERSION_NUMBER < 0x10100000L |
| |
| /** |
| * Array of static mutexes, with CRYPTO_num_locks() mutex |
| */ |
| static mutex_t **mutex = NULL; |
| |
| /** |
| * Locking callback for static locks |
| */ |
| static void locking_function(int mode, int type, const char *file, int line) |
| { |
| if (mutex) |
| { |
| if (mode & CRYPTO_LOCK) |
| { |
| mutex[type]->lock(mutex[type]); |
| } |
| else |
| { |
| mutex[type]->unlock(mutex[type]); |
| } |
| } |
| } |
| |
| /** |
| * Implementation of dynlock |
| */ |
| struct CRYPTO_dynlock_value { |
| mutex_t *mutex; |
| }; |
| |
| /** |
| * Callback to create a dynamic lock |
| */ |
| static struct CRYPTO_dynlock_value *create_function(const char *file, int line) |
| { |
| struct CRYPTO_dynlock_value *lock; |
| |
| lock = malloc_thing(struct CRYPTO_dynlock_value); |
| lock->mutex = mutex_create(MUTEX_TYPE_DEFAULT); |
| return lock; |
| } |
| |
| /** |
| * Callback to (un-)lock a dynamic lock |
| */ |
| static void lock_function(int mode, struct CRYPTO_dynlock_value *lock, |
| const char *file, int line) |
| { |
| if (mode & CRYPTO_LOCK) |
| { |
| lock->mutex->lock(lock->mutex); |
| } |
| else |
| { |
| lock->mutex->unlock(lock->mutex); |
| } |
| } |
| |
| /** |
| * Callback to destroy a dynamic lock |
| */ |
| static void destroy_function(struct CRYPTO_dynlock_value *lock, |
| const char *file, int line) |
| { |
| lock->mutex->destroy(lock->mutex); |
| free(lock); |
| } |
| |
| /** |
| * Thread-local value used to cleanup thread-specific error buffers |
| */ |
| static thread_value_t *cleanup; |
| |
| /** |
| * Called when a thread is destroyed. Avoid recursion by setting the thread id |
| * explicitly. |
| */ |
| static void cleanup_thread(void *arg) |
| { |
| #if OPENSSL_VERSION_NUMBER >= 0x1000000fL |
| CRYPTO_THREADID tid; |
| |
| CRYPTO_THREADID_set_numeric(&tid, (u_long)(uintptr_t)arg); |
| ERR_remove_thread_state(&tid); |
| #else |
| ERR_remove_state((u_long)(uintptr_t)arg); |
| #endif |
| } |
| |
| /** |
| * Thread-ID callback function |
| */ |
| static u_long id_function(void) |
| { |
| u_long id; |
| |
| /* ensure the thread ID is never zero, otherwise OpenSSL might try to |
| * acquire locks recursively */ |
| id = 1 + (u_long)thread_current_id(); |
| |
| /* cleanup a thread's state later if OpenSSL interacted with it */ |
| cleanup->set(cleanup, (void*)(uintptr_t)id); |
| return id; |
| } |
| |
| #if OPENSSL_VERSION_NUMBER >= 0x1000000fL |
| /** |
| * Callback for thread ID |
| */ |
| static void threadid_function(CRYPTO_THREADID *threadid) |
| { |
| CRYPTO_THREADID_set_numeric(threadid, id_function()); |
| } |
| #endif /* OPENSSL_VERSION_NUMBER */ |
| |
| /** |
| * initialize OpenSSL for multi-threaded use |
| */ |
| static void threading_init() |
| { |
| int i, num_locks; |
| |
| cleanup = thread_value_create(cleanup_thread); |
| |
| #if OPENSSL_VERSION_NUMBER >= 0x1000000fL |
| CRYPTO_THREADID_set_callback(threadid_function); |
| #else |
| CRYPTO_set_id_callback(id_function); |
| #endif |
| |
| CRYPTO_set_locking_callback(locking_function); |
| |
| CRYPTO_set_dynlock_create_callback(create_function); |
| CRYPTO_set_dynlock_lock_callback(lock_function); |
| CRYPTO_set_dynlock_destroy_callback(destroy_function); |
| |
| num_locks = CRYPTO_num_locks(); |
| mutex = malloc(sizeof(mutex_t*) * num_locks); |
| for (i = 0; i < num_locks; i++) |
| { |
| mutex[i] = mutex_create(MUTEX_TYPE_DEFAULT); |
| } |
| } |
| |
| /** |
| * cleanup OpenSSL threading locks |
| */ |
| static void threading_cleanup() |
| { |
| int i, num_locks; |
| |
| num_locks = CRYPTO_num_locks(); |
| for (i = 0; i < num_locks; i++) |
| { |
| mutex[i]->destroy(mutex[i]); |
| } |
| free(mutex); |
| mutex = NULL; |
| |
| cleanup->destroy(cleanup); |
| } |
| |
| #else /* OPENSSL_VERSION_NUMBER */ |
| |
| #define threading_init() |
| |
| #define threading_cleanup() |
| |
| #endif |
| |
| #if OPENSSL_VERSION_NUMBER < 0x1010100fL |
| /** |
| * Seed the OpenSSL RNG, if required |
| * Not necessary anymore with OpenSSL 1.1.1 (maybe wasn't already earlier, but |
| * it's now explicitly mentioned in the documentation). |
| */ |
| static bool seed_rng() |
| { |
| rng_t *rng = NULL; |
| char buf[32]; |
| |
| while (RAND_status() != 1) |
| { |
| if (!rng) |
| { |
| rng = lib->crypto->create_rng(lib->crypto, RNG_STRONG); |
| if (!rng) |
| { |
| return FALSE; |
| } |
| } |
| if (!rng->get_bytes(rng, sizeof(buf), buf)) |
| { |
| rng->destroy(rng); |
| return FALSE; |
| } |
| RAND_seed(buf, sizeof(buf)); |
| } |
| DESTROY_IF(rng); |
| return TRUE; |
| } |
| #endif /* OPENSSL_VERSION_NUMBER */ |
| |
| /** |
| * Generic key loader |
| */ |
| static private_key_t *openssl_private_key_load(key_type_t type, va_list args) |
| { |
| chunk_t blob = chunk_empty; |
| EVP_PKEY *key; |
| |
| while (TRUE) |
| { |
| switch (va_arg(args, builder_part_t)) |
| { |
| case BUILD_BLOB_ASN1_DER: |
| blob = va_arg(args, chunk_t); |
| continue; |
| case BUILD_END: |
| break; |
| default: |
| return NULL; |
| } |
| break; |
| } |
| |
| if (blob.ptr) |
| { |
| key = d2i_AutoPrivateKey(NULL, (const u_char**)&blob.ptr, blob.len); |
| if (key) |
| { |
| switch (EVP_PKEY_base_id(key)) |
| { |
| #ifndef OPENSSL_NO_RSA |
| case EVP_PKEY_RSA: |
| return openssl_rsa_private_key_create(key, FALSE); |
| #endif |
| #ifndef OPENSSL_NO_ECDSA |
| case EVP_PKEY_EC: |
| return openssl_ec_private_key_create(key, FALSE); |
| #endif |
| #if OPENSSL_VERSION_NUMBER >= 0x1010100fL && !defined(OPENSSL_NO_EC) |
| case EVP_PKEY_ED25519: |
| case EVP_PKEY_ED448: |
| return openssl_ed_private_key_create(key, FALSE); |
| #endif /* OPENSSL_VERSION_NUMBER */ |
| default: |
| EVP_PKEY_free(key); |
| break; |
| } |
| } |
| } |
| return NULL; |
| } |
| |
| #ifndef OPENSSL_NO_ENGINE |
| /** |
| * Login to engine with a PIN specified for a keyid |
| */ |
| static bool login(ENGINE *engine, chunk_t keyid) |
| { |
| enumerator_t *enumerator; |
| shared_key_t *shared; |
| identification_t *id; |
| chunk_t key; |
| char pin[64]; |
| bool found = FALSE, success = FALSE; |
| |
| id = identification_create_from_encoding(ID_KEY_ID, keyid); |
| enumerator = lib->credmgr->create_shared_enumerator(lib->credmgr, |
| SHARED_PIN, id, NULL); |
| while (enumerator->enumerate(enumerator, &shared, NULL, NULL)) |
| { |
| found = TRUE; |
| key = shared->get_key(shared); |
| if (snprintf(pin, sizeof(pin), |
| "%.*s", (int)key.len, key.ptr) >= sizeof(pin)) |
| { |
| continue; |
| } |
| if (ENGINE_ctrl_cmd_string(engine, "PIN", pin, 0)) |
| { |
| success = TRUE; |
| break; |
| } |
| else |
| { |
| DBG1(DBG_CFG, "setting PIN on engine failed"); |
| } |
| } |
| enumerator->destroy(enumerator); |
| id->destroy(id); |
| if (!found) |
| { |
| DBG1(DBG_CFG, "no PIN found for %#B", &keyid); |
| } |
| return success; |
| } |
| #endif /* OPENSSL_NO_ENGINE */ |
| |
| /** |
| * Load private key via engine |
| */ |
| static private_key_t *openssl_private_key_connect(key_type_t type, |
| va_list args) |
| { |
| #ifndef OPENSSL_NO_ENGINE |
| char *engine_id = NULL; |
| char keyname[BUF_LEN]; |
| chunk_t keyid = chunk_empty; |
| EVP_PKEY *key; |
| ENGINE *engine; |
| int slot = -1; |
| |
| while (TRUE) |
| { |
| switch (va_arg(args, builder_part_t)) |
| { |
| case BUILD_PKCS11_KEYID: |
| keyid = va_arg(args, chunk_t); |
| continue; |
| case BUILD_PKCS11_SLOT: |
| slot = va_arg(args, int); |
| continue; |
| case BUILD_PKCS11_MODULE: |
| engine_id = va_arg(args, char*); |
| continue; |
| case BUILD_END: |
| break; |
| default: |
| return NULL; |
| } |
| break; |
| } |
| if (!keyid.len) |
| { |
| return NULL; |
| } |
| |
| memset(keyname, 0, sizeof(keyname)); |
| if (slot != -1) |
| { |
| snprintf(keyname, sizeof(keyname), "%d:", slot); |
| } |
| if (sizeof(keyname) - strlen(keyname) <= keyid.len * 2 + 1) |
| { |
| return NULL; |
| } |
| chunk_to_hex(keyid, keyname + strlen(keyname), FALSE); |
| |
| if (!engine_id) |
| { |
| engine_id = lib->settings->get_str(lib->settings, |
| "%s.plugins.openssl.engine_id", "pkcs11", lib->ns); |
| } |
| engine = ENGINE_by_id(engine_id); |
| if (!engine) |
| { |
| DBG2(DBG_LIB, "engine '%s' is not available", engine_id); |
| return NULL; |
| } |
| if (!ENGINE_init(engine)) |
| { |
| DBG1(DBG_LIB, "failed to initialize engine '%s'", engine_id); |
| ENGINE_free(engine); |
| return NULL; |
| } |
| ENGINE_free(engine); |
| if (!login(engine, keyid)) |
| { |
| DBG1(DBG_LIB, "login to engine '%s' failed", engine_id); |
| ENGINE_finish(engine); |
| return NULL; |
| } |
| key = ENGINE_load_private_key(engine, keyname, NULL, NULL); |
| ENGINE_finish(engine); |
| if (!key) |
| { |
| DBG1(DBG_LIB, "failed to load private key with ID '%s' from " |
| "engine '%s'", keyname, engine_id); |
| return NULL; |
| } |
| |
| switch (EVP_PKEY_base_id(key)) |
| { |
| #ifndef OPENSSL_NO_RSA |
| case EVP_PKEY_RSA: |
| return openssl_rsa_private_key_create(key, TRUE); |
| #endif |
| #ifndef OPENSSL_NO_ECDSA |
| case EVP_PKEY_EC: |
| return openssl_ec_private_key_create(key, TRUE); |
| #endif |
| #if OPENSSL_VERSION_NUMBER >= 0x1010100fL && !defined(OPENSSL_NO_EC) |
| case EVP_PKEY_ED25519: |
| case EVP_PKEY_ED448: |
| return openssl_ed_private_key_create(key, TRUE); |
| #endif /* OPENSSL_VERSION_NUMBER */ |
| default: |
| EVP_PKEY_free(key); |
| break; |
| } |
| #endif /* OPENSSL_NO_ENGINE */ |
| return NULL; |
| } |
| |
| METHOD(plugin_t, get_name, char*, |
| private_openssl_plugin_t *this) |
| { |
| return "openssl"; |
| } |
| |
| METHOD(plugin_t, get_features, int, |
| private_openssl_plugin_t *this, plugin_feature_t *features[]) |
| { |
| static plugin_feature_t f[] = { |
| /* we provide OpenSSL threading callbacks */ |
| PLUGIN_PROVIDE(CUSTOM, "openssl-threading"), |
| /* crypters */ |
| PLUGIN_REGISTER(CRYPTER, openssl_crypter_create), |
| #ifndef OPENSSL_NO_AES |
| PLUGIN_PROVIDE(CRYPTER, ENCR_AES_CBC, 16), |
| PLUGIN_PROVIDE(CRYPTER, ENCR_AES_CBC, 24), |
| PLUGIN_PROVIDE(CRYPTER, ENCR_AES_CBC, 32), |
| PLUGIN_PROVIDE(CRYPTER, ENCR_AES_ECB, 16), |
| PLUGIN_PROVIDE(CRYPTER, ENCR_AES_ECB, 24), |
| PLUGIN_PROVIDE(CRYPTER, ENCR_AES_ECB, 32), |
| #endif |
| #ifndef OPENSSL_NO_CAMELLIA |
| PLUGIN_PROVIDE(CRYPTER, ENCR_CAMELLIA_CBC, 16), |
| PLUGIN_PROVIDE(CRYPTER, ENCR_CAMELLIA_CBC, 24), |
| PLUGIN_PROVIDE(CRYPTER, ENCR_CAMELLIA_CBC, 32), |
| #endif |
| #ifndef OPENSSL_NO_RC5 |
| PLUGIN_PROVIDE(CRYPTER, ENCR_RC5, 0), |
| #endif |
| #ifndef OPENSSL_NO_CAST |
| PLUGIN_PROVIDE(CRYPTER, ENCR_CAST, 0), |
| #endif |
| #ifndef OPENSSL_NO_BLOWFISH |
| PLUGIN_PROVIDE(CRYPTER, ENCR_BLOWFISH, 0), |
| #endif |
| #ifndef OPENSSL_NO_IDEA |
| PLUGIN_PROVIDE(CRYPTER, ENCR_IDEA, 16), |
| #endif |
| #ifndef OPENSSL_NO_DES |
| PLUGIN_PROVIDE(CRYPTER, ENCR_3DES, 24), |
| PLUGIN_PROVIDE(CRYPTER, ENCR_DES, 8), |
| PLUGIN_PROVIDE(CRYPTER, ENCR_DES_ECB, 8), |
| #endif |
| PLUGIN_PROVIDE(CRYPTER, ENCR_NULL, 0), |
| /* hashers */ |
| PLUGIN_REGISTER(HASHER, openssl_hasher_create), |
| #ifndef OPENSSL_NO_MD2 |
| PLUGIN_PROVIDE(HASHER, HASH_MD2), |
| #endif |
| #ifndef OPENSSL_NO_MD4 |
| PLUGIN_PROVIDE(HASHER, HASH_MD4), |
| #endif |
| #ifndef OPENSSL_NO_MD5 |
| PLUGIN_PROVIDE(HASHER, HASH_MD5), |
| #endif |
| #ifndef OPENSSL_NO_SHA1 |
| PLUGIN_PROVIDE(HASHER, HASH_SHA1), |
| #endif |
| #ifndef OPENSSL_NO_SHA256 |
| PLUGIN_PROVIDE(HASHER, HASH_SHA224), |
| PLUGIN_PROVIDE(HASHER, HASH_SHA256), |
| #endif |
| #ifndef OPENSSL_NO_SHA512 |
| PLUGIN_PROVIDE(HASHER, HASH_SHA384), |
| PLUGIN_PROVIDE(HASHER, HASH_SHA512), |
| #endif |
| /* SHA3/SHAKE was added with OpenSSL 1.1.1, it doesn't seem to be possible to |
| * disable it, defining the checked var prevents registration, though */ |
| #if OPENSSL_VERSION_NUMBER >= 0x1010100fL && !defined(OPENSSL_NO_SHA3) |
| PLUGIN_PROVIDE(HASHER, HASH_SHA3_224), |
| PLUGIN_PROVIDE(HASHER, HASH_SHA3_256), |
| PLUGIN_PROVIDE(HASHER, HASH_SHA3_384), |
| PLUGIN_PROVIDE(HASHER, HASH_SHA3_512), |
| #endif |
| #if OPENSSL_VERSION_NUMBER >= 0x1010100fL && !defined(OPENSSL_NO_SHAKE) |
| PLUGIN_REGISTER(XOF, openssl_xof_create), |
| PLUGIN_PROVIDE(XOF, XOF_SHAKE_128), |
| PLUGIN_PROVIDE(XOF, XOF_SHAKE_256), |
| #endif |
| #ifndef OPENSSL_NO_SHA1 |
| /* keyed sha1 hasher (aka prf) */ |
| PLUGIN_REGISTER(PRF, openssl_sha1_prf_create), |
| PLUGIN_PROVIDE(PRF, PRF_KEYED_SHA1), |
| #endif |
| #ifndef OPENSSL_NO_HMAC |
| PLUGIN_REGISTER(PRF, openssl_hmac_prf_create), |
| #ifndef OPENSSL_NO_MD5 |
| PLUGIN_PROVIDE(PRF, PRF_HMAC_MD5), |
| #endif |
| #ifndef OPENSSL_NO_SHA1 |
| PLUGIN_PROVIDE(PRF, PRF_HMAC_SHA1), |
| #endif |
| #ifndef OPENSSL_NO_SHA256 |
| PLUGIN_PROVIDE(PRF, PRF_HMAC_SHA2_256), |
| #endif |
| #ifndef OPENSSL_NO_SHA512 |
| PLUGIN_PROVIDE(PRF, PRF_HMAC_SHA2_384), |
| PLUGIN_PROVIDE(PRF, PRF_HMAC_SHA2_512), |
| #endif |
| PLUGIN_REGISTER(SIGNER, openssl_hmac_signer_create), |
| #ifndef OPENSSL_NO_MD5 |
| PLUGIN_PROVIDE(SIGNER, AUTH_HMAC_MD5_96), |
| PLUGIN_PROVIDE(SIGNER, AUTH_HMAC_MD5_128), |
| #endif |
| #ifndef OPENSSL_NO_SHA1 |
| PLUGIN_PROVIDE(SIGNER, AUTH_HMAC_SHA1_96), |
| PLUGIN_PROVIDE(SIGNER, AUTH_HMAC_SHA1_128), |
| PLUGIN_PROVIDE(SIGNER, AUTH_HMAC_SHA1_160), |
| #endif |
| #ifndef OPENSSL_NO_SHA256 |
| PLUGIN_PROVIDE(SIGNER, AUTH_HMAC_SHA2_256_128), |
| PLUGIN_PROVIDE(SIGNER, AUTH_HMAC_SHA2_256_256), |
| #endif |
| #ifndef OPENSSL_NO_SHA512 |
| PLUGIN_PROVIDE(SIGNER, AUTH_HMAC_SHA2_384_192), |
| PLUGIN_PROVIDE(SIGNER, AUTH_HMAC_SHA2_384_384), |
| PLUGIN_PROVIDE(SIGNER, AUTH_HMAC_SHA2_512_256), |
| PLUGIN_PROVIDE(SIGNER, AUTH_HMAC_SHA2_512_512), |
| #endif |
| #endif /* OPENSSL_NO_HMAC */ |
| #if (OPENSSL_VERSION_NUMBER >= 0x1000100fL && !defined(OPENSSL_NO_AES)) || \ |
| (OPENSSL_VERSION_NUMBER >= 0x1010000fL && !defined(OPENSSL_NO_CHACHA)) |
| /* AEAD (AES GCM since 1.0.1, ChaCha20-Poly1305 since 1.1.0) */ |
| PLUGIN_REGISTER(AEAD, openssl_aead_create), |
| #ifndef OPENSSL_NO_AES |
| PLUGIN_PROVIDE(AEAD, ENCR_AES_GCM_ICV16, 16), |
| PLUGIN_PROVIDE(AEAD, ENCR_AES_GCM_ICV16, 24), |
| PLUGIN_PROVIDE(AEAD, ENCR_AES_GCM_ICV16, 32), |
| PLUGIN_PROVIDE(AEAD, ENCR_AES_GCM_ICV12, 16), |
| PLUGIN_PROVIDE(AEAD, ENCR_AES_GCM_ICV12, 24), |
| PLUGIN_PROVIDE(AEAD, ENCR_AES_GCM_ICV12, 32), |
| PLUGIN_PROVIDE(AEAD, ENCR_AES_GCM_ICV8, 16), |
| PLUGIN_PROVIDE(AEAD, ENCR_AES_GCM_ICV8, 24), |
| PLUGIN_PROVIDE(AEAD, ENCR_AES_GCM_ICV8, 32), |
| #if OPENSSL_VERSION_NUMBER >= 0x1010000fL |
| /* CCM is available before 1.1.0 but not via generic controls */ |
| PLUGIN_PROVIDE(AEAD, ENCR_AES_CCM_ICV16, 16), |
| PLUGIN_PROVIDE(AEAD, ENCR_AES_CCM_ICV16, 24), |
| PLUGIN_PROVIDE(AEAD, ENCR_AES_CCM_ICV16, 32), |
| PLUGIN_PROVIDE(AEAD, ENCR_AES_CCM_ICV12, 16), |
| PLUGIN_PROVIDE(AEAD, ENCR_AES_CCM_ICV12, 24), |
| PLUGIN_PROVIDE(AEAD, ENCR_AES_CCM_ICV12, 32), |
| PLUGIN_PROVIDE(AEAD, ENCR_AES_CCM_ICV8, 16), |
| PLUGIN_PROVIDE(AEAD, ENCR_AES_CCM_ICV8, 24), |
| PLUGIN_PROVIDE(AEAD, ENCR_AES_CCM_ICV8, 32), |
| #endif /* OPENSSL_VERSION_NUMBER */ |
| #endif /* OPENSSL_NO_AES */ |
| #if OPENSSL_VERSION_NUMBER >= 0x1010000fL && !defined(OPENSSL_NO_CHACHA) |
| PLUGIN_PROVIDE(AEAD, ENCR_CHACHA20_POLY1305, 32), |
| #endif /* OPENSSL_NO_CHACHA */ |
| #endif /* OPENSSL_VERSION_NUMBER */ |
| #ifndef OPENSSL_NO_ECDH |
| /* EC DH groups */ |
| PLUGIN_REGISTER(DH, openssl_ec_diffie_hellman_create), |
| PLUGIN_PROVIDE(DH, ECP_256_BIT), |
| PLUGIN_PROVIDE(DH, ECP_384_BIT), |
| PLUGIN_PROVIDE(DH, ECP_521_BIT), |
| PLUGIN_PROVIDE(DH, ECP_224_BIT), |
| PLUGIN_PROVIDE(DH, ECP_192_BIT), |
| #if OPENSSL_VERSION_NUMBER >= 0x10002000L |
| PLUGIN_PROVIDE(DH, ECP_256_BP), |
| PLUGIN_PROVIDE(DH, ECP_384_BP), |
| PLUGIN_PROVIDE(DH, ECP_512_BP), |
| PLUGIN_PROVIDE(DH, ECP_224_BP), |
| #endif /* OPENSSL_VERSION_NUMBER */ |
| #endif /* OPENSSL_NO_ECDH */ |
| #ifndef OPENSSL_NO_DH |
| /* MODP DH groups */ |
| PLUGIN_REGISTER(DH, openssl_diffie_hellman_create), |
| PLUGIN_PROVIDE(DH, MODP_3072_BIT), |
| PLUGIN_PROVIDE(DH, MODP_4096_BIT), |
| PLUGIN_PROVIDE(DH, MODP_6144_BIT), |
| PLUGIN_PROVIDE(DH, MODP_8192_BIT), |
| PLUGIN_PROVIDE(DH, MODP_2048_BIT), |
| PLUGIN_PROVIDE(DH, MODP_2048_224), |
| PLUGIN_PROVIDE(DH, MODP_2048_256), |
| PLUGIN_PROVIDE(DH, MODP_1536_BIT), |
| PLUGIN_PROVIDE(DH, MODP_1024_BIT), |
| PLUGIN_PROVIDE(DH, MODP_1024_160), |
| PLUGIN_PROVIDE(DH, MODP_768_BIT), |
| PLUGIN_PROVIDE(DH, MODP_CUSTOM), |
| #endif |
| #ifndef OPENSSL_NO_RSA |
| /* RSA private/public key loading */ |
| PLUGIN_REGISTER(PRIVKEY, openssl_rsa_private_key_load, TRUE), |
| PLUGIN_PROVIDE(PRIVKEY, KEY_RSA), |
| PLUGIN_REGISTER(PRIVKEY_GEN, openssl_rsa_private_key_gen, FALSE), |
| PLUGIN_PROVIDE(PRIVKEY_GEN, KEY_RSA), |
| PLUGIN_REGISTER(PUBKEY, openssl_rsa_public_key_load, TRUE), |
| PLUGIN_PROVIDE(PUBKEY, KEY_RSA), |
| PLUGIN_REGISTER(PUBKEY, openssl_rsa_public_key_load, TRUE), |
| PLUGIN_PROVIDE(PUBKEY, KEY_ANY), |
| /* signature/encryption schemes */ |
| PLUGIN_PROVIDE(PRIVKEY_SIGN, SIGN_RSA_EMSA_PKCS1_NULL), |
| PLUGIN_PROVIDE(PUBKEY_VERIFY, SIGN_RSA_EMSA_PKCS1_NULL), |
| #if OPENSSL_VERSION_NUMBER >= 0x10000000L |
| PLUGIN_PROVIDE(PRIVKEY_SIGN, SIGN_RSA_EMSA_PSS), |
| PLUGIN_PROVIDE(PUBKEY_VERIFY, SIGN_RSA_EMSA_PSS), |
| #endif |
| #ifndef OPENSSL_NO_SHA1 |
| PLUGIN_PROVIDE(PRIVKEY_SIGN, SIGN_RSA_EMSA_PKCS1_SHA1), |
| PLUGIN_PROVIDE(PUBKEY_VERIFY, SIGN_RSA_EMSA_PKCS1_SHA1), |
| #endif |
| #ifndef OPENSSL_NO_SHA256 |
| PLUGIN_PROVIDE(PRIVKEY_SIGN, SIGN_RSA_EMSA_PKCS1_SHA2_224), |
| PLUGIN_PROVIDE(PRIVKEY_SIGN, SIGN_RSA_EMSA_PKCS1_SHA2_256), |
| PLUGIN_PROVIDE(PUBKEY_VERIFY, SIGN_RSA_EMSA_PKCS1_SHA2_224), |
| PLUGIN_PROVIDE(PUBKEY_VERIFY, SIGN_RSA_EMSA_PKCS1_SHA2_256), |
| #endif |
| #ifndef OPENSSL_NO_SHA512 |
| PLUGIN_PROVIDE(PRIVKEY_SIGN, SIGN_RSA_EMSA_PKCS1_SHA2_384), |
| PLUGIN_PROVIDE(PRIVKEY_SIGN, SIGN_RSA_EMSA_PKCS1_SHA2_512), |
| PLUGIN_PROVIDE(PUBKEY_VERIFY, SIGN_RSA_EMSA_PKCS1_SHA2_384), |
| PLUGIN_PROVIDE(PUBKEY_VERIFY, SIGN_RSA_EMSA_PKCS1_SHA2_512), |
| #endif |
| #if OPENSSL_VERSION_NUMBER >= 0x1010100fL && !defined(OPENSSL_NO_SHA3) |
| PLUGIN_PROVIDE(PRIVKEY_SIGN, SIGN_RSA_EMSA_PKCS1_SHA3_224), |
| PLUGIN_PROVIDE(PRIVKEY_SIGN, SIGN_RSA_EMSA_PKCS1_SHA3_256), |
| PLUGIN_PROVIDE(PRIVKEY_SIGN, SIGN_RSA_EMSA_PKCS1_SHA3_384), |
| PLUGIN_PROVIDE(PRIVKEY_SIGN, SIGN_RSA_EMSA_PKCS1_SHA3_512), |
| PLUGIN_PROVIDE(PUBKEY_VERIFY, SIGN_RSA_EMSA_PKCS1_SHA3_224), |
| PLUGIN_PROVIDE(PUBKEY_VERIFY, SIGN_RSA_EMSA_PKCS1_SHA3_256), |
| PLUGIN_PROVIDE(PUBKEY_VERIFY, SIGN_RSA_EMSA_PKCS1_SHA3_384), |
| PLUGIN_PROVIDE(PUBKEY_VERIFY, SIGN_RSA_EMSA_PKCS1_SHA3_512), |
| #endif |
| #ifndef OPENSSL_NO_MD5 |
| PLUGIN_PROVIDE(PRIVKEY_SIGN, SIGN_RSA_EMSA_PKCS1_MD5), |
| PLUGIN_PROVIDE(PUBKEY_VERIFY, SIGN_RSA_EMSA_PKCS1_MD5), |
| #endif |
| PLUGIN_PROVIDE(PRIVKEY_DECRYPT, ENCRYPT_RSA_PKCS1), |
| PLUGIN_PROVIDE(PUBKEY_ENCRYPT, ENCRYPT_RSA_PKCS1), |
| #endif /* OPENSSL_NO_RSA */ |
| /* certificate/CRL loading */ |
| PLUGIN_REGISTER(CERT_DECODE, openssl_x509_load, TRUE), |
| PLUGIN_PROVIDE(CERT_DECODE, CERT_X509), |
| PLUGIN_SDEPEND(PUBKEY, KEY_RSA), |
| PLUGIN_SDEPEND(PUBKEY, KEY_ECDSA), |
| PLUGIN_SDEPEND(PUBKEY, KEY_DSA), |
| PLUGIN_REGISTER(CERT_DECODE, openssl_crl_load, TRUE), |
| PLUGIN_PROVIDE(CERT_DECODE, CERT_X509_CRL), |
| #if OPENSSL_VERSION_NUMBER >= 0x0090807fL |
| #ifndef OPENSSL_NO_CMS |
| PLUGIN_REGISTER(CONTAINER_DECODE, openssl_pkcs7_load, TRUE), |
| PLUGIN_PROVIDE(CONTAINER_DECODE, CONTAINER_PKCS7), |
| #endif /* OPENSSL_NO_CMS */ |
| #endif /* OPENSSL_VERSION_NUMBER */ |
| PLUGIN_REGISTER(CONTAINER_DECODE, openssl_pkcs12_load, TRUE), |
| PLUGIN_PROVIDE(CONTAINER_DECODE, CONTAINER_PKCS12), |
| #ifndef OPENSSL_NO_ECDSA |
| /* EC private/public key loading */ |
| PLUGIN_REGISTER(PRIVKEY, openssl_ec_private_key_load, TRUE), |
| PLUGIN_PROVIDE(PRIVKEY, KEY_ECDSA), |
| PLUGIN_REGISTER(PRIVKEY_GEN, openssl_ec_private_key_gen, FALSE), |
| PLUGIN_PROVIDE(PRIVKEY_GEN, KEY_ECDSA), |
| PLUGIN_REGISTER(PUBKEY, openssl_ec_public_key_load, TRUE), |
| PLUGIN_PROVIDE(PUBKEY, KEY_ECDSA), |
| /* signature encryption schemes */ |
| PLUGIN_PROVIDE(PRIVKEY_SIGN, SIGN_ECDSA_WITH_NULL), |
| PLUGIN_PROVIDE(PUBKEY_VERIFY, SIGN_ECDSA_WITH_NULL), |
| #ifndef OPENSSL_NO_SHA1 |
| PLUGIN_PROVIDE(PRIVKEY_SIGN, SIGN_ECDSA_WITH_SHA1_DER), |
| PLUGIN_PROVIDE(PUBKEY_VERIFY, SIGN_ECDSA_WITH_SHA1_DER), |
| #endif |
| #ifndef OPENSSL_NO_SHA256 |
| PLUGIN_PROVIDE(PRIVKEY_SIGN, SIGN_ECDSA_WITH_SHA256_DER), |
| PLUGIN_PROVIDE(PUBKEY_VERIFY, SIGN_ECDSA_WITH_SHA256_DER), |
| PLUGIN_PROVIDE(PRIVKEY_SIGN, SIGN_ECDSA_256), |
| PLUGIN_PROVIDE(PUBKEY_VERIFY, SIGN_ECDSA_256), |
| #endif |
| #ifndef OPENSSL_NO_SHA512 |
| PLUGIN_PROVIDE(PRIVKEY_SIGN, SIGN_ECDSA_WITH_SHA384_DER), |
| PLUGIN_PROVIDE(PRIVKEY_SIGN, SIGN_ECDSA_WITH_SHA512_DER), |
| PLUGIN_PROVIDE(PUBKEY_VERIFY, SIGN_ECDSA_WITH_SHA384_DER), |
| PLUGIN_PROVIDE(PUBKEY_VERIFY, SIGN_ECDSA_WITH_SHA512_DER), |
| PLUGIN_PROVIDE(PRIVKEY_SIGN, SIGN_ECDSA_384), |
| PLUGIN_PROVIDE(PRIVKEY_SIGN, SIGN_ECDSA_521), |
| PLUGIN_PROVIDE(PUBKEY_VERIFY, SIGN_ECDSA_384), |
| PLUGIN_PROVIDE(PUBKEY_VERIFY, SIGN_ECDSA_521), |
| #endif |
| #endif /* OPENSSL_NO_ECDSA */ |
| #if OPENSSL_VERSION_NUMBER >= 0x1010100fL && !defined(OPENSSL_NO_ECDH) |
| PLUGIN_REGISTER(DH, openssl_x_diffie_hellman_create), |
| /* available since 1.1.0a, but we require 1.1.1 features */ |
| PLUGIN_PROVIDE(DH, CURVE_25519), |
| /* available since 1.1.1 */ |
| PLUGIN_PROVIDE(DH, CURVE_448), |
| #endif /* OPENSSL_VERSION_NUMBER && !OPENSSL_NO_ECDH */ |
| #if OPENSSL_VERSION_NUMBER >= 0x1010100fL && !defined(OPENSSL_NO_EC) |
| /* EdDSA private/public key loading */ |
| PLUGIN_REGISTER(PUBKEY, openssl_ed_public_key_load, TRUE), |
| PLUGIN_PROVIDE(PUBKEY, KEY_ED25519), |
| PLUGIN_PROVIDE(PUBKEY, KEY_ED448), |
| PLUGIN_REGISTER(PRIVKEY, openssl_ed_private_key_load, TRUE), |
| PLUGIN_PROVIDE(PRIVKEY, KEY_ED25519), |
| PLUGIN_PROVIDE(PRIVKEY, KEY_ED448), |
| PLUGIN_REGISTER(PRIVKEY_GEN, openssl_ed_private_key_gen, FALSE), |
| PLUGIN_PROVIDE(PRIVKEY_GEN, KEY_ED25519), |
| PLUGIN_PROVIDE(PRIVKEY_GEN, KEY_ED448), |
| PLUGIN_PROVIDE(PRIVKEY_SIGN, SIGN_ED25519), |
| PLUGIN_PROVIDE(PRIVKEY_SIGN, SIGN_ED448), |
| PLUGIN_PROVIDE(PUBKEY_VERIFY, SIGN_ED25519), |
| PLUGIN_PROVIDE(PUBKEY_VERIFY, SIGN_ED448), |
| /* register a pro forma identity hasher, never instantiated */ |
| PLUGIN_REGISTER(HASHER, return_null), |
| PLUGIN_PROVIDE(HASHER, HASH_IDENTITY), |
| #endif /* OPENSSL_VERSION_NUMBER && !OPENSSL_NO_EC */ |
| /* generic key loader */ |
| PLUGIN_REGISTER(PRIVKEY, openssl_private_key_load, TRUE), |
| PLUGIN_PROVIDE(PRIVKEY, KEY_ANY), |
| PLUGIN_REGISTER(PRIVKEY, openssl_private_key_connect, FALSE), |
| PLUGIN_PROVIDE(PRIVKEY, KEY_ANY), |
| PLUGIN_REGISTER(RNG, openssl_rng_create), |
| PLUGIN_PROVIDE(RNG, RNG_STRONG), |
| PLUGIN_PROVIDE(RNG, RNG_WEAK), |
| }; |
| *features = f; |
| return countof(f); |
| } |
| |
| METHOD(plugin_t, destroy, void, |
| private_openssl_plugin_t *this) |
| { |
| /* OpenSSL 1.1.0 cleans up itself at exit and while OPENSSL_cleanup() exists we |
| * can't call it as we couldn't re-initialize the library (as required by the |
| * unit tests and the Android app) */ |
| #if OPENSSL_VERSION_NUMBER < 0x10100000L |
| #ifndef OPENSSL_IS_BORINGSSL |
| CONF_modules_free(); |
| OBJ_cleanup(); |
| #endif |
| EVP_cleanup(); |
| #ifndef OPENSSL_NO_ENGINE |
| ENGINE_cleanup(); |
| #endif /* OPENSSL_NO_ENGINE */ |
| CRYPTO_cleanup_all_ex_data(); |
| threading_cleanup(); |
| ERR_free_strings(); |
| #endif /* OPENSSL_VERSION_NUMBER */ |
| |
| free(this); |
| } |
| |
| /* |
| * see header file |
| */ |
| plugin_t *openssl_plugin_create() |
| { |
| private_openssl_plugin_t *this; |
| int fips_mode; |
| |
| fips_mode = lib->settings->get_int(lib->settings, |
| "%s.plugins.openssl.fips_mode", FIPS_MODE, lib->ns); |
| #ifdef OPENSSL_FIPS |
| if (fips_mode) |
| { |
| if (FIPS_mode() != fips_mode && !FIPS_mode_set(fips_mode)) |
| { |
| DBG1(DBG_LIB, "unable to set openssl FIPS mode(%d) from (%d)", |
| fips_mode, FIPS_mode()); |
| return NULL; |
| } |
| } |
| #else |
| if (fips_mode) |
| { |
| DBG1(DBG_LIB, "openssl FIPS mode(%d) unavailable", fips_mode); |
| return NULL; |
| } |
| #endif |
| |
| INIT(this, |
| .public = { |
| .plugin = { |
| .get_name = _get_name, |
| .get_features = _get_features, |
| .destroy = _destroy, |
| }, |
| }, |
| ); |
| |
| #if OPENSSL_VERSION_NUMBER >= 0x10100000L |
| /* note that we can't call OPENSSL_cleanup() when the plugin is destroyed |
| * as we couldn't initialize the library again afterwards */ |
| OPENSSL_init_crypto(OPENSSL_INIT_LOAD_CONFIG | |
| OPENSSL_INIT_ENGINE_ALL_BUILTIN, NULL); |
| #else /* OPENSSL_VERSION_NUMBER */ |
| threading_init(); |
| #ifndef OPENSSL_IS_BORINGSSL |
| OPENSSL_config(NULL); |
| #endif |
| OpenSSL_add_all_algorithms(); |
| #ifndef OPENSSL_NO_ENGINE |
| /* activate support for hardware accelerators */ |
| ENGINE_load_builtin_engines(); |
| ENGINE_register_all_complete(); |
| #endif /* OPENSSL_NO_ENGINE */ |
| #endif /* OPENSSL_VERSION_NUMBER */ |
| |
| #ifdef OPENSSL_FIPS |
| /* we do this here as it may have been enabled via openssl.conf */ |
| fips_mode = FIPS_mode(); |
| dbg(DBG_LIB, strpfx(lib->ns, "charon") ? 1 : 2, |
| "openssl FIPS mode(%d) - %sabled ", fips_mode, fips_mode ? "en" : "dis"); |
| #endif /* OPENSSL_FIPS */ |
| |
| #if OPENSSL_VERSION_NUMBER < 0x1010100fL |
| if (!seed_rng()) |
| { |
| DBG1(DBG_CFG, "no RNG found to seed OpenSSL"); |
| destroy(this); |
| return NULL; |
| } |
| #endif /* OPENSSL_VERSION_NUMBER */ |
| |
| return &this->public.plugin; |
| } |
