HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/shared/crypto-util.c
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)