HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/shared/crypto-util.c

111,521 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: 76b856ea08ef69bb3acade436a796c5b42ed4935

Lines 2001–2727 of 2,727

                return log_openssl_errors(LOG_DEBUG, "Failed to get X509 digest NID");
 
        const EVP_MD *md = sym_EVP_get_digestbyname(hash_algorithm ?: "SHA256");
        if (!md)
                return log_debug_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "Unsupported digest algorithm '%s'",
                                       hash_algorithm ?: "SHA256");
 
        _cleanup_(PKCS7_SIGNER_INFO_freep) PKCS7_SIGNER_INFO *si = sym_PKCS7_SIGNER_INFO_new();
        if (!si)
                return log_oom();
 
        if (private_key) {
                if (sym_PKCS7_SIGNER_INFO_set(si, certificate, private_key, md) <= 0)
                        return log_openssl_errors(LOG_DEBUG, "Failed to configure signer info");
        } else {
                if (sym_ASN1_INTEGER_set(si->version, 1) == 0)
                        return log_openssl_errors(LOG_DEBUG, "Failed to set signer info version");
 
                if (sym_X509_NAME_set(&si->issuer_and_serial->issuer, sym_X509_get_issuer_name(certificate)) == 0)
                        return log_openssl_errors(LOG_DEBUG, "Failed to set signer info issuer");
 
                sym_ASN1_INTEGER_free(si->issuer_and_serial->serial);
                si->issuer_and_serial->serial = sym_ASN1_INTEGER_dup(sym_X509_get0_serialNumber(certificate));
                if (!si->issuer_and_serial->serial)
                        return log_openssl_errors(LOG_DEBUG, "Failed to set signer info serial");
 
                if (sym_X509_ALGOR_set0(si->digest_alg, sym_OBJ_nid2obj(sym_EVP_MD_get_type(md)), V_ASN1_NULL, NULL) == 0)
                        return log_openssl_errors(LOG_DEBUG, "Failed to set signer info digest algorithm");
 
                if (sym_X509_ALGOR_set0(si->digest_enc_alg, sym_OBJ_nid2obj(x509_pknid), V_ASN1_NULL, NULL) == 0)
                        return log_openssl_errors(LOG_DEBUG, "Failed to set signer info signing algorithm");
        }
 
        if (sym_PKCS7_add_signer(p7, si) == 0)
                return log_openssl_errors(LOG_DEBUG, "Failed to set PKCS7 signer info");
 
        *ret_p7 = TAKE_PTR(p7);
        if (ret_si)
                /* We do not pass ownership here, 'si' object remains owned by 'p7' object. */
                *ret_si = si;
 
        TAKE_PTR(si);
 
        return 0;
}
 
int string_hashsum(
                const char *s,
                size_t len,
                const char *md_algorithm,
                char **ret) {
 
        _cleanup_free_ void *hash = NULL;
        size_t hash_size;
        _cleanup_free_ char *enc = NULL;
        int r;
 
        assert(s || len == 0);
        assert(md_algorithm);
        assert(ret);
 
        r = openssl_digest(md_algorithm, s, len, &hash, &hash_size);
        if (r < 0)
                return r;
 
        enc = hexmem(hash, hash_size);
        if (!enc)
                return -ENOMEM;
 
        *ret = TAKE_PTR(enc);
        return 0;
}
 
static int ecc_pkey_generate_volume_keys(
                EVP_PKEY *pkey,
                void **ret_decrypted_key,
                size_t *ret_decrypted_key_size,
                void **ret_saved_key,
                size_t *ret_saved_key_size) {
 
        assert(ret_decrypted_key);
        assert(ret_decrypted_key_size);
        assert(ret_saved_key);
        assert(ret_saved_key_size);
 
        _cleanup_(EVP_PKEY_freep) EVP_PKEY *pkey_new = NULL;
        _cleanup_(erase_and_freep) void *decrypted_key = NULL;
        size_t decrypted_key_size, saved_key_size;
        int r;
 
        _cleanup_free_ char *curve_name = NULL;
        size_t len = 0;
 
        if (sym_EVP_PKEY_get_group_name(pkey, NULL, 0, &len) != 1 || len == 0)
                return log_openssl_errors(LOG_DEBUG, "Failed to determine PKEY group name length");
 
        len++;
        curve_name = new(char, len);
        if (!curve_name)
                return log_oom_debug();
 
        if (sym_EVP_PKEY_get_group_name(pkey, curve_name, len, &len) != 1)
                return log_openssl_errors(LOG_DEBUG, "Failed to get PKEY group name");
 
        r = ecc_pkey_new(sym_OBJ_sn2nid(curve_name), &pkey_new);
        if (r < 0)
                return log_debug_errno(r, "Failed to generate a new EC keypair: %m");
 
        r = ecc_ecdh(pkey_new, pkey, &decrypted_key, &decrypted_key_size);
        if (r < 0)
                return log_debug_errno(r, "Failed to derive shared secret: %m");
 
        /* EVP_PKEY_get1_encoded_public_key() always returns uncompressed format of EC points.
           See https://github.com/openssl/openssl/discussions/22835 */
        _cleanup_(OPENSSL_freep) void *buf = NULL;
        saved_key_size = sym_EVP_PKEY_get1_encoded_public_key(pkey_new, (unsigned char**) &buf);
        if (saved_key_size == 0)
                return log_openssl_errors(LOG_DEBUG, "Failed to convert the generated public key to SEC1 format");
 
        /* 'buf' is allocated by OpenSSL and must be freed via OPENSSL_free(). We duplicate it here so the
         * caller can safely use standard free(). */
        _cleanup_free_ void *saved_key = memdup(buf, saved_key_size);
        if (!saved_key)
                return log_oom_debug();
 
        *ret_decrypted_key = TAKE_PTR(decrypted_key);
        *ret_decrypted_key_size = decrypted_key_size;
        *ret_saved_key = TAKE_PTR(saved_key);
        *ret_saved_key_size = saved_key_size;
        return 0;
}
 
static int rsa_pkey_generate_volume_keys(
                EVP_PKEY *pkey,
                const char *digest_alg,
                void **ret_decrypted_key,
                size_t *ret_decrypted_key_size,
                void **ret_saved_key,
                size_t *ret_saved_key_size) {
 
        _cleanup_(erase_and_freep) void *decrypted_key = NULL;
        _cleanup_free_ void *saved_key = NULL;
        size_t decrypted_key_size, saved_key_size;
        int r;
 
        assert(digest_alg);
        assert(ret_decrypted_key);
        assert(ret_decrypted_key_size);
        assert(ret_saved_key);
        assert(ret_saved_key_size);
 
        r = rsa_pkey_to_suitable_key_size(pkey, &decrypted_key_size);
        if (r < 0)
                return log_debug_errno(r, "Failed to determine RSA public key size.");
 
        log_debug("Generating %zu bytes random key.", decrypted_key_size);
 
        decrypted_key = malloc(decrypted_key_size);
        if (!decrypted_key)
                return log_oom_debug();
 
        r = crypto_random_bytes(decrypted_key, decrypted_key_size);
        if (r < 0)
                return log_debug_errno(r, "Failed to generate random key: %m");
 
        r = rsa_oaep_encrypt_bytes(
                        pkey,
                        digest_alg,
                        /* label= */ NULL, /* matches PKCS#11 CKZ_DATA_SPECIFIED with empty source */
                        decrypted_key, decrypted_key_size,
                        &saved_key, &saved_key_size);
        if (r < 0)
                return log_debug_errno(r, "Failed to RSA-OAEP encrypt random key: %m");
 
        *ret_decrypted_key = TAKE_PTR(decrypted_key);
        *ret_decrypted_key_size = decrypted_key_size;
        *ret_saved_key = TAKE_PTR(saved_key);
        *ret_saved_key_size = saved_key_size;
        return 0;
}
 
int pkey_generate_volume_keys(
                EVP_PKEY *pkey,
                const char *rsa_oaep_digest_alg,
                void **ret_decrypted_key,
                size_t *ret_decrypted_key_size,
                void **ret_saved_key,
                size_t *ret_saved_key_size) {
 
        int r;
 
        assert(pkey);
        assert(ret_decrypted_key);
        assert(ret_decrypted_key_size);
        assert(ret_saved_key);
        assert(ret_saved_key_size);
 
        r = dlopen_libcrypto(LOG_DEBUG);
        if (r < 0)
                return r;
 
        int type = sym_EVP_PKEY_get_base_id(pkey);
        switch (type) {
 
        case EVP_PKEY_RSA:
                return rsa_pkey_generate_volume_keys(pkey, rsa_oaep_digest_alg ?: "SHA-1", ret_decrypted_key, ret_decrypted_key_size, ret_saved_key, ret_saved_key_size);
 
        case EVP_PKEY_EC:
                return ecc_pkey_generate_volume_keys(pkey, ret_decrypted_key, ret_decrypted_key_size, ret_saved_key, ret_saved_key_size);
 
        case NID_undef:
                return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "Failed to determine a type of public key.");
 
        default:
                return log_debug_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "Unsupported public key type: %s", sym_OBJ_nid2sn(type));
        }
}
 
static int load_key_from_provider(
                const char *provider,
                const char *private_key_uri,
                UI_METHOD *ui_method, /* can be NULL */
                EVP_PKEY **ret) {
 
        assert(provider);
        assert(private_key_uri);
        assert(ret);
 
        /* Load the provider so that this can work without any custom written configuration in /etc/.
         * Also load the 'default' as that seems to be the recommendation. */
        if (!sym_OSSL_PROVIDER_try_load(/* ctx= */ NULL, provider, /* retain_fallbacks= */ true))
                return log_openssl_errors(LOG_DEBUG, "Failed to load OpenSSL provider '%s'", provider);
        if (!sym_OSSL_PROVIDER_try_load(/* ctx= */ NULL, "default", /* retain_fallbacks= */ true))
                return log_openssl_errors(LOG_DEBUG, "Failed to load OpenSSL provider 'default'");
 
        _cleanup_(OSSL_STORE_closep) OSSL_STORE_CTX *store = sym_OSSL_STORE_open(
                        private_key_uri,
                        ui_method,
                        /* ui_data= */ NULL,
                        /* post_process= */ NULL,
                        /* post_process_data= */ NULL);
        if (!store)
                return log_openssl_errors(LOG_DEBUG, "Failed to open OpenSSL store via '%s'", private_key_uri);
 
        if (sym_OSSL_STORE_expect(store, OSSL_STORE_INFO_PKEY) == 0)
                return log_openssl_errors(LOG_DEBUG, "Failed to filter store by private keys");
 
        _cleanup_(OSSL_STORE_INFO_freep) OSSL_STORE_INFO *info = sym_OSSL_STORE_load(store);
        if (!info)
                return log_openssl_errors(LOG_DEBUG, "Failed to load OpenSSL store via '%s'", private_key_uri);
 
        _cleanup_(EVP_PKEY_freep) EVP_PKEY *private_key = sym_OSSL_STORE_INFO_get1_PKEY(info);
        if (!private_key)
                return log_openssl_errors(LOG_DEBUG, "Failed to load private key via '%s'", private_key_uri);
 
        *ret = TAKE_PTR(private_key);
 
        return 0;
}
 
static int load_key_from_engine(
                const char *engine,
                const char *private_key_uri,
                UI_METHOD *ui_method, /* can be NULL */
                EVP_PKEY **ret) {
 
#if !defined(OPENSSL_NO_ENGINE) && !defined(OPENSSL_NO_DEPRECATED_3_0)
        assert(engine);
        assert(private_key_uri);
        assert(ret);
 
        DISABLE_WARNING_DEPRECATED_DECLARATIONS;
        if (!sym_ENGINE_by_id ||
            !sym_ENGINE_free ||
            !sym_ENGINE_init ||
            !sym_ENGINE_load_private_key)
                return log_debug_errno(SYNTHETIC_ERRNO(EOPNOTSUPP),
                                       "ENGINE API is not available in the loaded OpenSSL library.");
 
        _cleanup_(ENGINE_freep) ENGINE *e = sym_ENGINE_by_id(engine);
        if (!e)
                return log_openssl_errors(LOG_DEBUG, "Failed to load signing engine '%s'", engine);
 
        if (sym_ENGINE_init(e) == 0)
                return log_openssl_errors(LOG_DEBUG, "Failed to initialize signing engine '%s'", engine);
 
        _cleanup_(EVP_PKEY_freep) EVP_PKEY *private_key = sym_ENGINE_load_private_key(e, private_key_uri, ui_method, /* callback_data= */ NULL);
        if (!private_key)
                return log_openssl_errors(LOG_DEBUG, "Failed to load private key from '%s'", private_key_uri);
        REENABLE_WARNING;
 
        *ret = TAKE_PTR(private_key);
 
        return 0;
#else
        return -EOPNOTSUPP;
#endif
}
 
static int openssl_load_private_key_from_file(const char *path, EVP_PKEY **ret) {
        _cleanup_(erase_and_freep) char *rawkey = NULL;
        _cleanup_(BIO_freep) BIO *kb = NULL;
        _cleanup_(EVP_PKEY_freep) EVP_PKEY *pk = NULL;
        size_t rawkeysz;
        int r;
 
        assert(path);
        assert(ret);
 
        r = read_full_file_full(
                        AT_FDCWD, path, UINT64_MAX, SIZE_MAX,
                        READ_FULL_FILE_SECURE|READ_FULL_FILE_WARN_WORLD_READABLE|READ_FULL_FILE_CONNECT_SOCKET,
                        NULL,
                        &rawkey, &rawkeysz);
        if (r < 0)
                return log_debug_errno(r, "Failed to read key file '%s': %m", path);
 
        kb = sym_BIO_new_mem_buf(rawkey, rawkeysz);
        if (!kb)
                return log_oom_debug();
 
        pk = sym_PEM_read_bio_PrivateKey(kb, NULL, NULL, NULL);
        if (!pk)
                return log_openssl_errors(LOG_DEBUG, "Failed to parse PEM private key");
 
        *ret = TAKE_PTR(pk);
 
        return 0;
}
 
static bool openssl_ui_supported(void) {
#ifndef OPENSSL_NO_UI_CONSOLE
        return
                sym_UI_OpenSSL &&
                sym_UI_create_method &&
                sym_UI_destroy_method &&
                sym_UI_get0_output_string &&
                sym_UI_get_default_method &&
                sym_UI_get_method &&
                sym_UI_get_string_type &&
                sym_UI_method_get_ex_data &&
                sym_UI_method_get_reader &&
                sym_UI_method_set_ex_data &&
                sym_UI_method_set_reader &&
                sym_UI_set_default_method &&
                sym_UI_set_result;
#else
        return false;
#endif
}
 
OpenSSLAskPasswordUI* openssl_ask_password_ui_free(OpenSSLAskPasswordUI *ui) {
        if (!ui)
                return NULL;
 
        assert(openssl_ui_supported());
 
#ifndef OPENSSL_NO_UI_CONSOLE
        /* Each OpenSSLAskPasswordUI object installs itself as default UI method, and restores the previous
         * one when freed. Hence, if multiple objects are allocated at the same time they must be freed in
         * the reverse order of allocation. */
        assert(sym_UI_get_default_method() == ui->method);
        sym_UI_set_default_method(ui->previous_method ?: sym_UI_OpenSSL());
        sym_UI_destroy_method(ui->method);
#endif
        return mfree(ui);
}
 
#ifndef OPENSSL_NO_UI_CONSOLE
static int openssl_ask_password_ui_read(UI *ui, UI_STRING *uis) {
        int r;
 
        assert(openssl_ui_supported());
 
        switch (sym_UI_get_string_type(uis)) {
        case UIT_PROMPT: {
                /* If no ask password request was configured use the default openssl UI. */
                AskPasswordRequest *req = (AskPasswordRequest*) sym_UI_method_get_ex_data(sym_UI_get_method(ui), 0);
                if (!req)
                        return (sym_UI_method_get_reader(sym_UI_OpenSSL()))(ui, uis);
 
                req->message = sym_UI_get0_output_string(uis);
 
                _cleanup_strv_free_ char **l = NULL;
                r = ask_password_auto(req, ASK_PASSWORD_ACCEPT_CACHED|ASK_PASSWORD_PUSH_CACHE, &l);
                if (r < 0) {
                        log_error_errno(r, "Failed to query for PIN: %m");
                        return 0;
                }
 
                if (strv_length(l) != 1) {
                        log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Expected only a single password/pin.");
                        return 0;
                }
 
                if (sym_UI_set_result(ui, uis, *l) != 0) {
                        log_openssl_errors(LOG_DEBUG, "Failed to set user interface result");
                        return 0;
                }
 
                return 1;
        }
        default:
                return (sym_UI_method_get_reader(sym_UI_OpenSSL()))(ui, uis);
        }
}
#endif
 
static int openssl_ask_password_ui_new(const AskPasswordRequest *request, OpenSSLAskPasswordUI **ret) {
        assert(request);
        assert(ret);
 
        if (!openssl_ui_supported()) {
                log_debug("OpenSSL UI API is not supported.");
                *ret = NULL;
                return 0;
        }
 
#ifndef OPENSSL_NO_UI_CONSOLE
        _cleanup_(UI_destroy_methodp) UI_METHOD *method = sym_UI_create_method("systemd-ask-password");
        if (!method)
                return log_openssl_errors(LOG_DEBUG, "Failed to initialize openssl user interface");
 
        if (sym_UI_method_set_reader(method, openssl_ask_password_ui_read) != 0)
                return log_openssl_errors(LOG_DEBUG, "Failed to set openssl user interface reader");
 
        OpenSSLAskPasswordUI *ui = new(OpenSSLAskPasswordUI, 1);
        if (!ui)
                return log_oom_debug();
 
        *ui = (OpenSSLAskPasswordUI) {
                .method = TAKE_PTR(method),
                .request = *request,
                .previous_method = sym_UI_get_default_method(),
        };
 
        sym_UI_set_default_method(ui->method);
 
        if (sym_UI_method_set_ex_data(ui->method, 0, &ui->request) == 0)
                return log_openssl_errors(LOG_DEBUG, "Failed to set extra data for UI method");
 
        *ret = TAKE_PTR(ui);
        return 0;
#else
        assert_not_reached();
#endif
}
 
int openssl_load_private_key(
                KeySourceType private_key_source_type,
                const char *private_key_source,
                const char *private_key,
                const AskPasswordRequest *request,
                EVP_PKEY **ret_private_key,
                OpenSSLAskPasswordUI **ret_user_interface) {
 
        int r;
 
        /* The caller must keep the OpenSSLAskPasswordUI object alive as long as the EVP_PKEY object so that
         * the user can enter any needed hardware token pin to unlock the private key when needed. */
 
        assert(private_key);
        assert(request);
        assert(ret_private_key);
        assert(ret_user_interface);
 
        r = dlopen_libcrypto(LOG_DEBUG);
        if (r < 0)
                return r;
 
        _cleanup_(openssl_ask_password_ui_freep) OpenSSLAskPasswordUI *ui = NULL;
 
        switch (private_key_source_type) {
        case OPENSSL_KEY_SOURCE_FILE:
                r = openssl_load_private_key_from_file(private_key, ret_private_key);
                break;
        case OPENSSL_KEY_SOURCE_ENGINE:
                r = openssl_ask_password_ui_new(request, &ui);
                if (r < 0)
                        return r;
 
                r = load_key_from_engine(private_key_source, private_key, ui ? ui->method : NULL, ret_private_key);
                break;
        case OPENSSL_KEY_SOURCE_PROVIDER:
                r = openssl_ask_password_ui_new(request, &ui);
                if (r < 0)
                        return r;
 
                r = load_key_from_provider(private_key_source, private_key, ui ? ui->method : NULL, ret_private_key);
                break;
        default:
                assert_not_reached();
        }
        if (r < 0)
                return r;
 
        *ret_user_interface = TAKE_PTR(ui);
        return 0;
}
 
int openssl_extract_public_key(EVP_PKEY *private_key, EVP_PKEY **ret) {
        int r;
 
        assert(private_key);
        assert(ret);
 
        r = dlopen_libcrypto(LOG_DEBUG);
        if (r < 0)
                return r;
 
        _cleanup_(OPENSSL_freep) void *buf = NULL;
        int len = sym_i2d_PUBKEY(private_key, (unsigned char**) &buf);
        if (len < 0)
                return log_openssl_errors(LOG_DEBUG, "Failed to extract public key in DER format");
 
        const unsigned char *t = buf;
        if (!sym_d2i_PUBKEY(ret, &t, len))
                return log_openssl_errors(LOG_DEBUG, "Failed to parse public key in DER format");
 
        return 0;
}
 
static int load_x509_certificate_from_file(const char *path, X509 **ret) {
        _cleanup_free_ char *rawcert = NULL;
        _cleanup_(X509_freep) X509 *cert = NULL;
        _cleanup_(BIO_freep) BIO *cb = NULL;
        size_t rawcertsz;
        int r;
 
        assert(path);
        assert(ret);
 
        r = read_full_file_full(
                        AT_FDCWD, path, UINT64_MAX, SIZE_MAX,
                        READ_FULL_FILE_CONNECT_SOCKET,
                        NULL,
                        &rawcert, &rawcertsz);
        if (r < 0)
                return log_debug_errno(r, "Failed to read certificate file '%s': %m", path);
 
        cb = sym_BIO_new_mem_buf(rawcert, rawcertsz);
        if (!cb)
                return log_oom_debug();
 
        cert = sym_PEM_read_bio_X509(cb, NULL, NULL, NULL);
        if (!cert)
                return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG), "Failed to parse X.509 certificate: %s",
                                       sym_ERR_error_string(sym_ERR_get_error(), NULL));
 
        *ret = TAKE_PTR(cert);
 
        return 0;
}
 
static int load_x509_certificate_from_provider(const char *provider, const char *certificate_uri, X509 **ret) {
        assert(provider);
        assert(certificate_uri);
        assert(ret);
 
        /* Load the provider so that this can work without any custom written configuration in /etc/.
         * Also load the 'default' as that seems to be the recommendation. */
        if (!sym_OSSL_PROVIDER_try_load(/* ctx= */ NULL, provider, /* retain_fallbacks= */ true))
                return log_openssl_errors(LOG_DEBUG, "Failed to load OpenSSL provider '%s'", provider);
        if (!sym_OSSL_PROVIDER_try_load(/* ctx= */ NULL, "default", /* retain_fallbacks= */ true))
                return log_openssl_errors(LOG_DEBUG, "Failed to load OpenSSL provider 'default'");
 
        _cleanup_(OSSL_STORE_closep) OSSL_STORE_CTX *store = sym_OSSL_STORE_open(
                        certificate_uri,
                        /* ui_method= */ NULL,
                        /* ui_method= */ NULL,
                        /* post_process= */ NULL,
                        /* post_process_data= */ NULL);
        if (!store)
                return log_openssl_errors(LOG_DEBUG, "Failed to open OpenSSL store via '%s'", certificate_uri);
 
        if (sym_OSSL_STORE_expect(store, OSSL_STORE_INFO_CERT) == 0)
                return log_openssl_errors(LOG_DEBUG, "Failed to filter store by X.509 certificates");
 
        _cleanup_(OSSL_STORE_INFO_freep) OSSL_STORE_INFO *info = sym_OSSL_STORE_load(store);
        if (!info)
                return log_openssl_errors(LOG_DEBUG, "Failed to load OpenSSL store via '%s'", certificate_uri);
 
        _cleanup_(X509_freep) X509 *cert = sym_OSSL_STORE_INFO_get1_CERT(info);
        if (!cert)
                return log_openssl_errors(LOG_DEBUG, "Failed to load certificate via '%s'", certificate_uri);
 
        *ret = TAKE_PTR(cert);
 
        return 0;
}
 
int x509_fingerprint(X509 *cert, uint8_t buffer[static SHA256_DIGEST_SIZE]) {
        _cleanup_(OPENSSL_freep) void *der = NULL;
        int dersz, r;
 
        assert(cert);
 
        r = dlopen_libcrypto(LOG_DEBUG);
        if (r < 0)
                return r;
 
        dersz = sym_i2d_X509(cert, (unsigned char**) &der);
        if (dersz < 0)
                return log_openssl_errors(LOG_DEBUG, "Unable to convert PEM certificate to DER format");
 
        sha256_direct(der, dersz, buffer);
        return 0;
}
 
int openssl_load_x509_certificate(
                CertificateSourceType certificate_source_type,
                const char *certificate_source,
                const char *certificate,
                X509 **ret) {
 
        int r;
 
        assert(certificate);
 
        r = dlopen_libcrypto(LOG_DEBUG);
        if (r < 0)
                return r;
 
        switch (certificate_source_type) {
 
        case OPENSSL_CERTIFICATE_SOURCE_FILE:
                r = load_x509_certificate_from_file(certificate, ret);
                break;
        case OPENSSL_CERTIFICATE_SOURCE_PROVIDER:
                r = load_x509_certificate_from_provider(certificate_source, certificate, ret);
                break;
        default:
                assert_not_reached();
        }
        if (r < 0)
                return log_debug_errno(
                                r,
                                "Failed to load certificate '%s' from OpenSSL certificate source %s: %m",
                                certificate,
                                certificate_source);
 
        return 0;
}
#endif
 
#if !HAVE_OPENSSL
int kdf_argon2id_derive(
                const struct iovec *password,
                const struct iovec *salt,
                const Argon2IdParameters *params,
                size_t derive_size,
                struct iovec *ret) {
 
        return -EOPNOTSUPP;
}
 
int kdf_hkdf_sha256(
                const struct iovec *key,
                const struct iovec *salt,
                const struct iovec *info,
                size_t derive_size,
                struct iovec *ret) {
 
        return -EOPNOTSUPP;
}
#endif
 
int parse_openssl_certificate_source_argument(
                const char *argument,
                char **certificate_source,
                CertificateSourceType *certificate_source_type) {
 
        CertificateSourceType type;
        const char *e = NULL;
        int r;
 
        assert(argument);
        assert(certificate_source);
        assert(certificate_source_type);
 
        if (streq(argument, "file"))
                type = OPENSSL_CERTIFICATE_SOURCE_FILE;
        else if ((e = startswith(argument, "provider:")))
                type = OPENSSL_CERTIFICATE_SOURCE_PROVIDER;
        else
                return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid certificate source '%s'", argument);
 
        r = free_and_strdup_warn(certificate_source, e);
        if (r < 0)
                return r;
 
        *certificate_source_type = type;
 
        return 0;
}
 
int parse_openssl_key_source_argument(
                const char *argument,
                char **private_key_source,
                KeySourceType *private_key_source_type) {
 
        KeySourceType type;
        const char *e = NULL;
        int r;
 
        assert(argument);
        assert(private_key_source);
        assert(private_key_source_type);
 
        if (streq(argument, "file"))
                type = OPENSSL_KEY_SOURCE_FILE;
        else if ((e = startswith(argument, "engine:")))
                type = OPENSSL_KEY_SOURCE_ENGINE;
        else if ((e = startswith(argument, "provider:")))
                type = OPENSSL_KEY_SOURCE_PROVIDER;
        else
                return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid private key source '%s'", argument);
 
        r = free_and_strdup_warn(private_key_source, e);
        if (r < 0)
                return r;
 
        *private_key_source_type = type;
 
        return 0;
}