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 1001–2000 of 2,727

 * be at least the minimum required key length for the cipher. The IV is optional but, if provided, it must
 * be at least the minimum iv length for the cipher. If no IV is provided and the cipher requires one, a
 * buffer of zeroes is used. Returns 0 on success, -EOPNOTSUPP if the cipher algorithm is not supported, or <
 * 0 on any other error. */
int openssl_cipher_many(
                const char *alg,
                size_t bits,
                const char *mode,
                const void *key,
                size_t key_size,
                const void *iv,
                size_t iv_size,
                const struct iovec data[],
                size_t n_data,
                void **ret,
                size_t *ret_size) {
 
        int r;
 
        assert(alg);
        assert(bits > 0);
        assert(mode);
        assert(key);
        assert(iv || iv_size == 0);
        assert(data || n_data == 0);
        assert(ret);
        assert(ret_size);
 
        r = dlopen_libcrypto(LOG_DEBUG);
        if (r < 0)
                return r;
 
        _cleanup_free_ char *cipher_alg = NULL;
        if (asprintf(&cipher_alg, "%s-%zu-%s", alg, bits, mode) < 0)
                return log_oom_debug();
 
        _cleanup_(EVP_CIPHER_freep) EVP_CIPHER *cipher = sym_EVP_CIPHER_fetch(NULL, cipher_alg, NULL);
        if (!cipher)
                return log_debug_errno(SYNTHETIC_ERRNO(EOPNOTSUPP),
                                       "Cipher algorithm '%s' not supported.", cipher_alg);
 
        _cleanup_(EVP_CIPHER_CTX_freep) EVP_CIPHER_CTX *ctx = sym_EVP_CIPHER_CTX_new();
        if (!ctx)
                return log_openssl_errors(LOG_DEBUG, "Failed to create new EVP_CIPHER_CTX");
 
        /* Verify enough key data was provided. */
        int cipher_key_length = sym_EVP_CIPHER_get_key_length(cipher);
        assert(cipher_key_length >= 0);
        if ((size_t) cipher_key_length > key_size)
                return log_debug_errno(SYNTHETIC_ERRNO(EINVAL),
                                       "Not enough key bytes provided, require %d", cipher_key_length);
 
        /* Verify enough IV data was provided or, if no IV was provided, use a zeroed buffer for IV data. */
        int cipher_iv_length = sym_EVP_CIPHER_get_iv_length(cipher);
        assert(cipher_iv_length >= 0);
        _cleanup_free_ void *zero_iv = NULL;
        if (iv_size == 0) {
                zero_iv = malloc0(cipher_iv_length);
                if (!zero_iv)
                        return log_oom_debug();
 
                iv = zero_iv;
                iv_size = (size_t) cipher_iv_length;
        }
        if ((size_t) cipher_iv_length > iv_size)
                return log_debug_errno(SYNTHETIC_ERRNO(EINVAL),
                                       "Not enough IV bytes provided, require %d", cipher_iv_length);
 
        if (!sym_EVP_EncryptInit(ctx, cipher, key, iv))
                return log_openssl_errors(LOG_DEBUG, "Failed to initialize EVP_CIPHER_CTX.");
 
        int cipher_block_size = sym_EVP_CIPHER_CTX_get_block_size(ctx);
        assert(cipher_block_size > 0);
 
        _cleanup_free_ uint8_t *buf = NULL;
        size_t size = 0;
 
        for (size_t i = 0; i < n_data; i++) {
                /* Cipher may produce (up to) input length + cipher block size of output. */
                if (!GREEDY_REALLOC(buf, size + data[i].iov_len + cipher_block_size))
                        return log_oom_debug();
 
                int update_size;
                if (!sym_EVP_EncryptUpdate(ctx, &buf[size], &update_size, data[i].iov_base, data[i].iov_len))
                        return log_openssl_errors(LOG_DEBUG, "Failed to update Cipher.");
 
                size += update_size;
        }
 
        if (!GREEDY_REALLOC(buf, size + cipher_block_size))
                return log_oom_debug();
 
        int final_size;
        if (!sym_EVP_EncryptFinal_ex(ctx, &buf[size], &final_size))
                return log_openssl_errors(LOG_DEBUG, "Failed to finalize Cipher.");
 
        *ret = TAKE_PTR(buf);
        *ret_size = size + final_size;
 
        return 0;
}
 
/* Perform Single-Step (aka "Concat") KDF. Currently, this only supports using the digest for the auxiliary
 * function. The derive_size parameter specifies how many bytes are derived.
 *
 * For more details see: https://www.openssl.org/docs/manmaster/man7/EVP_KDF-SS.html */
int kdf_ss_derive(
                const char *digest,
                const void *key,
                size_t key_size,
                const void *salt,
                size_t salt_size,
                const void *info,
                size_t info_size,
                size_t derive_size,
                void **ret) {
 
        int r;
 
        assert(digest);
        assert(key);
        assert(derive_size > 0);
        assert(ret);
 
        r = dlopen_libcrypto(LOG_DEBUG);
        if (r < 0)
                return r;
 
        _cleanup_(EVP_KDF_freep) EVP_KDF *kdf = sym_EVP_KDF_fetch(NULL, "SSKDF", NULL);
        if (!kdf)
                return log_openssl_errors(LOG_DEBUG, "Failed to create new EVP_KDF");
 
        _cleanup_(EVP_KDF_CTX_freep) EVP_KDF_CTX *ctx = sym_EVP_KDF_CTX_new(kdf);
        if (!ctx)
                return log_openssl_errors(LOG_DEBUG, "Failed to create new EVP_KDF_CTX");
 
        _cleanup_(OSSL_PARAM_BLD_freep) OSSL_PARAM_BLD *bld = sym_OSSL_PARAM_BLD_new();
        if (!bld)
                return log_openssl_errors(LOG_DEBUG, "Failed to create new OSSL_PARAM_BLD");
 
        _cleanup_free_ void *buf = malloc(derive_size);
        if (!buf)
                return log_oom_debug();
 
        if (!sym_OSSL_PARAM_BLD_push_utf8_string(bld, OSSL_KDF_PARAM_DIGEST, (char*) digest, 0))
                return log_openssl_errors(LOG_DEBUG, "Failed to add KDF-SS OSSL_KDF_PARAM_DIGEST");
 
        if (!sym_OSSL_PARAM_BLD_push_octet_string(bld, OSSL_KDF_PARAM_KEY, (char*) key, key_size))
                return log_openssl_errors(LOG_DEBUG, "Failed to add KDF-SS OSSL_KDF_PARAM_KEY");
 
        if (salt)
                if (!sym_OSSL_PARAM_BLD_push_octet_string(bld, OSSL_KDF_PARAM_SALT, (char*) salt, salt_size))
                        return log_openssl_errors(LOG_DEBUG, "Failed to add KDF-SS OSSL_KDF_PARAM_SALT");
 
        if (info)
                if (!sym_OSSL_PARAM_BLD_push_octet_string(bld, OSSL_KDF_PARAM_INFO, (char*) info, info_size))
                        return log_openssl_errors(LOG_DEBUG, "Failed to add KDF-SS OSSL_KDF_PARAM_INFO");
 
        _cleanup_(OSSL_PARAM_freep) OSSL_PARAM *params = sym_OSSL_PARAM_BLD_to_param(bld);
        if (!params)
                return log_openssl_errors(LOG_DEBUG, "Failed to build KDF-SS OSSL_PARAM");
 
        if (sym_EVP_KDF_derive(ctx, buf, derive_size, params) <= 0)
                return log_openssl_errors(LOG_DEBUG, "OpenSSL KDF-SS derive failed");
 
        *ret = TAKE_PTR(buf);
 
        return 0;
}
 
/* Perform Key-Based HMAC KDF. The mode must be "COUNTER" or "FEEDBACK". The parameter naming is from the
 * OpenSSL api, and maps to SP800-108 naming as "...key, salt, info, and seed correspond to KI, Label,
 * Context, and IV (respectively)...". The derive_size parameter specifies how many bytes are derived.
 *
 * For more details see: https://www.openssl.org/docs/manmaster/man7/EVP_KDF-KB.html */
int kdf_kb_hmac_derive(
                const char *mode,
                const char *digest,
                const void *key,
                size_t key_size,
                const void *salt,
                size_t salt_size,
                const void *info,
                size_t info_size,
                const void *seed,
                size_t seed_size,
                size_t derive_size,
                void **ret) {
 
        int r;
 
        assert(mode);
        assert(strcaseeq(mode, "COUNTER") || strcaseeq(mode, "FEEDBACK"));
        assert(digest);
        assert(key || key_size == 0);
        assert(salt || salt_size == 0);
        assert(info || info_size == 0);
        assert(seed || seed_size == 0);
        assert(derive_size > 0);
        assert(ret);
 
        r = dlopen_libcrypto(LOG_DEBUG);
        if (r < 0)
                return r;
 
        _cleanup_(EVP_KDF_freep) EVP_KDF *kdf = sym_EVP_KDF_fetch(NULL, "KBKDF", NULL);
        if (!kdf)
                return log_openssl_errors(LOG_DEBUG, "Failed to create new EVP_KDF");
 
        _cleanup_(EVP_KDF_CTX_freep) EVP_KDF_CTX *ctx = sym_EVP_KDF_CTX_new(kdf);
        if (!ctx)
                return log_openssl_errors(LOG_DEBUG, "Failed to create new EVP_KDF_CTX");
 
        _cleanup_(OSSL_PARAM_BLD_freep) OSSL_PARAM_BLD *bld = sym_OSSL_PARAM_BLD_new();
        if (!bld)
                return log_openssl_errors(LOG_DEBUG, "Failed to create new OSSL_PARAM_BLD");
 
        if (!sym_OSSL_PARAM_BLD_push_utf8_string(bld, OSSL_KDF_PARAM_MAC, (char*) "HMAC", 0))
                return log_openssl_errors(LOG_DEBUG, "Failed to add KDF-KB OSSL_KDF_PARAM_MAC");
 
        if (!sym_OSSL_PARAM_BLD_push_utf8_string(bld, OSSL_KDF_PARAM_MODE, (char*) mode, 0))
                return log_openssl_errors(LOG_DEBUG, "Failed to add KDF-KB OSSL_KDF_PARAM_MODE");
 
        if (!sym_OSSL_PARAM_BLD_push_utf8_string(bld, OSSL_KDF_PARAM_DIGEST, (char*) digest, 0))
                return log_openssl_errors(LOG_DEBUG, "Failed to add KDF-KB OSSL_KDF_PARAM_DIGEST");
 
        if (key)
                if (!sym_OSSL_PARAM_BLD_push_octet_string(bld, OSSL_KDF_PARAM_KEY, (char*) key, key_size))
                        return log_openssl_errors(LOG_DEBUG, "Failed to add KDF-KB OSSL_KDF_PARAM_KEY");
 
        if (salt)
                if (!sym_OSSL_PARAM_BLD_push_octet_string(bld, OSSL_KDF_PARAM_SALT, (char*) salt, salt_size))
                        return log_openssl_errors(LOG_DEBUG, "Failed to add KDF-KB OSSL_KDF_PARAM_SALT");
 
        if (info)
                if (!sym_OSSL_PARAM_BLD_push_octet_string(bld, OSSL_KDF_PARAM_INFO, (char*) info, info_size))
                        return log_openssl_errors(LOG_DEBUG, "Failed to add KDF-KB OSSL_KDF_PARAM_INFO");
 
        if (seed)
                if (!sym_OSSL_PARAM_BLD_push_octet_string(bld, OSSL_KDF_PARAM_SEED, (char*) seed, seed_size))
                        return log_openssl_errors(LOG_DEBUG, "Failed to add KDF-KB OSSL_KDF_PARAM_SEED");
 
        _cleanup_(OSSL_PARAM_freep) OSSL_PARAM *params = sym_OSSL_PARAM_BLD_to_param(bld);
        if (!params)
                return log_openssl_errors(LOG_DEBUG, "Failed to build KDF-KB OSSL_PARAM");
 
        _cleanup_free_ void *buf = malloc(derive_size);
        if (!buf)
                return log_oom_debug();
 
        if (sym_EVP_KDF_derive(ctx, buf, derive_size, params) <= 0)
                return log_openssl_errors(LOG_DEBUG, "OpenSSL KDF-KB derive failed");
 
        *ret = TAKE_PTR(buf);
 
        return 0;
}
 
/* Perform Argon2id KDF, producing derive_size bytes of output.
 *
 * For more details see: https://docs.openssl.org/master/man7/EVP_KDF-ARGON2/ */
int kdf_argon2id_derive(
                const struct iovec *password,
                const struct iovec *salt,
                const Argon2IdParameters *params,
                size_t derive_size,
                struct iovec *ret) {
 
        int r;
 
        assert(!password || password->iov_len > 0);
        assert(!salt || salt->iov_len > 0);
        assert(derive_size > 0);
        assert(ret);
 
        r = dlopen_libcrypto(LOG_DEBUG);
        if (r < 0)
                return r;
 
        _cleanup_(EVP_KDF_freep) EVP_KDF *kdf = sym_EVP_KDF_fetch(/* propq= */ NULL, "ARGON2ID", /* propq= */ NULL);
        if (!kdf)
                return log_openssl_errors(LOG_DEBUG, "Failed to create new EVP_KDF for ARGON2ID");
 
        _cleanup_(EVP_KDF_CTX_freep) EVP_KDF_CTX *ctx = sym_EVP_KDF_CTX_new(kdf);
        if (!ctx)
                return log_openssl_errors(LOG_DEBUG, "Failed to create new EVP_KDF_CTX");
 
        _cleanup_(OSSL_PARAM_BLD_freep) OSSL_PARAM_BLD *bld = sym_OSSL_PARAM_BLD_new();
        if (!bld)
                return log_openssl_errors(LOG_DEBUG, "Failed to create new OSSL_PARAM_BLD");
 
        assert(params);
        assert(params->memcost_bytes > 0);
        assert(params->iterations > 0);
        assert(params->lanes > 0);
 
        _cleanup_(erase_and_freep) void *buf = malloc(derive_size);
        if (!buf)
                return log_oom_debug();
 
        if (password && !sym_OSSL_PARAM_BLD_push_octet_string(bld, "pass", password->iov_base, password->iov_len))
                return log_openssl_errors(LOG_DEBUG, "Failed to add ARGON2ID pass");
 
        if (salt && !sym_OSSL_PARAM_BLD_push_octet_string(bld, "salt", salt->iov_base, salt->iov_len))
                return log_openssl_errors(LOG_DEBUG, "Failed to add ARGON2ID salt");
 
        uint64_t memcost_kb = params->memcost_bytes / 1024;
 
        if (memcost_kb > UINT_MAX)
                return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "Argon2id memory cost too large: %"PRIu64" bytes", params->memcost_bytes);
 
        if (!sym_OSSL_PARAM_BLD_push_uint(bld, "memcost", (unsigned) memcost_kb))
                return log_openssl_errors(LOG_DEBUG, "Failed to add ARGON2ID memcost");
 
        if (!sym_OSSL_PARAM_BLD_push_uint(bld, "iter", params->iterations))
                return log_openssl_errors(LOG_DEBUG, "Failed to add ARGON2ID iter");
 
        if (!sym_OSSL_PARAM_BLD_push_uint(bld, "lanes", params->lanes))
                return log_openssl_errors(LOG_DEBUG, "Failed to add ARGON2ID lanes");
 
        /* FIXME: drop sym_OSSL_set_max_threads() conditionalization once OpenSSL 3.2 becomes the minimum baseline */
        if (params->lanes > 1 && sym_OSSL_set_max_threads && !sym_OSSL_PARAM_BLD_push_uint(bld, "threads", params->lanes))
                return log_openssl_errors(LOG_DEBUG, "Failed to add ARGON2ID threads");
 
        _cleanup_(OSSL_PARAM_freep) OSSL_PARAM *openssl_params = sym_OSSL_PARAM_BLD_to_param(bld);
        if (!openssl_params)
                return log_openssl_errors(LOG_DEBUG, "Failed to build ARGON2ID OSSL_PARAM");
 
        /* FIXME: drop sym_OSSL_set_max_threads() conditionalization once OpenSSL 3.2 becomes the minimum baseline */
        uint64_t saved_max_threads = 0;
        if (params->lanes > 1 && sym_OSSL_set_max_threads) {
                if (sym_OSSL_get_max_threads)
                        saved_max_threads = sym_OSSL_get_max_threads(/* ctx= */ NULL);
                if (!sym_OSSL_set_max_threads(/* ctx= */ NULL, params->lanes))
                        return log_openssl_errors(LOG_DEBUG, "Failed to set Argon2id thread pool size");
        }
 
        if (sym_EVP_KDF_derive(ctx, buf, derive_size, openssl_params) <= 0) {
                if (params->lanes > 1 && sym_OSSL_set_max_threads)
                        sym_OSSL_set_max_threads(/* ctx= */ NULL, saved_max_threads);
                return log_openssl_errors(LOG_DEBUG, "OpenSSL ARGON2ID derive failed");
        }
 
        if (params->lanes > 1 && sym_OSSL_set_max_threads)
                sym_OSSL_set_max_threads(/* ctx= */ NULL, saved_max_threads);
 
        ret->iov_base = TAKE_PTR(buf);
        ret->iov_len = derive_size;
 
        return 0;
}
 
/* Perform HKDF (RFC 5869). 'key' is the input keying material (required, non-empty). 'salt' and 'info'
 * are optional: pass NULL or an empty iovec to omit. The output is written to 'ret' as a fresh allocation
 * of 'derive_size' bytes (must be ≤ 255 × HashLen).
 *
 * For more details see: https://www.openssl.org/docs/manmaster/man7/EVP_KDF-HKDF.html */
int kdf_hkdf_derive(
                const char *digest,
                const struct iovec *key,
                const struct iovec *salt,
                const struct iovec *info,
                size_t derive_size,
                struct iovec *ret) {
 
        int r;
 
        assert(digest);
        assert(iovec_is_set(key));
        assert(iovec_is_valid(salt));
        assert(iovec_is_valid(info));
        assert(derive_size > 0);
        assert(ret);
 
        r = dlopen_libcrypto(LOG_DEBUG);
        if (r < 0)
                return r;
 
        _cleanup_(EVP_KDF_freep) EVP_KDF *kdf = sym_EVP_KDF_fetch(/* libctx= */ NULL, "HKDF", /* properties= */ NULL);
        if (!kdf)
                return log_openssl_errors(LOG_DEBUG, "Failed to create new EVP_KDF");
 
        _cleanup_(EVP_KDF_CTX_freep) EVP_KDF_CTX *ctx = sym_EVP_KDF_CTX_new(kdf);
        if (!ctx)
                return log_openssl_errors(LOG_DEBUG, "Failed to create new EVP_KDF_CTX");
 
        _cleanup_(OSSL_PARAM_BLD_freep) OSSL_PARAM_BLD *bld = sym_OSSL_PARAM_BLD_new();
        if (!bld)
                return log_openssl_errors(LOG_DEBUG, "Failed to create new OSSL_PARAM_BLD");
 
        if (!sym_OSSL_PARAM_BLD_push_utf8_string(bld, OSSL_KDF_PARAM_DIGEST, (char*) digest, /* bsize= */ 0))
                return log_openssl_errors(LOG_DEBUG, "Failed to add HKDF OSSL_KDF_PARAM_DIGEST");
 
        if (!sym_OSSL_PARAM_BLD_push_octet_string(bld, OSSL_KDF_PARAM_KEY, key->iov_base, key->iov_len))
                return log_openssl_errors(LOG_DEBUG, "Failed to add HKDF OSSL_KDF_PARAM_KEY");
 
        if (iovec_is_set(salt))
                if (!sym_OSSL_PARAM_BLD_push_octet_string(bld, OSSL_KDF_PARAM_SALT, salt->iov_base, salt->iov_len))
                        return log_openssl_errors(LOG_DEBUG, "Failed to add HKDF OSSL_KDF_PARAM_SALT");
 
        if (iovec_is_set(info))
                if (!sym_OSSL_PARAM_BLD_push_octet_string(bld, OSSL_KDF_PARAM_INFO, info->iov_base, info->iov_len))
                        return log_openssl_errors(LOG_DEBUG, "Failed to add HKDF OSSL_KDF_PARAM_INFO");
 
        _cleanup_(OSSL_PARAM_freep) OSSL_PARAM *params = sym_OSSL_PARAM_BLD_to_param(bld);
        if (!params)
                return log_openssl_errors(LOG_DEBUG, "Failed to build HKDF OSSL_PARAM");
 
        _cleanup_(erase_and_freep) void *buf = malloc(derive_size);
        if (!buf)
                return log_oom_debug();
 
        if (sym_EVP_KDF_derive(ctx, buf, derive_size, params) <= 0)
                return log_openssl_errors(LOG_DEBUG, "OpenSSL HKDF derive failed");
 
        *ret = IOVEC_MAKE(TAKE_PTR(buf), derive_size);
        return 0;
}
 
/* Perform HKDF-SHA256 derivation, producing derive_size bytes of output. */
int kdf_hkdf_sha256(
                const struct iovec *key,
                const struct iovec *salt,
                const struct iovec *info,
                size_t derive_size,
                struct iovec *ret) {
 
        return kdf_hkdf_derive("SHA256", key, salt, info, derive_size, ret);
}
 
/* Encrypt the key data using RSA-OAEP with the provided label and specified digest algorithm. Returns 0 on
 * success, -EOPNOTSUPP if the digest algorithm is not supported, or < 0 for any other error. */
int rsa_oaep_encrypt_bytes(
                const EVP_PKEY *pkey,
                const char *digest_alg,
                const char *label,
                const void *decrypted_key,
                size_t decrypted_key_size,
                void **ret_encrypt_key,
                size_t *ret_encrypt_key_size) {
 
        int r;
 
        assert(pkey);
        assert(digest_alg);
        assert(decrypted_key);
        assert(decrypted_key_size > 0);
        assert(ret_encrypt_key);
        assert(ret_encrypt_key_size);
 
        r = dlopen_libcrypto(LOG_DEBUG);
        if (r < 0)
                return r;
 
        _cleanup_(EVP_MD_freep) EVP_MD *md = sym_EVP_MD_fetch(NULL, digest_alg, NULL);
        if (!md)
                return log_debug_errno(SYNTHETIC_ERRNO(EOPNOTSUPP),
                                       "Digest algorithm '%s' not supported.", digest_alg);
 
        _cleanup_(EVP_PKEY_CTX_freep) EVP_PKEY_CTX *ctx = sym_EVP_PKEY_CTX_new((EVP_PKEY*) pkey, NULL);
        if (!ctx)
                return log_openssl_errors(LOG_DEBUG, "Failed to create new EVP_PKEY_CTX");
 
        if (sym_EVP_PKEY_encrypt_init(ctx) <= 0)
                return log_openssl_errors(LOG_DEBUG, "Failed to initialize EVP_PKEY_CTX");
 
        if (sym_EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_PKCS1_OAEP_PADDING) <= 0)
                return log_openssl_errors(LOG_DEBUG, "Failed to configure RSA-OAEP padding");
 
        if (sym_EVP_PKEY_CTX_set_rsa_oaep_md(ctx, md) <= 0)
                return log_openssl_errors(LOG_DEBUG, "Failed to configure RSA-OAEP MD");
 
        if (label) {
                _cleanup_free_ char *duplabel = strdup(label);
                if (!duplabel)
                        return log_oom_debug();
 
                if (sym_EVP_PKEY_CTX_set0_rsa_oaep_label(ctx, duplabel, strlen(duplabel) + 1) <= 0)
                        return log_openssl_errors(LOG_DEBUG, "Failed to configure RSA-OAEP label");
                /* ctx owns this now, don't free */
                TAKE_PTR(duplabel);
        }
 
        size_t size = 0;
        if (sym_EVP_PKEY_encrypt(ctx, NULL, &size, decrypted_key, decrypted_key_size) <= 0)
                return log_openssl_errors(LOG_DEBUG, "Failed to determine RSA-OAEP encrypted key size");
 
        _cleanup_free_ void *buf = malloc(size);
        if (!buf)
                return log_oom_debug();
 
        if (sym_EVP_PKEY_encrypt(ctx, buf, &size, decrypted_key, decrypted_key_size) <= 0)
                return log_openssl_errors(LOG_DEBUG, "Failed to RSA-OAEP encrypt");
 
        *ret_encrypt_key = TAKE_PTR(buf);
        *ret_encrypt_key_size = size;
 
        return 0;
}
 
int rsa_pkey_to_suitable_key_size(
                EVP_PKEY *pkey,
                size_t *ret_suitable_key_size) {
 
        size_t suitable_key_size;
        int bits, r;
 
        assert(pkey);
        assert(ret_suitable_key_size);
 
        /* Analyzes the specified public key and that it is RSA. If so, will return a suitable size for a
         * disk encryption key to encrypt with RSA for use in PKCS#11 security token schemes. */
 
        r = dlopen_libcrypto(LOG_DEBUG);
        if (r < 0)
                return r;
 
        if (sym_EVP_PKEY_get_base_id(pkey) != EVP_PKEY_RSA)
                return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG), "X.509 certificate does not refer to RSA key.");
 
        bits = sym_EVP_PKEY_get_bits(pkey);
        log_debug("Bits in RSA key: %i", bits);
 
        /* We use RSA-OAEP for the cleartext, which has 2*hash_len + 2 bytes of overhead (e.g. 66 bytes
         * for SHA-256, 42 for SHA-1). Leave plenty of headroom by only generating a key half the size of
         * the RSA modulus. */
        suitable_key_size = bits / 8 / 2;
 
        if (suitable_key_size < 1)
                return log_debug_errno(SYNTHETIC_ERRNO(EIO), "Uh, RSA key size too short?");
 
        *ret_suitable_key_size = suitable_key_size;
        return 0;
}
 
/* Generate RSA public key from provided "n" and "e" values. Numbers "n" and "e" must be provided here
 * in big-endian format, e.g. wrap it with htobe32() for uint32_t. */
int rsa_pkey_from_n_e(const void *n, size_t n_size, const void *e, size_t e_size, EVP_PKEY **ret) {
        _cleanup_(EVP_PKEY_freep) EVP_PKEY *pkey = NULL;
        int r;
 
        assert(n);
        assert(n_size != 0);
        assert(e);
        assert(e_size != 0);
        assert(ret);
 
        r = dlopen_libcrypto(LOG_DEBUG);
        if (r < 0)
                return r;
 
        _cleanup_(EVP_PKEY_CTX_freep) EVP_PKEY_CTX *ctx = sym_EVP_PKEY_CTX_new_from_name(NULL, "RSA", NULL);
        if (!ctx)
                return log_openssl_errors(LOG_DEBUG, "Failed to create new EVP_PKEY_CTX");
 
        if (sym_EVP_PKEY_fromdata_init(ctx) <= 0)
                return log_openssl_errors(LOG_DEBUG, "Failed to initialize EVP_PKEY_CTX");
 
        _cleanup_(BN_freep) BIGNUM *bn_n = sym_BN_bin2bn(n, n_size, NULL);
        if (!bn_n)
                return log_openssl_errors(LOG_DEBUG, "Failed to create BIGNUM n");
 
        _cleanup_(BN_freep) BIGNUM *bn_e = sym_BN_bin2bn(e, e_size, NULL);
        if (!bn_e)
                return log_openssl_errors(LOG_DEBUG, "Failed to create BIGNUM e");
 
        _cleanup_(OSSL_PARAM_BLD_freep) OSSL_PARAM_BLD *bld = sym_OSSL_PARAM_BLD_new();
        if (!bld)
                return log_openssl_errors(LOG_DEBUG, "Failed to create new OSSL_PARAM_BLD");
 
        if (!sym_OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_N, bn_n))
                return log_openssl_errors(LOG_DEBUG, "Failed to push n to RSA params");
 
        if (!sym_OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_E, bn_e))
                return log_openssl_errors(LOG_DEBUG, "Failed to push e to RSA params");
 
        _cleanup_(OSSL_PARAM_freep) OSSL_PARAM *params = sym_OSSL_PARAM_BLD_to_param(bld);
        if (!params)
                return log_openssl_errors(LOG_DEBUG, "Failed to build RSA OSSL_PARAM");
 
        if (sym_EVP_PKEY_fromdata(ctx, &pkey, EVP_PKEY_PUBLIC_KEY, params) <= 0)
                return log_openssl_errors(LOG_DEBUG, "Failed to create RSA EVP_PKEY");
 
        *ret = TAKE_PTR(pkey);
        return 0;
}
 
/* Get the "n" and "e" values from the pkey. The values are returned in "bin" format, i.e. BN_bn2bin(). */
int rsa_pkey_to_n_e(
                const EVP_PKEY *pkey,
                void **ret_n,
                size_t *ret_n_size,
                void **ret_e,
                size_t *ret_e_size) {
 
        int r;
 
        assert(pkey);
        assert(ret_n);
        assert(ret_n_size);
        assert(ret_e);
        assert(ret_e_size);
 
        r = dlopen_libcrypto(LOG_DEBUG);
        if (r < 0)
                return r;
 
        _cleanup_(BN_freep) BIGNUM *bn_n = NULL;
        if (!sym_EVP_PKEY_get_bn_param(pkey, OSSL_PKEY_PARAM_RSA_N, &bn_n))
                return log_openssl_errors(LOG_DEBUG, "Failed to get RSA n");
 
        _cleanup_(BN_freep) BIGNUM *bn_e = NULL;
        if (!sym_EVP_PKEY_get_bn_param(pkey, OSSL_PKEY_PARAM_RSA_E, &bn_e))
                return log_openssl_errors(LOG_DEBUG, "Failed to get RSA e");
 
        size_t n_size = sym_BN_num_bytes(bn_n), e_size = sym_BN_num_bytes(bn_e);
        _cleanup_free_ void *n = malloc(n_size), *e = malloc(e_size);
        if (!n || !e)
                return log_oom_debug();
 
        assert_se(sym_BN_bn2bin(bn_n, n) == (int) n_size);
        assert_se(sym_BN_bn2bin(bn_e, e) == (int) e_size);
 
        *ret_n = TAKE_PTR(n);
        *ret_n_size = n_size;
        *ret_e = TAKE_PTR(e);
        *ret_e_size = e_size;
 
        return 0;
}
 
/* Generate ECC public key from provided curve ID and x/y points. */
int ecc_pkey_from_curve_x_y(
                int curve_id,
                const void *x,
                size_t x_size,
                const void *y,
                size_t y_size,
                EVP_PKEY **ret) {
 
        int r;
 
        assert(x);
        assert(y);
        assert(ret);
 
        r = dlopen_libcrypto(LOG_DEBUG);
        if (r < 0)
                return r;
 
        _cleanup_(EVP_PKEY_CTX_freep) EVP_PKEY_CTX *ctx = sym_EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL);
        if (!ctx)
                return log_openssl_errors(LOG_DEBUG, "Failed to create new EVP_PKEY_CTX");
 
        _cleanup_(BN_freep) BIGNUM *bn_x = sym_BN_bin2bn(x, x_size, NULL);
        if (!bn_x)
                return log_openssl_errors(LOG_DEBUG, "Failed to create BIGNUM x");
 
        _cleanup_(BN_freep) BIGNUM *bn_y = sym_BN_bin2bn(y, y_size, NULL);
        if (!bn_y)
                return log_openssl_errors(LOG_DEBUG, "Failed to create BIGNUM y");
 
        _cleanup_(EC_GROUP_freep) EC_GROUP *group = sym_EC_GROUP_new_by_curve_name(curve_id);
        if (!group)
                return log_openssl_errors(LOG_DEBUG, "ECC curve id %d not supported", curve_id);
 
        _cleanup_(EC_POINT_freep) EC_POINT *point = sym_EC_POINT_new(group);
        if (!point)
                return log_openssl_errors(LOG_DEBUG, "Failed to create new EC_POINT");
 
        if (!sym_EC_POINT_set_affine_coordinates(group, point, bn_x, bn_y, NULL))
                return log_openssl_errors(LOG_DEBUG, "Failed to set ECC coordinates");
 
        if (sym_EVP_PKEY_fromdata_init(ctx) <= 0)
                return log_openssl_errors(LOG_DEBUG, "Failed to initialize EVP_PKEY_CTX");
 
        _cleanup_(OSSL_PARAM_BLD_freep) OSSL_PARAM_BLD *bld = sym_OSSL_PARAM_BLD_new();
        if (!bld)
                return log_openssl_errors(LOG_DEBUG, "Failed to create new OSSL_PARAM_BLD");
 
        if (!sym_OSSL_PARAM_BLD_push_utf8_string(bld, OSSL_PKEY_PARAM_GROUP_NAME, (char*) sym_OSSL_EC_curve_nid2name(curve_id), 0))
                return log_openssl_errors(LOG_DEBUG, "Failed to add ECC OSSL_PKEY_PARAM_GROUP_NAME");
 
        _cleanup_(OPENSSL_freep) void *pbuf = NULL;
        size_t pbuf_len = 0;
        pbuf_len = sym_EC_POINT_point2buf(group, point, POINT_CONVERSION_UNCOMPRESSED, (unsigned char**) &pbuf, NULL);
        if (pbuf_len == 0)
                return log_openssl_errors(LOG_DEBUG, "Failed to convert ECC point to buffer");
 
        if (!sym_OSSL_PARAM_BLD_push_octet_string(bld, OSSL_PKEY_PARAM_PUB_KEY, pbuf, pbuf_len))
                return log_openssl_errors(LOG_DEBUG, "Failed to add ECC OSSL_PKEY_PARAM_PUB_KEY");
 
        _cleanup_(OSSL_PARAM_freep) OSSL_PARAM *params = sym_OSSL_PARAM_BLD_to_param(bld);
        if (!params)
                return log_openssl_errors(LOG_DEBUG, "Failed to build ECC OSSL_PARAM");
 
        _cleanup_(EVP_PKEY_freep) EVP_PKEY *pkey = NULL;
        if (sym_EVP_PKEY_fromdata(ctx, &pkey, EVP_PKEY_PUBLIC_KEY, params) <= 0)
                return log_openssl_errors(LOG_DEBUG, "Failed to create ECC EVP_PKEY");
 
        *ret = TAKE_PTR(pkey);
        return 0;
}
 
int ecc_pkey_to_curve_x_y(
                const EVP_PKEY *pkey,
                int *ret_curve_id,
                void **ret_x,
                size_t *ret_x_size,
                void **ret_y,
                size_t *ret_y_size) {
 
        _cleanup_(BN_freep) BIGNUM *bn_x = NULL, *bn_y = NULL;
        int curve_id, r;
 
        assert(pkey);
 
        r = dlopen_libcrypto(LOG_DEBUG);
        if (r < 0)
                return r;
 
        size_t name_size;
        if (!sym_EVP_PKEY_get_utf8_string_param(pkey, OSSL_PKEY_PARAM_GROUP_NAME, NULL, 0, &name_size))
                return log_openssl_errors(LOG_DEBUG, "Failed to get ECC group name size");
 
        _cleanup_free_ char *name = new(char, name_size + 1);
        if (!name)
                return log_oom_debug();
 
        if (!sym_EVP_PKEY_get_utf8_string_param(pkey, OSSL_PKEY_PARAM_GROUP_NAME, name, name_size + 1, NULL))
                return log_openssl_errors(LOG_DEBUG, "Failed to get ECC group name");
 
        curve_id = sym_OBJ_sn2nid(name);
        if (curve_id == NID_undef)
                return log_openssl_errors(LOG_DEBUG, "Failed to get ECC curve id");
 
        if (!sym_EVP_PKEY_get_bn_param(pkey, OSSL_PKEY_PARAM_EC_PUB_X, &bn_x))
                return log_openssl_errors(LOG_DEBUG, "Failed to get ECC point x");
 
        if (!sym_EVP_PKEY_get_bn_param(pkey, OSSL_PKEY_PARAM_EC_PUB_Y, &bn_y))
                return log_openssl_errors(LOG_DEBUG, "Failed to get ECC point y");
 
        /* The affine coordinates are elements of the curve's underlying field and must be
         * marshalled at the fixed field width. BN_bn2bin() writes the minimal big-endian
         * encoding, dropping any leading zero bytes, so a coordinate whose most significant byte
         * is zero (roughly 1 in 256 keys per coordinate) comes out one or more bytes short. A short
         * coordinate makes callers such as tpm2_tpm2b_public_from_openssl_pkey() build a
         * TPM2B_PUBLIC that TPM2_LoadExternal() rejects with TPM_RC_KEY. The object name hashes
         * the marshalled public area, so the name a TPM derives for the key also stops matching
         * the name systemd computes in software. Size the buffers to the field width and
         * zero-pad. */
        _cleanup_(EC_GROUP_freep) EC_GROUP *group = sym_EC_GROUP_new_by_curve_name(curve_id);
        if (!group)
                return log_openssl_errors(LOG_DEBUG, "ECC curve id %d not supported", curve_id);
 
        int bits = sym_EC_GROUP_get_degree(group);
        assert(bits > 0);
 
        size_t size = DIV_ROUND_UP(bits, 8);
        _cleanup_free_ void *x = malloc(size), *y = malloc(size);
        if (!x || !y)
                return log_oom_debug();
 
        if (sym_BN_bn2binpad(bn_x, x, size) < 0)
                return log_debug_errno(SYNTHETIC_ERRNO(EIO), "Failed to marshal ECC point x to %zu bytes.", size);
 
        if (sym_BN_bn2binpad(bn_y, y, size) < 0)
                return log_debug_errno(SYNTHETIC_ERRNO(EIO), "Failed to marshal ECC point y to %zu bytes.", size);
 
        if (ret_curve_id)
                *ret_curve_id = curve_id;
        if (ret_x)
                *ret_x = TAKE_PTR(x);
        if (ret_x_size)
                *ret_x_size = size;
        if (ret_y)
                *ret_y = TAKE_PTR(y);
        if (ret_y_size)
                *ret_y_size = size;
 
        return 0;
}
 
/* Generate a new ECC key for the specified ECC curve id. */
int ecc_pkey_new(int curve_id, EVP_PKEY **ret) {
        int r;
 
        assert(ret);
 
        r = dlopen_libcrypto(LOG_DEBUG);
        if (r < 0)
                return r;
 
        _cleanup_(EVP_PKEY_CTX_freep) EVP_PKEY_CTX *ctx = sym_EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL);
        if (!ctx)
                return log_openssl_errors(LOG_DEBUG, "Failed to create new EVP_PKEY_CTX");
 
        if (sym_EVP_PKEY_keygen_init(ctx) <= 0)
                return log_openssl_errors(LOG_DEBUG, "Failed to initialize EVP_PKEY_CTX");
 
        if (sym_EVP_PKEY_CTX_set_ec_paramgen_curve_nid(ctx, curve_id) <= 0)
                return log_openssl_errors(LOG_DEBUG, "Failed to set ECC curve %d", curve_id);
 
        _cleanup_(EVP_PKEY_freep) EVP_PKEY *pkey = NULL;
        if (sym_EVP_PKEY_keygen(ctx, &pkey) <= 0)
                return log_openssl_errors(LOG_DEBUG, "Failed to generate ECC key");
 
        *ret = TAKE_PTR(pkey);
 
        return 0;
}
 
/* Perform ECDH to derive an ECC shared secret between the provided private key and public peer key. For two
 * keys, this will result in the same shared secret in either direction; ECDH using Alice's private key and
 * Bob's public (peer) key will result in the same shared secret as ECDH using Bob's private key and Alice's
 * public (peer) key. On success, this returns 0 and provides the shared secret; otherwise this returns an
 * error. */
int ecc_ecdh(const EVP_PKEY *private_pkey,
             const EVP_PKEY *peer_pkey,
             void **ret_shared_secret,
             size_t *ret_shared_secret_size) {
 
        int r;
 
        assert(private_pkey);
        assert(peer_pkey);
        assert(ret_shared_secret);
        assert(ret_shared_secret_size);
 
        r = dlopen_libcrypto(LOG_DEBUG);
        if (r < 0)
                return r;
 
        _cleanup_(EVP_PKEY_CTX_freep) EVP_PKEY_CTX *ctx = sym_EVP_PKEY_CTX_new((EVP_PKEY*) private_pkey, NULL);
        if (!ctx)
                return log_openssl_errors(LOG_DEBUG, "Failed to create new EVP_PKEY_CTX");
 
        if (sym_EVP_PKEY_derive_init(ctx) <= 0)
                return log_openssl_errors(LOG_DEBUG, "Failed to initialize EVP_PKEY_CTX");
 
        if (sym_EVP_PKEY_derive_set_peer(ctx, (EVP_PKEY*) peer_pkey) <= 0)
                return log_openssl_errors(LOG_DEBUG, "Failed to set ECC derive peer");
 
        size_t shared_secret_size;
        if (sym_EVP_PKEY_derive(ctx, NULL, &shared_secret_size) <= 0)
                return log_openssl_errors(LOG_DEBUG, "Failed to get ECC shared secret size");
 
        _cleanup_(erase_and_freep) void *shared_secret = malloc(shared_secret_size);
        if (!shared_secret)
                return log_oom_debug();
 
        if (sym_EVP_PKEY_derive(ctx, (unsigned char*) shared_secret, &shared_secret_size) <= 0)
                return log_openssl_errors(LOG_DEBUG, "Failed to derive ECC shared secret");
 
        *ret_shared_secret = TAKE_PTR(shared_secret);
        *ret_shared_secret_size = shared_secret_size;
 
        return 0;
}
 
int pubkey_fingerprint(EVP_PKEY *pk, const EVP_MD *md, void **ret, size_t *ret_size) {
        _cleanup_(EVP_MD_CTX_freep) EVP_MD_CTX* m = NULL;
        _cleanup_free_ void *h = NULL;
        int lsz, msz;
        unsigned umsz;
        int r;
 
        /* Calculates a message digest of the DER encoded public key */
 
        assert(pk);
        assert(md);
        assert(ret);
        assert(ret_size);
 
        r = dlopen_libcrypto(LOG_DEBUG);
        if (r < 0)
                return r;
 
        _cleanup_(OPENSSL_freep) void *d = NULL;
        lsz = sym_i2d_PublicKey(pk, (unsigned char**) &d);
        if (lsz < 0)
                return log_openssl_errors(LOG_DEBUG, "Unable to convert public key to DER format");
 
        m = sym_EVP_MD_CTX_new();
        if (!m)
                return log_openssl_errors(LOG_DEBUG, "Failed to create new EVP_MD_CTX");
 
        if (sym_EVP_DigestInit_ex(m, md, NULL) != 1)
                return log_openssl_errors(LOG_DEBUG, "Failed to initialize %s context", sym_EVP_MD_get0_name(md));
 
        if (sym_EVP_DigestUpdate(m, d, lsz) != 1)
                return log_openssl_errors(LOG_DEBUG, "Failed to run %s context", sym_EVP_MD_get0_name(md));
 
        msz = sym_EVP_MD_get_size(md);
        assert(msz > 0);
 
        h = malloc(msz);
        if (!h)
                return log_oom_debug();
 
        umsz = msz;
        if (sym_EVP_DigestFinal_ex(m, h, &umsz) != 1)
                return log_openssl_errors(LOG_DEBUG, "Failed to finalize hash context");
 
        assert(umsz == (unsigned) msz);
 
        *ret = TAKE_PTR(h);
        *ret_size = msz;
 
        return 0;
}
 
int digest_and_sign(
                const EVP_MD *md,
                EVP_PKEY *privkey,
                const void *data, size_t size,
                void **ret, size_t *ret_size) {
 
        int r;
 
        assert(privkey);
        assert(ret);
        assert(ret_size);
 
        r = dlopen_libcrypto(LOG_DEBUG);
        if (r < 0)
                return r;
 
        if (size == 0)
                data = ""; /* make sure to pass a valid pointer to OpenSSL */
        else {
                assert(data);
 
                if (size == SIZE_MAX) /* If SIZE_MAX input is a string whose size we determine automatically */
                        size = strlen(data);
        }
 
        _cleanup_(EVP_MD_CTX_freep) EVP_MD_CTX* mdctx = sym_EVP_MD_CTX_new();
        if (!mdctx)
                return log_openssl_errors(LOG_DEBUG, "Failed to create new EVP_MD_CTX");
 
        /* Note that a NULL 'md' (message digest algorithm) means to sign the provided data directly, without
         * hashing it first, as long as a suitable signing algorithm is used that supports this, such as
         * Ed25519 (PureEdDSA). For such algorithms callers may pass an already calculated digest as input. */
        if (sym_EVP_DigestSignInit(mdctx, NULL, md, NULL, privkey) != 1) {
                /* Distro security policies often disable support for SHA-1. Let's return a recognizable
                 * error for that case. */
                bool invalid_digest = ERR_GET_REASON(sym_ERR_peek_last_error()) == EVP_R_INVALID_DIGEST;
                r = log_openssl_errors(LOG_DEBUG, "Failed to initialize signature context");
                return invalid_digest ? -EADDRNOTAVAIL : r;
        }
 
        /* Determine signature size */
        size_t ss;
        if (sym_EVP_DigestSign(mdctx, NULL, &ss, data, size) != 1)
                return log_openssl_errors(LOG_DEBUG, "Failed to determine size of signature");
 
        _cleanup_free_ void *sig = malloc(ss);
        if (!sig)
                return log_oom_debug();
 
        if (sym_EVP_DigestSign(mdctx, sig, &ss, data, size) != 1)
                return log_openssl_errors(LOG_DEBUG, "Failed to sign data");
 
        *ret = TAKE_PTR(sig);
        *ret_size = ss;
        return 0;
}
 
int pkcs7_new(X509 *certificate, EVP_PKEY *private_key, const char *hash_algorithm, PKCS7 **ret_p7, PKCS7_SIGNER_INFO **ret_si) {
        int r;
 
        assert(certificate);
        assert(ret_p7);
 
        /* This function sets up a new PKCS7 signing context. If a private key is provided, the context is
         * set up for "in-band" signing with PKCS7_dataFinal(). If a private key is not provided, the context
         * is set up for "out-of-band" signing, meaning the signature has to be provided by the user and
         * copied into the signer info's "enc_digest" field. If the signing hash algorithm is not provided,
         * SHA-256 is used. */
 
        r = dlopen_libcrypto(LOG_DEBUG);
        if (r < 0)
                return r;
 
        _cleanup_(PKCS7_freep) PKCS7 *p7 = sym_PKCS7_new();
        if (!p7)
                return log_oom();
 
        if (sym_PKCS7_set_type(p7, NID_pkcs7_signed) == 0)
                return log_openssl_errors(LOG_DEBUG, "Failed to set PKCS7 type");
 
        if (sym_PKCS7_content_new(p7, NID_pkcs7_data) == 0)
                return log_openssl_errors(LOG_DEBUG, "Failed to set PKCS7 content");
 
        if (sym_PKCS7_add_certificate(p7, certificate) == 0)
                return log_openssl_errors(LOG_DEBUG, "Failed to set PKCS7 certificate");
 
        int x509_pknid = 0;
        if (sym_X509_get_signature_info(certificate, NULL, &x509_pknid, NULL, NULL) == 0)