Debian Codegraph @

src/shared/crypto-util.c

raw
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3 #include "sd-dlopen.h"
4
5 #include "alloc-util.h"
6 #include "ask-password-api.h"
7 #include "crypto-util.h"
8 #include "dlfcn-util.h"
9 #include "fd-util.h"
10 #include "fileio.h"
11 #include "hexdecoct.h"
12 #include "log.h"
13 #include "memory-util.h"
14 #include "memstream-util.h"
15 #include "random-util.h"
16 #include "string-util.h"
17 #include "strv.h"
18
19 #if HAVE_OPENSSL
20 # include <openssl/core_names.h>
21 # include <openssl/kdf.h>
22 # include <openssl/provider.h>
23 # include <openssl/store.h>
24
25 # if !defined(OPENSSL_NO_ENGINE) && !defined(OPENSSL_NO_DEPRECATED_3_0)
26 # include <openssl/engine.h>
27 # endif
28
29 # ifndef OPENSSL_NO_UI_CONSOLE
30 # include <openssl/ui.h>
31 # endif
32
33 struct OpenSSLAskPasswordUI {
34 AskPasswordRequest request;
35 #ifndef OPENSSL_NO_UI_CONSOLE
36 UI_METHOD *method;
37 #endif
38 };
39
40 static DLSYM_PROTOTYPE(ASN1_INTEGER_dup) = NULL;
41 static DLSYM_PROTOTYPE(ASN1_INTEGER_free) = NULL;
42 static DLSYM_PROTOTYPE(ASN1_INTEGER_set) = NULL;
43 DLSYM_PROTOTYPE(ASN1_ANY_it) = NULL;
44 DLSYM_PROTOTYPE(ASN1_BIT_STRING_it) = NULL;
45 DLSYM_PROTOTYPE(ASN1_BMPSTRING_it) = NULL;
46 DLSYM_PROTOTYPE(ASN1_BMPSTRING_new) = NULL;
47 DLSYM_PROTOTYPE(ASN1_IA5STRING_it) = NULL;
48 DLSYM_PROTOTYPE(ASN1_OBJECT_it) = NULL;
49 DLSYM_PROTOTYPE(ASN1_OCTET_STRING_free) = NULL;
50 DLSYM_PROTOTYPE(ASN1_OCTET_STRING_it) = NULL;
51 DLSYM_PROTOTYPE(ASN1_OCTET_STRING_set) = NULL;
52 DLSYM_PROTOTYPE(ASN1_STRING_get0_data) = NULL;
53 DLSYM_PROTOTYPE(ASN1_STRING_length) = NULL;
54 DLSYM_PROTOTYPE(ASN1_STRING_new) = NULL;
55 DLSYM_PROTOTYPE(ASN1_STRING_set) = NULL;
56 DLSYM_PROTOTYPE(ASN1_STRING_set0) = NULL;
57 DLSYM_PROTOTYPE(ASN1_TIME_free) = NULL;
58 DLSYM_PROTOTYPE(ASN1_TIME_set) = NULL;
59 DLSYM_PROTOTYPE(ASN1_TYPE_new) = NULL;
60 DLSYM_PROTOTYPE(ASN1_get_object) = NULL;
61 DLSYM_PROTOTYPE(ASN1_item_d2i) = NULL;
62 DLSYM_PROTOTYPE(ASN1_item_free) = NULL;
63 DLSYM_PROTOTYPE(ASN1_item_i2d) = NULL;
64 DLSYM_PROTOTYPE(ASN1_item_new) = NULL;
65 DLSYM_PROTOTYPE(BIO_ctrl) = NULL;
66 DLSYM_PROTOTYPE(BIO_find_type) = NULL;
67 DLSYM_PROTOTYPE(BIO_free) = NULL;
68 DLSYM_PROTOTYPE(BIO_free_all) = NULL;
69 DLSYM_PROTOTYPE(BIO_new) = NULL;
70 DLSYM_PROTOTYPE(BIO_new_mem_buf) = NULL;
71 DLSYM_PROTOTYPE(BIO_new_socket) = NULL;
72 DLSYM_PROTOTYPE(BIO_s_mem) = NULL;
73 DLSYM_PROTOTYPE(BIO_write) = NULL;
74 DLSYM_PROTOTYPE(BN_CTX_free) = NULL;
75 DLSYM_PROTOTYPE(BN_CTX_new) = NULL;
76 DLSYM_PROTOTYPE(BN_bin2bn) = NULL;
77 static DLSYM_PROTOTYPE(BN_bn2bin) = NULL;
78 DLSYM_PROTOTYPE(BN_bn2nativepad) = NULL;
79 DLSYM_PROTOTYPE(BN_free) = NULL;
80 DLSYM_PROTOTYPE(BN_new) = NULL;
81 DLSYM_PROTOTYPE(BN_num_bits) = NULL;
82 DLSYM_PROTOTYPE(CRYPTO_free) = NULL;
83 DLSYM_PROTOTYPE(ECDSA_SIG_free) = NULL;
84 DLSYM_PROTOTYPE(EC_GROUP_free) = NULL;
85 DLSYM_PROTOTYPE(EC_GROUP_get0_generator) = NULL;
86 DLSYM_PROTOTYPE(EC_GROUP_get0_order) = NULL;
87 DLSYM_PROTOTYPE(EC_GROUP_get_curve) = NULL;
88 DLSYM_PROTOTYPE(EC_GROUP_get_curve_name) = NULL;
89 DLSYM_PROTOTYPE(EC_GROUP_get_field_type) = NULL;
90 DLSYM_PROTOTYPE(EC_GROUP_new_by_curve_name) = NULL;
91 DLSYM_PROTOTYPE(EC_POINT_free) = NULL;
92 DLSYM_PROTOTYPE(EC_POINT_new) = NULL;
93 DLSYM_PROTOTYPE(EC_POINT_oct2point) = NULL;
94 static DLSYM_PROTOTYPE(EC_POINT_point2buf) = NULL;
95 DLSYM_PROTOTYPE(EC_POINT_point2oct) = NULL;
96 static DLSYM_PROTOTYPE(EC_POINT_set_affine_coordinates) = NULL;
97 DLSYM_PROTOTYPE(ERR_clear_error) = NULL;
98 DLSYM_PROTOTYPE(ERR_error_string) = NULL;
99 DLSYM_PROTOTYPE(ERR_error_string_n) = NULL;
100 DLSYM_PROTOTYPE(ERR_get_error) = NULL;
101 static DLSYM_PROTOTYPE(ERR_peek_last_error) = NULL;
102 DLSYM_PROTOTYPE(EVP_CIPHER_CTX_ctrl) = NULL;
103 DLSYM_PROTOTYPE(EVP_CIPHER_CTX_free) = NULL;
104 static DLSYM_PROTOTYPE(EVP_CIPHER_CTX_get_block_size) = NULL;
105 DLSYM_PROTOTYPE(EVP_CIPHER_CTX_new) = NULL;
106 static DLSYM_PROTOTYPE(EVP_CIPHER_fetch) = NULL;
107 DLSYM_PROTOTYPE(EVP_CIPHER_free) = NULL;
108 DLSYM_PROTOTYPE(EVP_CIPHER_get_block_size) = NULL;
109 DLSYM_PROTOTYPE(EVP_CIPHER_get_iv_length) = NULL;
110 DLSYM_PROTOTYPE(EVP_CIPHER_get_key_length) = NULL;
111 DLSYM_PROTOTYPE(EVP_DecryptFinal_ex) = NULL;
112 DLSYM_PROTOTYPE(EVP_DecryptInit_ex) = NULL;
113 DLSYM_PROTOTYPE(EVP_DecryptUpdate) = NULL;
114 DLSYM_PROTOTYPE(EVP_Digest) = NULL;
115 DLSYM_PROTOTYPE(EVP_DigestFinal_ex) = NULL;
116 DLSYM_PROTOTYPE(EVP_DigestInit_ex) = NULL;
117 static DLSYM_PROTOTYPE(EVP_DigestSign) = NULL;
118 static DLSYM_PROTOTYPE(EVP_DigestSignInit) = NULL;
119 DLSYM_PROTOTYPE(EVP_DigestUpdate) = NULL;
120 DLSYM_PROTOTYPE(EVP_DigestVerify) = NULL;
121 DLSYM_PROTOTYPE(EVP_DigestVerifyInit) = NULL;
122 DLSYM_PROTOTYPE(EVP_EncryptFinal_ex) = NULL;
123 static DLSYM_PROTOTYPE(EVP_EncryptInit) = NULL;
124 DLSYM_PROTOTYPE(EVP_EncryptInit_ex) = NULL;
125 DLSYM_PROTOTYPE(EVP_EncryptUpdate) = NULL;
126 static DLSYM_PROTOTYPE(EVP_KDF_CTX_free) = NULL;
127 static DLSYM_PROTOTYPE(EVP_KDF_CTX_new) = NULL;
128 static DLSYM_PROTOTYPE(EVP_KDF_derive) = NULL;
129 static DLSYM_PROTOTYPE(EVP_KDF_fetch) = NULL;
130 static DLSYM_PROTOTYPE(EVP_KDF_free) = NULL;
131 DLSYM_PROTOTYPE(EVP_MAC_CTX_free) = NULL;
132 static DLSYM_PROTOTYPE(EVP_MAC_CTX_get_mac_size) = NULL;
133 static DLSYM_PROTOTYPE(EVP_MAC_CTX_new) = NULL;
134 static DLSYM_PROTOTYPE(EVP_MAC_fetch) = NULL;
135 static DLSYM_PROTOTYPE(EVP_MAC_final) = NULL;
136 DLSYM_PROTOTYPE(EVP_MAC_free) = NULL;
137 static DLSYM_PROTOTYPE(EVP_MAC_init) = NULL;
138 static DLSYM_PROTOTYPE(EVP_MAC_update) = NULL;
139 DLSYM_PROTOTYPE(EVP_MD_CTX_free) = NULL;
140 DLSYM_PROTOTYPE(EVP_MD_CTX_get0_md) = NULL;
141 DLSYM_PROTOTYPE(EVP_MD_CTX_new) = NULL;
142 DLSYM_PROTOTYPE(EVP_MD_CTX_set_pkey_ctx) = NULL;
143 static DLSYM_PROTOTYPE(EVP_MD_fetch) = NULL;
144 DLSYM_PROTOTYPE(EVP_MD_free) = NULL;
145 DLSYM_PROTOTYPE(EVP_MD_get0_name) = NULL;
146 DLSYM_PROTOTYPE(EVP_MD_get_size) = NULL;
147 static DLSYM_PROTOTYPE(EVP_MD_get_type) = NULL;
148 DLSYM_PROTOTYPE(EVP_PKEY_CTX_free) = NULL;
149 DLSYM_PROTOTYPE(EVP_PKEY_CTX_new) = NULL;
150 DLSYM_PROTOTYPE(EVP_PKEY_CTX_new_from_name) = NULL;
151 DLSYM_PROTOTYPE(EVP_PKEY_CTX_new_id) = NULL;
152 static DLSYM_PROTOTYPE(EVP_PKEY_CTX_set0_rsa_oaep_label) = NULL;
153 static DLSYM_PROTOTYPE(EVP_PKEY_CTX_set_ec_paramgen_curve_nid) = NULL;
154 static DLSYM_PROTOTYPE(EVP_PKEY_CTX_set_rsa_oaep_md) = NULL;
155 DLSYM_PROTOTYPE(EVP_PKEY_CTX_set_rsa_padding) = NULL;
156 DLSYM_PROTOTYPE(EVP_PKEY_CTX_set_signature_md) = NULL;
157 static DLSYM_PROTOTYPE(EVP_PKEY_derive) = NULL;
158 static DLSYM_PROTOTYPE(EVP_PKEY_derive_init) = NULL;
159 static DLSYM_PROTOTYPE(EVP_PKEY_derive_set_peer) = NULL;
160 static DLSYM_PROTOTYPE(EVP_PKEY_encrypt) = NULL;
161 static DLSYM_PROTOTYPE(EVP_PKEY_encrypt_init) = NULL;
162 DLSYM_PROTOTYPE(EVP_PKEY_eq) = NULL;
163 DLSYM_PROTOTYPE(EVP_PKEY_free) = NULL;
164 DLSYM_PROTOTYPE(EVP_PKEY_fromdata) = NULL;
165 DLSYM_PROTOTYPE(EVP_PKEY_fromdata_init) = NULL;
166 static DLSYM_PROTOTYPE(EVP_PKEY_get1_encoded_public_key) = NULL;
167 DLSYM_PROTOTYPE(EVP_PKEY_get_base_id) = NULL;
168 static DLSYM_PROTOTYPE(EVP_PKEY_get_bits) = NULL;
169 static DLSYM_PROTOTYPE(EVP_PKEY_get_bn_param) = NULL;
170 static DLSYM_PROTOTYPE(EVP_PKEY_get_group_name) = NULL;
171 DLSYM_PROTOTYPE(EVP_PKEY_get_id) = NULL;
172 static DLSYM_PROTOTYPE(EVP_PKEY_get_utf8_string_param) = NULL;
173 DLSYM_PROTOTYPE(EVP_PKEY_keygen) = NULL;
174 DLSYM_PROTOTYPE(EVP_PKEY_keygen_init) = NULL;
175 DLSYM_PROTOTYPE(EVP_PKEY_new) = NULL;
176 DLSYM_PROTOTYPE(EVP_PKEY_new_raw_public_key) = NULL;
177 DLSYM_PROTOTYPE(EVP_PKEY_verify) = NULL;
178 DLSYM_PROTOTYPE(EVP_PKEY_verify_init) = NULL;
179 DLSYM_PROTOTYPE(EVP_aes_256_ctr) = NULL;
180 DLSYM_PROTOTYPE(EVP_aes_256_gcm) = NULL;
181 DLSYM_PROTOTYPE(EVP_get_cipherbyname) = NULL;
182 DLSYM_PROTOTYPE(EVP_get_digestbyname) = NULL;
183 DLSYM_PROTOTYPE(EVP_sha1) = NULL;
184 DLSYM_PROTOTYPE(EVP_sha256) = NULL;
185 DLSYM_PROTOTYPE(EVP_sha384) = NULL;
186 DLSYM_PROTOTYPE(EVP_sha512) = NULL;
187 DLSYM_PROTOTYPE(HMAC) = NULL;
188 DLSYM_PROTOTYPE(SHA1) = NULL;
189 DLSYM_PROTOTYPE(SHA512) = NULL;
190 DLSYM_PROTOTYPE(OBJ_nid2obj) = NULL;
191 DLSYM_PROTOTYPE(OBJ_nid2sn) = NULL;
192 DLSYM_PROTOTYPE(OBJ_sn2nid) = NULL;
193 DLSYM_PROTOTYPE(OBJ_txt2obj) = NULL;
194 DLSYM_PROTOTYPE(OPENSSL_sk_new_null) = NULL;
195 DLSYM_PROTOTYPE(OPENSSL_sk_num) = NULL;
196 DLSYM_PROTOTYPE(OPENSSL_sk_pop_free) = NULL;
197 DLSYM_PROTOTYPE(OPENSSL_sk_push) = NULL;
198 DLSYM_PROTOTYPE(OPENSSL_sk_value) = NULL;
199 DLSYM_PROTOTYPE(OSSL_EC_curve_nid2name) = NULL;
200 static DLSYM_PROTOTYPE(OSSL_PARAM_BLD_new) = NULL;
201 static DLSYM_PROTOTYPE(OSSL_PARAM_BLD_free) = NULL;
202 static DLSYM_PROTOTYPE(OSSL_PARAM_BLD_push_octet_string) = NULL;
203 static DLSYM_PROTOTYPE(OSSL_PARAM_BLD_push_utf8_string) = NULL;
204 static DLSYM_PROTOTYPE(OSSL_PARAM_BLD_to_param) = NULL;
205 DLSYM_PROTOTYPE(OSSL_PARAM_construct_BN) = NULL;
206 DLSYM_PROTOTYPE(OSSL_PARAM_construct_end) = NULL;
207 DLSYM_PROTOTYPE(OSSL_PARAM_construct_octet_string) = NULL;
208 DLSYM_PROTOTYPE(OSSL_PARAM_construct_utf8_string) = NULL;
209 DLSYM_PROTOTYPE(OSSL_PARAM_free) = NULL;
210 static DLSYM_PROTOTYPE(OSSL_PROVIDER_try_load) = NULL;
211 static DLSYM_PROTOTYPE(OSSL_STORE_INFO_free) = NULL;
212 static DLSYM_PROTOTYPE(OSSL_STORE_INFO_get1_CERT) = NULL;
213 static DLSYM_PROTOTYPE(OSSL_STORE_INFO_get1_PKEY) = NULL;
214 static DLSYM_PROTOTYPE(OSSL_STORE_close) = NULL;
215 static DLSYM_PROTOTYPE(OSSL_STORE_expect) = NULL;
216 static DLSYM_PROTOTYPE(OSSL_STORE_load) = NULL;
217 static DLSYM_PROTOTYPE(OSSL_STORE_open) = NULL;
218 DLSYM_PROTOTYPE(PEM_read_PUBKEY) = NULL;
219 DLSYM_PROTOTYPE(PEM_read_PrivateKey) = NULL;
220 DLSYM_PROTOTYPE(PEM_read_X509) = NULL;
221 static DLSYM_PROTOTYPE(PEM_read_bio_PrivateKey) = NULL;
222 static DLSYM_PROTOTYPE(PEM_read_bio_X509) = NULL;
223 DLSYM_PROTOTYPE(PKCS5_PBKDF2_HMAC) = NULL;
224 DLSYM_PROTOTYPE(PEM_write_PUBKEY) = NULL;
225 DLSYM_PROTOTYPE(PEM_write_PrivateKey) = NULL;
226 DLSYM_PROTOTYPE(PEM_write_X509) = NULL;
227 DLSYM_PROTOTYPE(PKCS7_SIGNER_INFO_free) = NULL;
228 DLSYM_PROTOTYPE(PKCS7_ATTR_SIGN_it) = NULL;
229 static DLSYM_PROTOTYPE(PKCS7_SIGNER_INFO_new) = NULL;
230 static DLSYM_PROTOTYPE(PKCS7_SIGNER_INFO_set) = NULL;
231 DLSYM_PROTOTYPE(PKCS7_add0_attrib_signing_time) = NULL;
232 DLSYM_PROTOTYPE(PKCS7_add1_attrib_digest) = NULL;
233 DLSYM_PROTOTYPE(PKCS7_add_attrib_content_type) = NULL;
234 DLSYM_PROTOTYPE(PKCS7_add_attrib_smimecap) = NULL;
235 static DLSYM_PROTOTYPE(PKCS7_add_certificate) = NULL;
236 DLSYM_PROTOTYPE(PKCS7_add_signed_attribute) = NULL;
237 static DLSYM_PROTOTYPE(PKCS7_add_signer) = NULL;
238 DLSYM_PROTOTYPE(PKCS7_content_new) = NULL;
239 DLSYM_PROTOTYPE(PKCS7_ctrl) = NULL;
240 DLSYM_PROTOTYPE(PKCS7_dataFinal) = NULL;
241 DLSYM_PROTOTYPE(PKCS7_dataInit) = NULL;
242 DLSYM_PROTOTYPE(PKCS7_free) = NULL;
243 DLSYM_PROTOTYPE(PKCS7_get_signer_info) = NULL;
244 DLSYM_PROTOTYPE(PKCS7_new) = NULL;
245 DLSYM_PROTOTYPE(PKCS7_set_content) = NULL;
246 static DLSYM_PROTOTYPE(PKCS7_set_type) = NULL;
247 DLSYM_PROTOTYPE(PKCS7_sign) = NULL;
248 DLSYM_PROTOTYPE(PKCS7_verify) = NULL;
249 static DLSYM_PROTOTYPE(X509_ALGOR_set0) = NULL;
250 DLSYM_PROTOTYPE(X509_NAME_free) = NULL;
251 DLSYM_PROTOTYPE(X509_ALGOR_free) = NULL;
252 DLSYM_PROTOTYPE(X509_ATTRIBUTE_free) = NULL;
253 DLSYM_PROTOTYPE(X509_NAME_oneline) = NULL;
254 static DLSYM_PROTOTYPE(X509_NAME_set) = NULL;
255 DLSYM_PROTOTYPE(X509_VERIFY_PARAM_set1_host) = NULL;
256 DLSYM_PROTOTYPE(X509_VERIFY_PARAM_set1_ip) = NULL;
257 DLSYM_PROTOTYPE(X509_VERIFY_PARAM_set_hostflags) = NULL;
258 DLSYM_PROTOTYPE(X509_free) = NULL;
259 DLSYM_PROTOTYPE(X509_gmtime_adj) = NULL;
260 static DLSYM_PROTOTYPE(X509_get0_serialNumber) = NULL;
261 static DLSYM_PROTOTYPE(X509_get_issuer_name) = NULL;
262 DLSYM_PROTOTYPE(X509_get_pubkey) = NULL;
263 static DLSYM_PROTOTYPE(X509_get_signature_info) = NULL;
264 DLSYM_PROTOTYPE(X509_get_subject_name) = NULL;
265 DLSYM_PROTOTYPE(d2i_ASN1_OCTET_STRING) = NULL;
266 DLSYM_PROTOTYPE(d2i_ECPKParameters) = NULL;
267 DLSYM_PROTOTYPE(d2i_PKCS7) = NULL;
268 DLSYM_PROTOTYPE(d2i_PUBKEY) = NULL;
269 DLSYM_PROTOTYPE(d2i_X509) = NULL;
270 DLSYM_PROTOTYPE(i2d_ASN1_INTEGER) = NULL;
271 DLSYM_PROTOTYPE(i2d_PKCS7) = NULL;
272 DLSYM_PROTOTYPE(i2d_PKCS7_fp) = NULL;
273 DLSYM_PROTOTYPE(i2d_PUBKEY) = NULL;
274 static DLSYM_PROTOTYPE(i2d_PUBKEY_fp) = NULL;
275 static DLSYM_PROTOTYPE(i2d_PublicKey) = NULL;
276 DLSYM_PROTOTYPE(i2d_X509) = NULL;
277 DLSYM_PROTOTYPE(i2d_X509_NAME) = NULL;
278
279 DEFINE_TRIVIAL_CLEANUP_FUNC_FULL_RENAME(OSSL_PARAM_BLD*, sym_OSSL_PARAM_BLD_free, OSSL_PARAM_BLD_freep, NULL);
280 DEFINE_TRIVIAL_CLEANUP_FUNC_FULL_RENAME(OSSL_STORE_CTX*, sym_OSSL_STORE_close, OSSL_STORE_closep, NULL);
281 DEFINE_TRIVIAL_CLEANUP_FUNC_FULL_RENAME(OSSL_STORE_INFO*, sym_OSSL_STORE_INFO_free, OSSL_STORE_INFO_freep, NULL);
282 DEFINE_TRIVIAL_CLEANUP_FUNC_FULL_RENAME(EVP_KDF*, sym_EVP_KDF_free, EVP_KDF_freep, NULL);
283 DEFINE_TRIVIAL_CLEANUP_FUNC_FULL_RENAME(EVP_KDF_CTX*, sym_EVP_KDF_CTX_free, EVP_KDF_CTX_freep, NULL);
284
285 #if !defined(OPENSSL_NO_ENGINE) && !defined(OPENSSL_NO_DEPRECATED_3_0)
286 DISABLE_WARNING_DEPRECATED_DECLARATIONS;
287 static DLSYM_PROTOTYPE(ENGINE_by_id) = NULL;
288 static DLSYM_PROTOTYPE(ENGINE_free) = NULL;
289 static DLSYM_PROTOTYPE(ENGINE_init) = NULL;
290 static DLSYM_PROTOTYPE(ENGINE_load_private_key) = NULL;
291 REENABLE_WARNING;
292
293 DEFINE_TRIVIAL_CLEANUP_FUNC_FULL_RENAME(ENGINE*, sym_ENGINE_free, ENGINE_freep, NULL);
294 #endif
295
296 #if !defined(OPENSSL_NO_DEPRECATED_3_0)
297 DISABLE_WARNING_DEPRECATED_DECLARATIONS;
298 DLSYM_PROTOTYPE(ECDSA_SIG_new) = NULL;
299 DLSYM_PROTOTYPE(ECDSA_SIG_set0) = NULL;
300 DLSYM_PROTOTYPE(ECDSA_do_verify) = NULL;
301 DLSYM_PROTOTYPE(EC_KEY_check_key) = NULL;
302 DLSYM_PROTOTYPE(EC_KEY_free) = NULL;
303 DLSYM_PROTOTYPE(EC_KEY_new) = NULL;
304 DLSYM_PROTOTYPE(EC_KEY_set_group) = NULL;
305 DLSYM_PROTOTYPE(EC_KEY_set_public_key) = NULL;
306 DLSYM_PROTOTYPE(EVP_PKEY_assign) = NULL;
307 DLSYM_PROTOTYPE(RSA_free) = NULL;
308 DLSYM_PROTOTYPE(RSA_new) = NULL;
309 DLSYM_PROTOTYPE(RSA_set0_key) = NULL;
310 DLSYM_PROTOTYPE(RSA_size) = NULL;
311 DLSYM_PROTOTYPE(RSAPublicKey_dup) = NULL;
312 REENABLE_WARNING;
313 #endif
314
315 #ifndef OPENSSL_NO_UI_CONSOLE
316 static DLSYM_PROTOTYPE(UI_OpenSSL) = NULL;
317 static DLSYM_PROTOTYPE(UI_create_method) = NULL;
318 static DLSYM_PROTOTYPE(UI_destroy_method) = NULL;
319 static DLSYM_PROTOTYPE(UI_get0_output_string) = NULL;
320 static DLSYM_PROTOTYPE(UI_get_default_method) = NULL;
321 static DLSYM_PROTOTYPE(UI_get_method) = NULL;
322 static DLSYM_PROTOTYPE(UI_get_string_type) = NULL;
323 static DLSYM_PROTOTYPE(UI_method_get_ex_data) = NULL;
324 static DLSYM_PROTOTYPE(UI_method_get_reader) = NULL;
325 static DLSYM_PROTOTYPE(UI_method_set_ex_data) = NULL;
326 static DLSYM_PROTOTYPE(UI_method_set_reader) = NULL;
327 static DLSYM_PROTOTYPE(UI_set_default_method) = NULL;
328 static DLSYM_PROTOTYPE(UI_set_result) = NULL;
329
330 DEFINE_TRIVIAL_CLEANUP_FUNC_FULL_RENAME(UI_METHOD*, sym_UI_destroy_method, UI_destroy_methodp, NULL);
331 #endif
332
333 #endif
334
335 int dlopen_libcrypto(int log_level) {
336 #if HAVE_OPENSSL
337 static void *libcrypto_dl = NULL;
338
339 LIBCRYPTO_NOTE(SD_ELF_NOTE_DLOPEN_PRIORITY_SUGGESTED);
340
341 return dlopen_many_sym_or_warn(
342 &libcrypto_dl,
343 "libcrypto.so.3",
344 log_level,
345 DLSYM_ARG(ASN1_ANY_it),
346 DLSYM_ARG(ASN1_BIT_STRING_it),
347 DLSYM_ARG(ASN1_BMPSTRING_it),
348 DLSYM_ARG(ASN1_BMPSTRING_new),
349 DLSYM_ARG(ASN1_get_object),
350 DLSYM_ARG(ASN1_IA5STRING_it),
351 DLSYM_ARG(ASN1_INTEGER_dup),
352 DLSYM_ARG(ASN1_INTEGER_free),
353 DLSYM_ARG(ASN1_INTEGER_set),
354 DLSYM_ARG(ASN1_item_d2i),
355 DLSYM_ARG(ASN1_item_free),
356 DLSYM_ARG(ASN1_item_i2d),
357 DLSYM_ARG(ASN1_item_new),
358 DLSYM_ARG(ASN1_OBJECT_it),
359 DLSYM_ARG(ASN1_OCTET_STRING_free),
360 DLSYM_ARG(ASN1_OCTET_STRING_it),
361 DLSYM_ARG(ASN1_OCTET_STRING_set),
362 DLSYM_ARG(ASN1_STRING_get0_data),
363 DLSYM_ARG(ASN1_STRING_length),
364 DLSYM_ARG(ASN1_STRING_new),
365 DLSYM_ARG(ASN1_STRING_set),
366 DLSYM_ARG(ASN1_STRING_set0),
367 DLSYM_ARG(ASN1_TIME_free),
368 DLSYM_ARG(ASN1_TIME_set),
369 DLSYM_ARG(ASN1_TYPE_new),
370 DLSYM_ARG(BIO_ctrl),
371 DLSYM_ARG(BIO_find_type),
372 DLSYM_ARG(BIO_free_all),
373 DLSYM_ARG(BIO_free),
374 DLSYM_ARG(BIO_new_mem_buf),
375 DLSYM_ARG(BIO_new_socket),
376 DLSYM_ARG(BIO_new),
377 DLSYM_ARG(BIO_s_mem),
378 DLSYM_ARG(BIO_write),
379 DLSYM_ARG(BN_bin2bn),
380 DLSYM_ARG(BN_bn2bin),
381 DLSYM_ARG(BN_bn2nativepad),
382 DLSYM_ARG(BN_CTX_free),
383 DLSYM_ARG(BN_CTX_new),
384 DLSYM_ARG(BN_free),
385 DLSYM_ARG(BN_new),
386 DLSYM_ARG(BN_num_bits),
387 DLSYM_ARG(CRYPTO_free),
388 DLSYM_ARG(d2i_ASN1_OCTET_STRING),
389 DLSYM_ARG(d2i_ECPKParameters),
390 DLSYM_ARG(d2i_PKCS7),
391 DLSYM_ARG(d2i_PUBKEY),
392 DLSYM_ARG(d2i_X509),
393 DLSYM_ARG(EC_GROUP_free),
394 DLSYM_ARG(EC_GROUP_get_curve_name),
395 DLSYM_ARG(EC_GROUP_get_curve),
396 DLSYM_ARG(EC_GROUP_get_field_type),
397 DLSYM_ARG(EC_GROUP_get0_generator),
398 DLSYM_ARG(EC_GROUP_get0_order),
399 DLSYM_ARG(EC_GROUP_new_by_curve_name),
400 DLSYM_ARG(EC_POINT_free),
401 DLSYM_ARG(EC_POINT_new),
402 DLSYM_ARG(EC_POINT_oct2point),
403 DLSYM_ARG(EC_POINT_point2buf),
404 DLSYM_ARG(EC_POINT_point2oct),
405 DLSYM_ARG(EC_POINT_set_affine_coordinates),
406 DLSYM_ARG(ECDSA_SIG_free),
407 #if !defined(OPENSSL_NO_ENGINE) && !defined(OPENSSL_NO_DEPRECATED_3_0)
408 DLSYM_ARG_FORCE(ENGINE_by_id),
409 DLSYM_ARG_FORCE(ENGINE_free),
410 DLSYM_ARG_FORCE(ENGINE_init),
411 DLSYM_ARG_FORCE(ENGINE_load_private_key),
412 #endif
413 #if !defined(OPENSSL_NO_DEPRECATED_3_0)
414 DLSYM_ARG_FORCE(EC_KEY_check_key),
415 DLSYM_ARG_FORCE(EC_KEY_free),
416 DLSYM_ARG_FORCE(EC_KEY_new),
417 DLSYM_ARG_FORCE(EC_KEY_set_group),
418 DLSYM_ARG_FORCE(EC_KEY_set_public_key),
419 DLSYM_ARG_FORCE(ECDSA_do_verify),
420 DLSYM_ARG_FORCE(ECDSA_SIG_new),
421 DLSYM_ARG_FORCE(ECDSA_SIG_set0),
422 DLSYM_ARG_FORCE(EVP_PKEY_assign),
423 DLSYM_ARG_FORCE(RSA_free),
424 DLSYM_ARG_FORCE(RSA_new),
425 DLSYM_ARG_FORCE(RSA_set0_key),
426 DLSYM_ARG_FORCE(RSA_size),
427 DLSYM_ARG_FORCE(RSAPublicKey_dup),
428 #endif
429 DLSYM_ARG(ERR_clear_error),
430 DLSYM_ARG(ERR_error_string_n),
431 DLSYM_ARG(ERR_error_string),
432 DLSYM_ARG(ERR_get_error),
433 DLSYM_ARG(ERR_peek_last_error),
434 DLSYM_ARG(EVP_aes_256_ctr),
435 DLSYM_ARG(EVP_aes_256_gcm),
436 DLSYM_ARG(EVP_CIPHER_CTX_ctrl),
437 DLSYM_ARG(EVP_CIPHER_CTX_free),
438 DLSYM_ARG(EVP_CIPHER_CTX_get_block_size),
439 DLSYM_ARG(EVP_CIPHER_CTX_new),
440 DLSYM_ARG(EVP_CIPHER_fetch),
441 DLSYM_ARG(EVP_CIPHER_free),
442 DLSYM_ARG(EVP_CIPHER_get_block_size),
443 DLSYM_ARG(EVP_CIPHER_get_iv_length),
444 DLSYM_ARG(EVP_CIPHER_get_key_length),
445 DLSYM_ARG(EVP_DecryptFinal_ex),
446 DLSYM_ARG(EVP_DecryptInit_ex),
447 DLSYM_ARG(EVP_DecryptUpdate),
448 DLSYM_ARG(EVP_Digest),
449 DLSYM_ARG(EVP_DigestFinal_ex),
450 DLSYM_ARG(EVP_DigestInit_ex),
451 DLSYM_ARG(EVP_DigestSign),
452 DLSYM_ARG(EVP_DigestSignInit),
453 DLSYM_ARG(EVP_DigestUpdate),
454 DLSYM_ARG(EVP_DigestVerify),
455 DLSYM_ARG(EVP_DigestVerifyInit),
456 DLSYM_ARG(EVP_EncryptFinal_ex),
457 DLSYM_ARG(EVP_EncryptInit_ex),
458 DLSYM_ARG(EVP_EncryptInit),
459 DLSYM_ARG(EVP_EncryptUpdate),
460 DLSYM_ARG(EVP_get_cipherbyname),
461 DLSYM_ARG(EVP_get_digestbyname),
462 DLSYM_ARG(EVP_KDF_CTX_free),
463 DLSYM_ARG(EVP_KDF_CTX_new),
464 DLSYM_ARG(EVP_KDF_derive),
465 DLSYM_ARG(EVP_KDF_fetch),
466 DLSYM_ARG(EVP_KDF_free),
467 DLSYM_ARG(EVP_MAC_CTX_free),
468 DLSYM_ARG(EVP_MAC_CTX_get_mac_size),
469 DLSYM_ARG(EVP_MAC_CTX_new),
470 DLSYM_ARG(EVP_MAC_fetch),
471 DLSYM_ARG(EVP_MAC_final),
472 DLSYM_ARG(EVP_MAC_free),
473 DLSYM_ARG(EVP_MAC_init),
474 DLSYM_ARG(EVP_MAC_update),
475 DLSYM_ARG(EVP_MD_CTX_free),
476 DLSYM_ARG(EVP_MD_CTX_get0_md),
477 DLSYM_ARG(EVP_MD_CTX_new),
478 DLSYM_ARG(EVP_MD_CTX_set_pkey_ctx),
479 DLSYM_ARG(EVP_MD_fetch),
480 DLSYM_ARG(EVP_MD_free),
481 DLSYM_ARG(EVP_MD_get_size),
482 DLSYM_ARG(EVP_MD_get_type),
483 DLSYM_ARG(EVP_MD_get0_name),
484 DLSYM_ARG(EVP_PKEY_CTX_free),
485 DLSYM_ARG(EVP_PKEY_CTX_new_from_name),
486 DLSYM_ARG(EVP_PKEY_CTX_new_id),
487 DLSYM_ARG(EVP_PKEY_CTX_new),
488 DLSYM_ARG(EVP_PKEY_CTX_set_ec_paramgen_curve_nid),
489 DLSYM_ARG(EVP_PKEY_CTX_set_rsa_oaep_md),
490 DLSYM_ARG(EVP_PKEY_CTX_set_rsa_padding),
491 DLSYM_ARG(EVP_PKEY_CTX_set_signature_md),
492 DLSYM_ARG(EVP_PKEY_CTX_set0_rsa_oaep_label),
493 DLSYM_ARG(EVP_PKEY_derive_init),
494 DLSYM_ARG(EVP_PKEY_derive_set_peer),
495 DLSYM_ARG(EVP_PKEY_derive),
496 DLSYM_ARG(EVP_PKEY_encrypt_init),
497 DLSYM_ARG(EVP_PKEY_encrypt),
498 DLSYM_ARG(EVP_PKEY_eq),
499 DLSYM_ARG(EVP_PKEY_free),
500 DLSYM_ARG(EVP_PKEY_fromdata_init),
501 DLSYM_ARG(EVP_PKEY_fromdata),
502 DLSYM_ARG(EVP_PKEY_get_base_id),
503 DLSYM_ARG(EVP_PKEY_get_bits),
504 DLSYM_ARG(EVP_PKEY_get_bn_param),
505 DLSYM_ARG(EVP_PKEY_get_group_name),
506 DLSYM_ARG(EVP_PKEY_get_id),
507 DLSYM_ARG(EVP_PKEY_get_utf8_string_param),
508 DLSYM_ARG(EVP_PKEY_get1_encoded_public_key),
509 DLSYM_ARG(EVP_PKEY_keygen_init),
510 DLSYM_ARG(EVP_PKEY_keygen),
511 DLSYM_ARG(EVP_PKEY_new_raw_public_key),
512 DLSYM_ARG(EVP_PKEY_new),
513 DLSYM_ARG(EVP_PKEY_verify_init),
514 DLSYM_ARG(EVP_PKEY_verify),
515 DLSYM_ARG(EVP_sha1),
516 DLSYM_ARG(EVP_sha256),
517 DLSYM_ARG(EVP_sha384),
518 DLSYM_ARG(EVP_sha512),
519 DLSYM_ARG(HMAC),
520 DLSYM_ARG(i2d_ASN1_INTEGER),
521 DLSYM_ARG(i2d_PKCS7_fp),
522 DLSYM_ARG(i2d_PKCS7),
523 DLSYM_ARG(i2d_PUBKEY_fp),
524 DLSYM_ARG(i2d_PUBKEY),
525 DLSYM_ARG(i2d_PublicKey),
526 DLSYM_ARG(i2d_X509_NAME),
527 DLSYM_ARG(i2d_X509),
528 DLSYM_ARG(OBJ_nid2obj),
529 DLSYM_ARG(OBJ_nid2sn),
530 DLSYM_ARG(OBJ_sn2nid),
531 DLSYM_ARG(OBJ_txt2obj),
532 DLSYM_ARG(OPENSSL_sk_new_null),
533 DLSYM_ARG(OPENSSL_sk_num),
534 DLSYM_ARG(OPENSSL_sk_pop_free),
535 DLSYM_ARG(OPENSSL_sk_push),
536 DLSYM_ARG(OPENSSL_sk_value),
537 DLSYM_ARG(OSSL_EC_curve_nid2name),
538 DLSYM_ARG(OSSL_PARAM_BLD_free),
539 DLSYM_ARG(OSSL_PARAM_BLD_new),
540 DLSYM_ARG(OSSL_PARAM_BLD_push_octet_string),
541 DLSYM_ARG(OSSL_PARAM_BLD_push_utf8_string),
542 DLSYM_ARG(OSSL_PARAM_BLD_to_param),
543 DLSYM_ARG(OSSL_PARAM_construct_BN),
544 DLSYM_ARG(OSSL_PARAM_construct_end),
545 DLSYM_ARG(OSSL_PARAM_construct_octet_string),
546 DLSYM_ARG(OSSL_PARAM_construct_utf8_string),
547 DLSYM_ARG(OSSL_PARAM_free),
548 DLSYM_ARG(OSSL_PROVIDER_try_load),
549 DLSYM_ARG(OSSL_STORE_close),
550 DLSYM_ARG(OSSL_STORE_expect),
551 DLSYM_ARG(OSSL_STORE_INFO_free),
552 DLSYM_ARG(OSSL_STORE_INFO_get1_CERT),
553 DLSYM_ARG(OSSL_STORE_INFO_get1_PKEY),
554 DLSYM_ARG(OSSL_STORE_load),
555 DLSYM_ARG(OSSL_STORE_open),
556 DLSYM_ARG(PEM_read_bio_PrivateKey),
557 DLSYM_ARG(PEM_read_bio_X509),
558 DLSYM_ARG(PEM_read_PrivateKey),
559 DLSYM_ARG(PEM_read_PUBKEY),
560 DLSYM_ARG(PEM_read_X509),
561 DLSYM_ARG(PEM_write_PrivateKey),
562 DLSYM_ARG(PEM_write_PUBKEY),
563 DLSYM_ARG(PEM_write_X509),
564 DLSYM_ARG(PKCS5_PBKDF2_HMAC),
565 DLSYM_ARG(PKCS7_add_attrib_content_type),
566 DLSYM_ARG(PKCS7_add_attrib_smimecap),
567 DLSYM_ARG(PKCS7_add_certificate),
568 DLSYM_ARG(PKCS7_add_signed_attribute),
569 DLSYM_ARG(PKCS7_add_signer),
570 DLSYM_ARG(PKCS7_add0_attrib_signing_time),
571 DLSYM_ARG(PKCS7_add1_attrib_digest),
572 DLSYM_ARG(PKCS7_ATTR_SIGN_it),
573 DLSYM_ARG(PKCS7_content_new),
574 DLSYM_ARG(PKCS7_ctrl),
575 DLSYM_ARG(PKCS7_dataFinal),
576 DLSYM_ARG(PKCS7_dataInit),
577 DLSYM_ARG(PKCS7_free),
578 DLSYM_ARG(PKCS7_get_signer_info),
579 DLSYM_ARG(PKCS7_new),
580 DLSYM_ARG(PKCS7_set_content),
581 DLSYM_ARG(PKCS7_set_type),
582 DLSYM_ARG(PKCS7_sign),
583 DLSYM_ARG(PKCS7_SIGNER_INFO_free),
584 DLSYM_ARG(PKCS7_SIGNER_INFO_new),
585 DLSYM_ARG(PKCS7_SIGNER_INFO_set),
586 DLSYM_ARG(PKCS7_verify),
587 DLSYM_ARG(SHA1),
588 DLSYM_ARG(SHA512),
589 #ifndef OPENSSL_NO_UI_CONSOLE
590 DLSYM_ARG(UI_create_method),
591 DLSYM_ARG(UI_destroy_method),
592 DLSYM_ARG(UI_get_default_method),
593 DLSYM_ARG(UI_get_method),
594 DLSYM_ARG(UI_get_string_type),
595 DLSYM_ARG(UI_get0_output_string),
596 DLSYM_ARG(UI_method_get_ex_data),
597 DLSYM_ARG(UI_method_get_reader),
598 DLSYM_ARG(UI_method_set_ex_data),
599 DLSYM_ARG(UI_method_set_reader),
600 DLSYM_ARG(UI_OpenSSL),
601 DLSYM_ARG(UI_set_default_method),
602 DLSYM_ARG(UI_set_result),
603 #endif
604 DLSYM_ARG(X509_ALGOR_free),
605 DLSYM_ARG(X509_ALGOR_set0),
606 DLSYM_ARG(X509_ATTRIBUTE_free),
607 DLSYM_ARG(X509_free),
608 DLSYM_ARG(X509_get_issuer_name),
609 DLSYM_ARG(X509_get_pubkey),
610 DLSYM_ARG(X509_get_signature_info),
611 DLSYM_ARG(X509_get_subject_name),
612 DLSYM_ARG(X509_get0_serialNumber),
613 DLSYM_ARG(X509_gmtime_adj),
614 DLSYM_ARG(X509_NAME_free),
615 DLSYM_ARG(X509_NAME_oneline),
616 DLSYM_ARG(X509_NAME_set),
617 DLSYM_ARG(X509_VERIFY_PARAM_set_hostflags),
618 DLSYM_ARG(X509_VERIFY_PARAM_set1_host),
619 DLSYM_ARG(X509_VERIFY_PARAM_set1_ip));
620 #else
621 return log_full_errno(log_level, SYNTHETIC_ERRNO(EOPNOTSUPP),
622 "libcrypto support is not compiled in.");
623 #endif
624 }
625
626 #if HAVE_OPENSSL
627
628 /* For each error in the OpenSSL thread error queue, log the provided message and the OpenSSL error
629 * string. If there are no errors in the OpenSSL thread queue, this logs the message with "No OpenSSL
630 * errors." This logs at level debug. Returns -EIO (or -ENOMEM). */
631 #define log_openssl_errors(fmt, ...) _log_openssl_errors(UNIQ, fmt, ##__VA_ARGS__)
632 #define _log_openssl_errors(u, fmt, ...) \
633 ({ \
634 size_t UNIQ_T(MAX, u) = 512 /* arbitrary, but openssl doc states it must be >= 256 */; \
635 _cleanup_free_ char *UNIQ_T(BUF, u) = malloc(UNIQ_T(MAX, u)); \
636 !UNIQ_T(BUF, u) \
637 ? log_oom_debug() \
638 : __log_openssl_errors(u, UNIQ_T(BUF, u), UNIQ_T(MAX, u), fmt, ##__VA_ARGS__) \
639 ?: log_debug_errno(SYNTHETIC_ERRNO(EIO), fmt ": No OpenSSL errors.", ##__VA_ARGS__); \
640 })
641 #define __log_openssl_errors(u, buf, max, fmt, ...) \
642 ({ \
643 int UNIQ_T(R, u) = 0; \
644 for (;;) { \
645 unsigned long UNIQ_T(E, u) = sym_ERR_get_error(); \
646 if (UNIQ_T(E, u) == 0) \
647 break; \
648 sym_ERR_error_string_n(UNIQ_T(E, u), buf, max); \
649 UNIQ_T(R, u) = log_debug_errno(SYNTHETIC_ERRNO(EIO), fmt ": %s", ##__VA_ARGS__, buf); \
650 } \
651 UNIQ_T(R, u); \
652 })
653
654 int openssl_pubkey_from_pem(const void *pem, size_t pem_size, EVP_PKEY **ret) {
655 int r;
656
657 assert(pem);
658 assert(ret);
659
660 r = dlopen_libcrypto(LOG_DEBUG);
661 if (r < 0)
662 return r;
663
664 if (pem_size == SIZE_MAX)
665 pem_size = strlen(pem);
666
667 _cleanup_fclose_ FILE *f = NULL;
668 f = fmemopen((void*) pem, pem_size, "r");
669 if (!f)
670 return log_oom_debug();
671
672 _cleanup_(EVP_PKEY_freep) EVP_PKEY *pkey = sym_PEM_read_PUBKEY(f, /* x= */ NULL, /* pam_password_cb= */ NULL, /* userdata= */ NULL);
673 if (!pkey)
674 return log_openssl_errors("Failed to parse PEM");
675
676 *ret = TAKE_PTR(pkey);
677 return 0;
678 }
679
680 int openssl_pubkey_to_pem(EVP_PKEY *pkey, char **ret) {
681 int r;
682
683 assert(pkey);
684 assert(ret);
685
686 r = dlopen_libcrypto(LOG_DEBUG);
687 if (r < 0)
688 return r;
689
690 _cleanup_(memstream_done) MemStream m = {};
691 FILE *f = memstream_init(&m);
692 if (!f)
693 return -ENOMEM;
694
695 if (sym_PEM_write_PUBKEY(f, pkey) <= 0)
696 return -EIO;
697
698 return memstream_finalize(&m, ret, /* ret_size= */ NULL);
699 }
700
701 /* Returns the number of bytes generated by the specified digest algorithm. This can be used only for
702 * fixed-size algorithms, e.g. md5, sha1, sha256, etc. Do not use this for variable-sized digest algorithms,
703 * e.g. shake128. Returns 0 on success, -EOPNOTSUPP if the algorithm is not supported, or < 0 for any other
704 * error. */
705 int openssl_digest_size(const char *digest_alg, size_t *ret_digest_size) {
706 int r;
707
708 assert(digest_alg);
709 assert(ret_digest_size);
710
711 r = dlopen_libcrypto(LOG_DEBUG);
712 if (r < 0)
713 return r;
714
715 _cleanup_(EVP_MD_freep) EVP_MD *md = sym_EVP_MD_fetch(NULL, digest_alg, NULL);
716 if (!md)
717 return log_debug_errno(SYNTHETIC_ERRNO(EOPNOTSUPP),
718 "Digest algorithm '%s' not supported.", digest_alg);
719
720 size_t digest_size = sym_EVP_MD_get_size(md);
721 if (digest_size == 0)
722 return log_openssl_errors("Failed to get Digest size");
723
724 *ret_digest_size = digest_size;
725
726 return 0;
727 }
728
729 /* Calculate the digest hash value for the provided data, using the specified digest algorithm. Returns 0 on
730 * success, -EOPNOTSUPP if the digest algorithm is not supported, or < 0 for any other error. */
731 int openssl_digest_many(
732 const char *digest_alg,
733 const struct iovec data[],
734 size_t n_data,
735 void **ret_digest,
736 size_t *ret_digest_size) {
737
738 int r;
739
740 assert(digest_alg);
741 assert(data || n_data == 0);
742 assert(ret_digest);
743 /* ret_digest_size is optional, as caller may already know the digest size */
744
745 r = dlopen_libcrypto(LOG_DEBUG);
746 if (r < 0)
747 return r;
748
749 _cleanup_(EVP_MD_freep) EVP_MD *md = sym_EVP_MD_fetch(NULL, digest_alg, NULL);
750 if (!md)
751 return log_debug_errno(SYNTHETIC_ERRNO(EOPNOTSUPP),
752 "Digest algorithm '%s' not supported.", digest_alg);
753
754 _cleanup_(EVP_MD_CTX_freep) EVP_MD_CTX *ctx = sym_EVP_MD_CTX_new();
755 if (!ctx)
756 return log_openssl_errors("Failed to create new EVP_MD_CTX");
757
758 if (!sym_EVP_DigestInit_ex(ctx, md, NULL))
759 return log_openssl_errors("Failed to initialize EVP_MD_CTX");
760
761 for (size_t i = 0; i < n_data; i++)
762 if (!sym_EVP_DigestUpdate(ctx, data[i].iov_base, data[i].iov_len))
763 return log_openssl_errors("Failed to update Digest");
764
765 size_t digest_size;
766 r = openssl_digest_size(digest_alg, &digest_size);
767 if (r < 0)
768 return r;
769
770 _cleanup_free_ void *buf = malloc(digest_size);
771 if (!buf)
772 return log_oom_debug();
773
774 unsigned size;
775 if (!sym_EVP_DigestFinal_ex(ctx, buf, &size))
776 return log_openssl_errors("Failed to finalize Digest");
777
778 assert(size == digest_size);
779
780 *ret_digest = TAKE_PTR(buf);
781 if (ret_digest_size)
782 *ret_digest_size = size;
783
784 return 0;
785 }
786
787 /* Calculate the HMAC digest hash value for the provided data, using the provided key and specified digest
788 * algorithm. Returns 0 on success, -EOPNOTSUPP if the digest algorithm is not supported, or < 0 for any
789 * other error. */
790 int openssl_hmac_many(
791 const char *digest_alg,
792 const void *key,
793 size_t key_size,
794 const struct iovec data[],
795 size_t n_data,
796 void **ret_digest,
797 size_t *ret_digest_size) {
798
799 int r;
800
801 assert(digest_alg);
802 assert(key);
803 assert(data || n_data == 0);
804 assert(ret_digest);
805 /* ret_digest_size is optional, as caller may already know the digest size */
806
807 r = dlopen_libcrypto(LOG_DEBUG);
808 if (r < 0)
809 return r;
810
811 _cleanup_(EVP_MD_freep) EVP_MD *md = sym_EVP_MD_fetch(NULL, digest_alg, NULL);
812 if (!md)
813 return log_debug_errno(SYNTHETIC_ERRNO(EOPNOTSUPP),
814 "Digest algorithm '%s' not supported.", digest_alg);
815
816 _cleanup_(EVP_MAC_freep) EVP_MAC *mac = sym_EVP_MAC_fetch(NULL, "HMAC", NULL);
817 if (!mac)
818 return log_openssl_errors("Failed to create new EVP_MAC");
819
820 _cleanup_(EVP_MAC_CTX_freep) EVP_MAC_CTX *ctx = sym_EVP_MAC_CTX_new(mac);
821 if (!ctx)
822 return log_openssl_errors("Failed to create new EVP_MAC_CTX");
823
824 _cleanup_(OSSL_PARAM_BLD_freep) OSSL_PARAM_BLD *bld = sym_OSSL_PARAM_BLD_new();
825 if (!bld)
826 return log_openssl_errors("Failed to create new OSSL_PARAM_BLD");
827
828 if (!sym_OSSL_PARAM_BLD_push_utf8_string(bld, OSSL_MAC_PARAM_DIGEST, (char*) digest_alg, 0))
829 return log_openssl_errors("Failed to set HMAC OSSL_MAC_PARAM_DIGEST");
830
831 _cleanup_(OSSL_PARAM_freep) OSSL_PARAM *params = sym_OSSL_PARAM_BLD_to_param(bld);
832 if (!params)
833 return log_openssl_errors("Failed to build HMAC OSSL_PARAM");
834
835 if (!sym_EVP_MAC_init(ctx, key, key_size, params))
836 return log_openssl_errors("Failed to initialize EVP_MAC_CTX");
837
838 for (size_t i = 0; i < n_data; i++)
839 if (!sym_EVP_MAC_update(ctx, data[i].iov_base, data[i].iov_len))
840 return log_openssl_errors("Failed to update HMAC");
841
842 size_t digest_size = sym_EVP_MAC_CTX_get_mac_size(ctx);
843 if (digest_size == 0)
844 return log_openssl_errors("Failed to get HMAC digest size");
845
846 _cleanup_free_ void *buf = malloc(digest_size);
847 if (!buf)
848 return log_oom_debug();
849
850 size_t size;
851 if (!sym_EVP_MAC_final(ctx, buf, &size, digest_size))
852 return log_openssl_errors("Failed to finalize HMAC");
853
854 assert(size == digest_size);
855
856 *ret_digest = TAKE_PTR(buf);
857 if (ret_digest_size)
858 *ret_digest_size = size;
859
860 return 0;
861 }
862
863 /* Symmetric Cipher encryption using the alg-bits-mode cipher, e.g. AES-128-CFB. The key is required and must
864 * be at least the minimum required key length for the cipher. The IV is optional but, if provided, it must
865 * be at least the minimum iv length for the cipher. If no IV is provided and the cipher requires one, a
866 * buffer of zeroes is used. Returns 0 on success, -EOPNOTSUPP if the cipher algorithm is not supported, or <
867 * 0 on any other error. */
868 int openssl_cipher_many(
869 const char *alg,
870 size_t bits,
871 const char *mode,
872 const void *key,
873 size_t key_size,
874 const void *iv,
875 size_t iv_size,
876 const struct iovec data[],
877 size_t n_data,
878 void **ret,
879 size_t *ret_size) {
880
881 int r;
882
883 assert(alg);
884 assert(bits > 0);
885 assert(mode);
886 assert(key);
887 assert(iv || iv_size == 0);
888 assert(data || n_data == 0);
889 assert(ret);
890 assert(ret_size);
891
892 r = dlopen_libcrypto(LOG_DEBUG);
893 if (r < 0)
894 return r;
895
896 _cleanup_free_ char *cipher_alg = NULL;
897 if (asprintf(&cipher_alg, "%s-%zu-%s", alg, bits, mode) < 0)
898 return log_oom_debug();
899
900 _cleanup_(EVP_CIPHER_freep) EVP_CIPHER *cipher = sym_EVP_CIPHER_fetch(NULL, cipher_alg, NULL);
901 if (!cipher)
902 return log_debug_errno(SYNTHETIC_ERRNO(EOPNOTSUPP),
903 "Cipher algorithm '%s' not supported.", cipher_alg);
904
905 _cleanup_(EVP_CIPHER_CTX_freep) EVP_CIPHER_CTX *ctx = sym_EVP_CIPHER_CTX_new();
906 if (!ctx)
907 return log_openssl_errors("Failed to create new EVP_CIPHER_CTX");
908
909 /* Verify enough key data was provided. */
910 int cipher_key_length = sym_EVP_CIPHER_get_key_length(cipher);
911 assert(cipher_key_length >= 0);
912 if ((size_t) cipher_key_length > key_size)
913 return log_debug_errno(SYNTHETIC_ERRNO(EINVAL),
914 "Not enough key bytes provided, require %d", cipher_key_length);
915
916 /* Verify enough IV data was provided or, if no IV was provided, use a zeroed buffer for IV data. */
917 int cipher_iv_length = sym_EVP_CIPHER_get_iv_length(cipher);
918 assert(cipher_iv_length >= 0);
919 _cleanup_free_ void *zero_iv = NULL;
920 if (iv_size == 0) {
921 zero_iv = malloc0(cipher_iv_length);
922 if (!zero_iv)
923 return log_oom_debug();
924
925 iv = zero_iv;
926 iv_size = (size_t) cipher_iv_length;
927 }
928 if ((size_t) cipher_iv_length > iv_size)
929 return log_debug_errno(SYNTHETIC_ERRNO(EINVAL),
930 "Not enough IV bytes provided, require %d", cipher_iv_length);
931
932 if (!sym_EVP_EncryptInit(ctx, cipher, key, iv))
933 return log_openssl_errors("Failed to initialize EVP_CIPHER_CTX.");
934
935 int cipher_block_size = sym_EVP_CIPHER_CTX_get_block_size(ctx);
936 assert(cipher_block_size > 0);
937
938 _cleanup_free_ uint8_t *buf = NULL;
939 size_t size = 0;
940
941 for (size_t i = 0; i < n_data; i++) {
942 /* Cipher may produce (up to) input length + cipher block size of output. */
943 if (!GREEDY_REALLOC(buf, size + data[i].iov_len + cipher_block_size))
944 return log_oom_debug();
945
946 int update_size;
947 if (!sym_EVP_EncryptUpdate(ctx, &buf[size], &update_size, data[i].iov_base, data[i].iov_len))
948 return log_openssl_errors("Failed to update Cipher.");
949
950 size += update_size;
951 }
952
953 if (!GREEDY_REALLOC(buf, size + cipher_block_size))
954 return log_oom_debug();
955
956 int final_size;
957 if (!sym_EVP_EncryptFinal_ex(ctx, &buf[size], &final_size))
958 return log_openssl_errors("Failed to finalize Cipher.");
959
960 *ret = TAKE_PTR(buf);
961 *ret_size = size + final_size;
962
963 return 0;
964 }
965
966 /* Perform Single-Step (aka "Concat") KDF. Currently, this only supports using the digest for the auxiliary
967 * function. The derive_size parameter specifies how many bytes are derived.
968 *
969 * For more details see: https://www.openssl.org/docs/manmaster/man7/EVP_KDF-SS.html */
970 int kdf_ss_derive(
971 const char *digest,
972 const void *key,
973 size_t key_size,
974 const void *salt,
975 size_t salt_size,
976 const void *info,
977 size_t info_size,
978 size_t derive_size,
979 void **ret) {
980
981 int r;
982
983 assert(digest);
984 assert(key);
985 assert(derive_size > 0);
986 assert(ret);
987
988 r = dlopen_libcrypto(LOG_DEBUG);
989 if (r < 0)
990 return r;
991
992 _cleanup_(EVP_KDF_freep) EVP_KDF *kdf = sym_EVP_KDF_fetch(NULL, "SSKDF", NULL);
993 if (!kdf)
994 return log_openssl_errors("Failed to create new EVP_KDF");
995
996 _cleanup_(EVP_KDF_CTX_freep) EVP_KDF_CTX *ctx = sym_EVP_KDF_CTX_new(kdf);
997 if (!ctx)
998 return log_openssl_errors("Failed to create new EVP_KDF_CTX");
999
1000 _cleanup_(OSSL_PARAM_BLD_freep) OSSL_PARAM_BLD *bld = sym_OSSL_PARAM_BLD_new();
1001 if (!bld)
1002 return log_openssl_errors("Failed to create new OSSL_PARAM_BLD");
1003
1004 _cleanup_free_ void *buf = malloc(derive_size);
1005 if (!buf)
1006 return log_oom_debug();
1007
1008 if (!sym_OSSL_PARAM_BLD_push_utf8_string(bld, OSSL_KDF_PARAM_DIGEST, (char*) digest, 0))
1009 return log_openssl_errors("Failed to add KDF-SS OSSL_KDF_PARAM_DIGEST");
1010
1011 if (!sym_OSSL_PARAM_BLD_push_octet_string(bld, OSSL_KDF_PARAM_KEY, (char*) key, key_size))
1012 return log_openssl_errors("Failed to add KDF-SS OSSL_KDF_PARAM_KEY");
1013
1014 if (salt)
1015 if (!sym_OSSL_PARAM_BLD_push_octet_string(bld, OSSL_KDF_PARAM_SALT, (char*) salt, salt_size))
1016 return log_openssl_errors("Failed to add KDF-SS OSSL_KDF_PARAM_SALT");
1017
1018 if (info)
1019 if (!sym_OSSL_PARAM_BLD_push_octet_string(bld, OSSL_KDF_PARAM_INFO, (char*) info, info_size))
1020 return log_openssl_errors("Failed to add KDF-SS OSSL_KDF_PARAM_INFO");
1021
1022 _cleanup_(OSSL_PARAM_freep) OSSL_PARAM *params = sym_OSSL_PARAM_BLD_to_param(bld);
1023 if (!params)
1024 return log_openssl_errors("Failed to build KDF-SS OSSL_PARAM");
1025
1026 if (sym_EVP_KDF_derive(ctx, buf, derive_size, params) <= 0)
1027 return log_openssl_errors("OpenSSL KDF-SS derive failed");
1028
1029 *ret = TAKE_PTR(buf);
1030
1031 return 0;
1032 }
1033
1034 /* Perform Key-Based HMAC KDF. The mode must be "COUNTER" or "FEEDBACK". The parameter naming is from the
1035 * OpenSSL api, and maps to SP800-108 naming as "...key, salt, info, and seed correspond to KI, Label,
1036 * Context, and IV (respectively)...". The derive_size parameter specifies how many bytes are derived.
1037 *
1038 * For more details see: https://www.openssl.org/docs/manmaster/man7/EVP_KDF-KB.html */
1039 int kdf_kb_hmac_derive(
1040 const char *mode,
1041 const char *digest,
1042 const void *key,
1043 size_t key_size,
1044 const void *salt,
1045 size_t salt_size,
1046 const void *info,
1047 size_t info_size,
1048 const void *seed,
1049 size_t seed_size,
1050 size_t derive_size,
1051 void **ret) {
1052
1053 int r;
1054
1055 assert(mode);
1056 assert(strcaseeq(mode, "COUNTER") || strcaseeq(mode, "FEEDBACK"));
1057 assert(digest);
1058 assert(key || key_size == 0);
1059 assert(salt || salt_size == 0);
1060 assert(info || info_size == 0);
1061 assert(seed || seed_size == 0);
1062 assert(derive_size > 0);
1063 assert(ret);
1064
1065 r = dlopen_libcrypto(LOG_DEBUG);
1066 if (r < 0)
1067 return r;
1068
1069 _cleanup_(EVP_KDF_freep) EVP_KDF *kdf = sym_EVP_KDF_fetch(NULL, "KBKDF", NULL);
1070 if (!kdf)
1071 return log_openssl_errors("Failed to create new EVP_KDF");
1072
1073 _cleanup_(EVP_KDF_CTX_freep) EVP_KDF_CTX *ctx = sym_EVP_KDF_CTX_new(kdf);
1074 if (!ctx)
1075 return log_openssl_errors("Failed to create new EVP_KDF_CTX");
1076
1077 _cleanup_(OSSL_PARAM_BLD_freep) OSSL_PARAM_BLD *bld = sym_OSSL_PARAM_BLD_new();
1078 if (!bld)
1079 return log_openssl_errors("Failed to create new OSSL_PARAM_BLD");
1080
1081 if (!sym_OSSL_PARAM_BLD_push_utf8_string(bld, OSSL_KDF_PARAM_MAC, (char*) "HMAC", 0))
1082 return log_openssl_errors("Failed to add KDF-KB OSSL_KDF_PARAM_MAC");
1083
1084 if (!sym_OSSL_PARAM_BLD_push_utf8_string(bld, OSSL_KDF_PARAM_MODE, (char*) mode, 0))
1085 return log_openssl_errors("Failed to add KDF-KB OSSL_KDF_PARAM_MODE");
1086
1087 if (!sym_OSSL_PARAM_BLD_push_utf8_string(bld, OSSL_KDF_PARAM_DIGEST, (char*) digest, 0))
1088 return log_openssl_errors("Failed to add KDF-KB OSSL_KDF_PARAM_DIGEST");
1089
1090 if (key)
1091 if (!sym_OSSL_PARAM_BLD_push_octet_string(bld, OSSL_KDF_PARAM_KEY, (char*) key, key_size))
1092 return log_openssl_errors("Failed to add KDF-KB OSSL_KDF_PARAM_KEY");
1093
1094 if (salt)
1095 if (!sym_OSSL_PARAM_BLD_push_octet_string(bld, OSSL_KDF_PARAM_SALT, (char*) salt, salt_size))
1096 return log_openssl_errors("Failed to add KDF-KB OSSL_KDF_PARAM_SALT");
1097
1098 if (info)
1099 if (!sym_OSSL_PARAM_BLD_push_octet_string(bld, OSSL_KDF_PARAM_INFO, (char*) info, info_size))
1100 return log_openssl_errors("Failed to add KDF-KB OSSL_KDF_PARAM_INFO");
1101
1102 if (seed)
1103 if (!sym_OSSL_PARAM_BLD_push_octet_string(bld, OSSL_KDF_PARAM_SEED, (char*) seed, seed_size))
1104 return log_openssl_errors("Failed to add KDF-KB OSSL_KDF_PARAM_SEED");
1105
1106 _cleanup_(OSSL_PARAM_freep) OSSL_PARAM *params = sym_OSSL_PARAM_BLD_to_param(bld);
1107 if (!params)
1108 return log_openssl_errors("Failed to build KDF-KB OSSL_PARAM");
1109
1110 _cleanup_free_ void *buf = malloc(derive_size);
1111 if (!buf)
1112 return log_oom_debug();
1113
1114 if (sym_EVP_KDF_derive(ctx, buf, derive_size, params) <= 0)
1115 return log_openssl_errors("OpenSSL KDF-KB derive failed");
1116
1117 *ret = TAKE_PTR(buf);
1118
1119 return 0;
1120 }
1121
1122 int rsa_oaep_encrypt_bytes(
1123 const EVP_PKEY *pkey,
1124 const char *digest_alg,
1125 const char *label,
1126 const void *decrypted_key,
1127 size_t decrypted_key_size,
1128 void **ret_encrypt_key,
1129 size_t *ret_encrypt_key_size) {
1130
1131 int r;
1132
1133 assert(pkey);
1134 assert(digest_alg);
1135 assert(decrypted_key);
1136 assert(decrypted_key_size > 0);
1137 assert(ret_encrypt_key);
1138 assert(ret_encrypt_key_size);
1139
1140 r = dlopen_libcrypto(LOG_DEBUG);
1141 if (r < 0)
1142 return r;
1143
1144 _cleanup_(EVP_MD_freep) EVP_MD *md = sym_EVP_MD_fetch(NULL, digest_alg, NULL);
1145 if (!md)
1146 return log_debug_errno(SYNTHETIC_ERRNO(EOPNOTSUPP),
1147 "Digest algorithm '%s' not supported.", digest_alg);
1148
1149 _cleanup_(EVP_PKEY_CTX_freep) EVP_PKEY_CTX *ctx = sym_EVP_PKEY_CTX_new((EVP_PKEY*) pkey, NULL);
1150 if (!ctx)
1151 return log_openssl_errors("Failed to create new EVP_PKEY_CTX");
1152
1153 if (sym_EVP_PKEY_encrypt_init(ctx) <= 0)
1154 return log_openssl_errors("Failed to initialize EVP_PKEY_CTX");
1155
1156 if (sym_EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_PKCS1_OAEP_PADDING) <= 0)
1157 return log_openssl_errors("Failed to configure RSA-OAEP padding");
1158
1159 if (sym_EVP_PKEY_CTX_set_rsa_oaep_md(ctx, md) <= 0)
1160 return log_openssl_errors("Failed to configure RSA-OAEP MD");
1161
1162 if (label) {
1163 _cleanup_free_ char *duplabel = strdup(label);
1164 if (!duplabel)
1165 return log_oom_debug();
1166
1167 if (sym_EVP_PKEY_CTX_set0_rsa_oaep_label(ctx, duplabel, strlen(duplabel) + 1) <= 0)
1168 return log_openssl_errors("Failed to configure RSA-OAEP label");
1169 /* ctx owns this now, don't free */
1170 TAKE_PTR(duplabel);
1171 }
1172
1173 size_t size = 0;
1174 if (sym_EVP_PKEY_encrypt(ctx, NULL, &size, decrypted_key, decrypted_key_size) <= 0)
1175 return log_openssl_errors("Failed to determine RSA-OAEP encrypted key size");
1176
1177 _cleanup_free_ void *buf = malloc(size);
1178 if (!buf)
1179 return log_oom_debug();
1180
1181 if (sym_EVP_PKEY_encrypt(ctx, buf, &size, decrypted_key, decrypted_key_size) <= 0)
1182 return log_openssl_errors("Failed to RSA-OAEP encrypt");
1183
1184 *ret_encrypt_key = TAKE_PTR(buf);
1185 *ret_encrypt_key_size = size;
1186
1187 return 0;
1188 }
1189
1190 int rsa_pkey_to_suitable_key_size(
1191 EVP_PKEY *pkey,
1192 size_t *ret_suitable_key_size) {
1193
1194 size_t suitable_key_size;
1195 int bits, r;
1196
1197 assert(pkey);
1198 assert(ret_suitable_key_size);
1199
1200 /* Analyzes the specified public key and that it is RSA. If so, will return a suitable size for a
1201 * disk encryption key to encrypt with RSA for use in PKCS#11 security token schemes. */
1202
1203 r = dlopen_libcrypto(LOG_DEBUG);
1204 if (r < 0)
1205 return r;
1206
1207 if (sym_EVP_PKEY_get_base_id(pkey) != EVP_PKEY_RSA)
1208 return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG), "X.509 certificate does not refer to RSA key.");
1209
1210 bits = sym_EVP_PKEY_get_bits(pkey);
1211 log_debug("Bits in RSA key: %i", bits);
1212
1213 /* We use RSA-OAEP for the cleartext, which has 2*hash_len + 2 bytes of overhead (e.g. 66 bytes
1214 * for SHA-256, 42 for SHA-1). Leave plenty of headroom by only generating a key half the size of
1215 * the RSA modulus. */
1216 suitable_key_size = bits / 8 / 2;
1217
1218 if (suitable_key_size < 1)
1219 return log_debug_errno(SYNTHETIC_ERRNO(EIO), "Uh, RSA key size too short?");
1220
1221 *ret_suitable_key_size = suitable_key_size;
1222 return 0;
1223 }
1224
1225 /* Generate RSA public key from provided "n" and "e" values. Numbers "n" and "e" must be provided here
1226 * in big-endian format, e.g. wrap it with htobe32() for uint32_t. */
1227 int rsa_pkey_from_n_e(const void *n, size_t n_size, const void *e, size_t e_size, EVP_PKEY **ret) {
1228 _cleanup_(EVP_PKEY_freep) EVP_PKEY *pkey = NULL;
1229 int r;
1230
1231 assert(n);
1232 assert(n_size != 0);
1233 assert(e);
1234 assert(e_size != 0);
1235 assert(ret);
1236
1237 r = dlopen_libcrypto(LOG_DEBUG);
1238 if (r < 0)
1239 return r;
1240
1241 _cleanup_(EVP_PKEY_CTX_freep) EVP_PKEY_CTX *ctx = sym_EVP_PKEY_CTX_new_from_name(NULL, "RSA", NULL);
1242 if (!ctx)
1243 return log_openssl_errors("Failed to create new EVP_PKEY_CTX");
1244
1245 if (sym_EVP_PKEY_fromdata_init(ctx) <= 0)
1246 return log_openssl_errors("Failed to initialize EVP_PKEY_CTX");
1247
1248 OSSL_PARAM params[3];
1249
1250 #if __BYTE_ORDER == __BIG_ENDIAN
1251 params[0] = sym_OSSL_PARAM_construct_BN(OSSL_PKEY_PARAM_RSA_N, (void*)n, n_size);
1252 params[1] = sym_OSSL_PARAM_construct_BN(OSSL_PKEY_PARAM_RSA_E, (void*)e, e_size);
1253 #else
1254 _cleanup_free_ void *native_n = memdup_reverse(n, n_size);
1255 if (!native_n)
1256 return log_oom_debug();
1257
1258 _cleanup_free_ void *native_e = memdup_reverse(e, e_size);
1259 if (!native_e)
1260 return log_oom_debug();
1261
1262 params[0] = sym_OSSL_PARAM_construct_BN(OSSL_PKEY_PARAM_RSA_N, native_n, n_size);
1263 params[1] = sym_OSSL_PARAM_construct_BN(OSSL_PKEY_PARAM_RSA_E, native_e, e_size);
1264 #endif
1265 params[2] = sym_OSSL_PARAM_construct_end();
1266
1267 if (sym_EVP_PKEY_fromdata(ctx, &pkey, EVP_PKEY_PUBLIC_KEY, params) <= 0)
1268 return log_openssl_errors("Failed to create RSA EVP_PKEY");
1269
1270 *ret = TAKE_PTR(pkey);
1271
1272 return 0;
1273 }
1274
1275 /* Get the "n" and "e" values from the pkey. The values are returned in "bin" format, i.e. BN_bn2bin(). */
1276 int rsa_pkey_to_n_e(
1277 const EVP_PKEY *pkey,
1278 void **ret_n,
1279 size_t *ret_n_size,
1280 void **ret_e,
1281 size_t *ret_e_size) {
1282
1283 int r;
1284
1285 assert(pkey);
1286 assert(ret_n);
1287 assert(ret_n_size);
1288 assert(ret_e);
1289 assert(ret_e_size);
1290
1291 r = dlopen_libcrypto(LOG_DEBUG);
1292 if (r < 0)
1293 return r;
1294
1295 _cleanup_(BN_freep) BIGNUM *bn_n = NULL;
1296 if (!sym_EVP_PKEY_get_bn_param(pkey, OSSL_PKEY_PARAM_RSA_N, &bn_n))
1297 return log_openssl_errors("Failed to get RSA n");
1298
1299 _cleanup_(BN_freep) BIGNUM *bn_e = NULL;
1300 if (!sym_EVP_PKEY_get_bn_param(pkey, OSSL_PKEY_PARAM_RSA_E, &bn_e))
1301 return log_openssl_errors("Failed to get RSA e");
1302
1303 size_t n_size = sym_BN_num_bytes(bn_n), e_size = sym_BN_num_bytes(bn_e);
1304 _cleanup_free_ void *n = malloc(n_size), *e = malloc(e_size);
1305 if (!n || !e)
1306 return log_oom_debug();
1307
1308 assert(sym_BN_bn2bin(bn_n, n) == (int) n_size);
1309 assert(sym_BN_bn2bin(bn_e, e) == (int) e_size);
1310
1311 *ret_n = TAKE_PTR(n);
1312 *ret_n_size = n_size;
1313 *ret_e = TAKE_PTR(e);
1314 *ret_e_size = e_size;
1315
1316 return 0;
1317 }
1318
1319 /* Generate ECC public key from provided curve ID and x/y points. */
1320 int ecc_pkey_from_curve_x_y(
1321 int curve_id,
1322 const void *x,
1323 size_t x_size,
1324 const void *y,
1325 size_t y_size,
1326 EVP_PKEY **ret) {
1327
1328 int r;
1329
1330 assert(x);
1331 assert(y);
1332 assert(ret);
1333
1334 r = dlopen_libcrypto(LOG_DEBUG);
1335 if (r < 0)
1336 return r;
1337
1338 _cleanup_(EVP_PKEY_CTX_freep) EVP_PKEY_CTX *ctx = sym_EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL);
1339 if (!ctx)
1340 return log_openssl_errors("Failed to create new EVP_PKEY_CTX");
1341
1342 _cleanup_(BN_freep) BIGNUM *bn_x = sym_BN_bin2bn(x, x_size, NULL);
1343 if (!bn_x)
1344 return log_openssl_errors("Failed to create BIGNUM x");
1345
1346 _cleanup_(BN_freep) BIGNUM *bn_y = sym_BN_bin2bn(y, y_size, NULL);
1347 if (!bn_y)
1348 return log_openssl_errors("Failed to create BIGNUM y");
1349
1350 _cleanup_(EC_GROUP_freep) EC_GROUP *group = sym_EC_GROUP_new_by_curve_name(curve_id);
1351 if (!group)
1352 return log_openssl_errors("ECC curve id %d not supported", curve_id);
1353
1354 _cleanup_(EC_POINT_freep) EC_POINT *point = sym_EC_POINT_new(group);
1355 if (!point)
1356 return log_openssl_errors("Failed to create new EC_POINT");
1357
1358 if (!sym_EC_POINT_set_affine_coordinates(group, point, bn_x, bn_y, NULL))
1359 return log_openssl_errors("Failed to set ECC coordinates");
1360
1361 if (sym_EVP_PKEY_fromdata_init(ctx) <= 0)
1362 return log_openssl_errors("Failed to initialize EVP_PKEY_CTX");
1363
1364 _cleanup_(OSSL_PARAM_BLD_freep) OSSL_PARAM_BLD *bld = sym_OSSL_PARAM_BLD_new();
1365 if (!bld)
1366 return log_openssl_errors("Failed to create new OSSL_PARAM_BLD");
1367
1368 if (!sym_OSSL_PARAM_BLD_push_utf8_string(bld, OSSL_PKEY_PARAM_GROUP_NAME, (char*) sym_OSSL_EC_curve_nid2name(curve_id), 0))
1369 return log_openssl_errors("Failed to add ECC OSSL_PKEY_PARAM_GROUP_NAME");
1370
1371 _cleanup_(OPENSSL_freep) void *pbuf = NULL;
1372 size_t pbuf_len = 0;
1373 pbuf_len = sym_EC_POINT_point2buf(group, point, POINT_CONVERSION_UNCOMPRESSED, (unsigned char**) &pbuf, NULL);
1374 if (pbuf_len == 0)
1375 return log_openssl_errors("Failed to convert ECC point to buffer");
1376
1377 if (!sym_OSSL_PARAM_BLD_push_octet_string(bld, OSSL_PKEY_PARAM_PUB_KEY, pbuf, pbuf_len))
1378 return log_openssl_errors("Failed to add ECC OSSL_PKEY_PARAM_PUB_KEY");
1379
1380 _cleanup_(OSSL_PARAM_freep) OSSL_PARAM *params = sym_OSSL_PARAM_BLD_to_param(bld);
1381 if (!params)
1382 return log_openssl_errors("Failed to build ECC OSSL_PARAM");
1383
1384 _cleanup_(EVP_PKEY_freep) EVP_PKEY *pkey = NULL;
1385 if (sym_EVP_PKEY_fromdata(ctx, &pkey, EVP_PKEY_PUBLIC_KEY, params) <= 0)
1386 return log_openssl_errors("Failed to create ECC EVP_PKEY");
1387
1388 *ret = TAKE_PTR(pkey);
1389 return 0;
1390 }
1391
1392 int ecc_pkey_to_curve_x_y(
1393 const EVP_PKEY *pkey,
1394 int *ret_curve_id,
1395 void **ret_x,
1396 size_t *ret_x_size,
1397 void **ret_y,
1398 size_t *ret_y_size) {
1399
1400 _cleanup_(BN_freep) BIGNUM *bn_x = NULL, *bn_y = NULL;
1401 int curve_id, r;
1402
1403 assert(pkey);
1404
1405 r = dlopen_libcrypto(LOG_DEBUG);
1406 if (r < 0)
1407 return r;
1408
1409 size_t name_size;
1410 if (!sym_EVP_PKEY_get_utf8_string_param(pkey, OSSL_PKEY_PARAM_GROUP_NAME, NULL, 0, &name_size))
1411 return log_openssl_errors("Failed to get ECC group name size");
1412
1413 _cleanup_free_ char *name = new(char, name_size + 1);
1414 if (!name)
1415 return log_oom_debug();
1416
1417 if (!sym_EVP_PKEY_get_utf8_string_param(pkey, OSSL_PKEY_PARAM_GROUP_NAME, name, name_size + 1, NULL))
1418 return log_openssl_errors("Failed to get ECC group name");
1419
1420 curve_id = sym_OBJ_sn2nid(name);
1421 if (curve_id == NID_undef)
1422 return log_openssl_errors("Failed to get ECC curve id");
1423
1424 if (!sym_EVP_PKEY_get_bn_param(pkey, OSSL_PKEY_PARAM_EC_PUB_X, &bn_x))
1425 return log_openssl_errors("Failed to get ECC point x");
1426
1427 if (!sym_EVP_PKEY_get_bn_param(pkey, OSSL_PKEY_PARAM_EC_PUB_Y, &bn_y))
1428 return log_openssl_errors("Failed to get ECC point y");
1429
1430 size_t x_size = sym_BN_num_bytes(bn_x), y_size = sym_BN_num_bytes(bn_y);
1431 _cleanup_free_ void *x = malloc(x_size), *y = malloc(y_size);
1432 if (!x || !y)
1433 return log_oom_debug();
1434
1435 assert(sym_BN_bn2bin(bn_x, x) == (int) x_size);
1436 assert(sym_BN_bn2bin(bn_y, y) == (int) y_size);
1437
1438 if (ret_curve_id)
1439 *ret_curve_id = curve_id;
1440 if (ret_x)
1441 *ret_x = TAKE_PTR(x);
1442 if (ret_x_size)
1443 *ret_x_size = x_size;
1444 if (ret_y)
1445 *ret_y = TAKE_PTR(y);
1446 if (ret_y_size)
1447 *ret_y_size = y_size;
1448
1449 return 0;
1450 }
1451
1452 /* Generate a new ECC key for the specified ECC curve id. */
1453 int ecc_pkey_new(int curve_id, EVP_PKEY **ret) {
1454 int r;
1455
1456 assert(ret);
1457
1458 r = dlopen_libcrypto(LOG_DEBUG);
1459 if (r < 0)
1460 return r;
1461
1462 _cleanup_(EVP_PKEY_CTX_freep) EVP_PKEY_CTX *ctx = sym_EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL);
1463 if (!ctx)
1464 return log_openssl_errors("Failed to create new EVP_PKEY_CTX");
1465
1466 if (sym_EVP_PKEY_keygen_init(ctx) <= 0)
1467 return log_openssl_errors("Failed to initialize EVP_PKEY_CTX");
1468
1469 if (sym_EVP_PKEY_CTX_set_ec_paramgen_curve_nid(ctx, curve_id) <= 0)
1470 return log_openssl_errors("Failed to set ECC curve %d", curve_id);
1471
1472 _cleanup_(EVP_PKEY_freep) EVP_PKEY *pkey = NULL;
1473 if (sym_EVP_PKEY_keygen(ctx, &pkey) <= 0)
1474 return log_openssl_errors("Failed to generate ECC key");
1475
1476 *ret = TAKE_PTR(pkey);
1477
1478 return 0;
1479 }
1480
1481 /* Perform ECDH to derive an ECC shared secret between the provided private key and public peer key. For two
1482 * keys, this will result in the same shared secret in either direction; ECDH using Alice's private key and
1483 * Bob's public (peer) key will result in the same shared secret as ECDH using Bob's private key and Alice's
1484 * public (peer) key. On success, this returns 0 and provides the shared secret; otherwise this returns an
1485 * error. */
1486 int ecc_ecdh(const EVP_PKEY *private_pkey,
1487 const EVP_PKEY *peer_pkey,
1488 void **ret_shared_secret,
1489 size_t *ret_shared_secret_size) {
1490
1491 int r;
1492
1493 assert(private_pkey);
1494 assert(peer_pkey);
1495 assert(ret_shared_secret);
1496 assert(ret_shared_secret_size);
1497
1498 r = dlopen_libcrypto(LOG_DEBUG);
1499 if (r < 0)
1500 return r;
1501
1502 _cleanup_(EVP_PKEY_CTX_freep) EVP_PKEY_CTX *ctx = sym_EVP_PKEY_CTX_new((EVP_PKEY*) private_pkey, NULL);
1503 if (!ctx)
1504 return log_openssl_errors("Failed to create new EVP_PKEY_CTX");
1505
1506 if (sym_EVP_PKEY_derive_init(ctx) <= 0)
1507 return log_openssl_errors("Failed to initialize EVP_PKEY_CTX");
1508
1509 if (sym_EVP_PKEY_derive_set_peer(ctx, (EVP_PKEY*) peer_pkey) <= 0)
1510 return log_openssl_errors("Failed to set ECC derive peer");
1511
1512 size_t shared_secret_size;
1513 if (sym_EVP_PKEY_derive(ctx, NULL, &shared_secret_size) <= 0)
1514 return log_openssl_errors("Failed to get ECC shared secret size");
1515
1516 _cleanup_(erase_and_freep) void *shared_secret = malloc(shared_secret_size);
1517 if (!shared_secret)
1518 return log_oom_debug();
1519
1520 if (sym_EVP_PKEY_derive(ctx, (unsigned char*) shared_secret, &shared_secret_size) <= 0)
1521 return log_openssl_errors("Failed to derive ECC shared secret");
1522
1523 *ret_shared_secret = TAKE_PTR(shared_secret);
1524 *ret_shared_secret_size = shared_secret_size;
1525
1526 return 0;
1527 }
1528
1529 int pubkey_fingerprint(EVP_PKEY *pk, const EVP_MD *md, void **ret, size_t *ret_size) {
1530 _cleanup_(EVP_MD_CTX_freep) EVP_MD_CTX* m = NULL;
1531 _cleanup_free_ void *d = NULL, *h = NULL;
1532 int sz, lsz, msz;
1533 unsigned umsz;
1534 unsigned char *dd;
1535 int r;
1536
1537 /* Calculates a message digest of the DER encoded public key */
1538
1539 assert(pk);
1540 assert(md);
1541 assert(ret);
1542 assert(ret_size);
1543
1544 r = dlopen_libcrypto(LOG_DEBUG);
1545 if (r < 0)
1546 return r;
1547
1548 sz = sym_i2d_PublicKey(pk, NULL);
1549 if (sz < 0)
1550 return log_openssl_errors("Unable to convert public key to DER format");
1551
1552 dd = d = malloc(sz);
1553 if (!d)
1554 return log_oom_debug();
1555
1556 lsz = sym_i2d_PublicKey(pk, &dd);
1557 if (lsz < 0)
1558 return log_openssl_errors("Unable to convert public key to DER format");
1559
1560 m = sym_EVP_MD_CTX_new();
1561 if (!m)
1562 return log_openssl_errors("Failed to create new EVP_MD_CTX");
1563
1564 if (sym_EVP_DigestInit_ex(m, md, NULL) != 1)
1565 return log_openssl_errors("Failed to initialize %s context", sym_EVP_MD_get0_name(md));
1566
1567 if (sym_EVP_DigestUpdate(m, d, lsz) != 1)
1568 return log_openssl_errors("Failed to run %s context", sym_EVP_MD_get0_name(md));
1569
1570 msz = sym_EVP_MD_get_size(md);
1571 assert(msz > 0);
1572
1573 h = malloc(msz);
1574 if (!h)
1575 return log_oom_debug();
1576
1577 umsz = msz;
1578 if (sym_EVP_DigestFinal_ex(m, h, &umsz) != 1)
1579 return log_openssl_errors("Failed to finalize hash context");
1580
1581 assert(umsz == (unsigned) msz);
1582
1583 *ret = TAKE_PTR(h);
1584 *ret_size = msz;
1585
1586 return 0;
1587 }
1588
1589 int digest_and_sign(
1590 const EVP_MD *md,
1591 EVP_PKEY *privkey,
1592 const void *data, size_t size,
1593 void **ret, size_t *ret_size) {
1594
1595 int r;
1596
1597 assert(privkey);
1598 assert(ret);
1599 assert(ret_size);
1600
1601 r = dlopen_libcrypto(LOG_DEBUG);
1602 if (r < 0)
1603 return r;
1604
1605 if (size == 0)
1606 data = ""; /* make sure to pass a valid pointer to OpenSSL */
1607 else {
1608 assert(data);
1609
1610 if (size == SIZE_MAX) /* If SIZE_MAX input is a string whose size we determine automatically */
1611 size = strlen(data);
1612 }
1613
1614 _cleanup_(EVP_MD_CTX_freep) EVP_MD_CTX* mdctx = sym_EVP_MD_CTX_new();
1615 if (!mdctx)
1616 return log_openssl_errors("Failed to create new EVP_MD_CTX");
1617
1618 if (sym_EVP_DigestSignInit(mdctx, NULL, md, NULL, privkey) != 1) {
1619 /* Distro security policies often disable support for SHA-1. Let's return a recognizable
1620 * error for that case. */
1621 bool invalid_digest = ERR_GET_REASON(sym_ERR_peek_last_error()) == EVP_R_INVALID_DIGEST;
1622 r = log_openssl_errors("Failed to initialize signature context");
1623 return invalid_digest ? -EADDRNOTAVAIL : r;
1624 }
1625
1626 /* Determine signature size */
1627 size_t ss;
1628 if (sym_EVP_DigestSign(mdctx, NULL, &ss, data, size) != 1)
1629 return log_openssl_errors("Failed to determine size of signature");
1630
1631 _cleanup_free_ void *sig = malloc(ss);
1632 if (!sig)
1633 return log_oom_debug();
1634
1635 if (sym_EVP_DigestSign(mdctx, sig, &ss, data, size) != 1)
1636 return log_openssl_errors("Failed to sign data");
1637
1638 *ret = TAKE_PTR(sig);
1639 *ret_size = ss;
1640 return 0;
1641 }
1642
1643 int pkcs7_new(X509 *certificate, EVP_PKEY *private_key, const char *hash_algorithm, PKCS7 **ret_p7, PKCS7_SIGNER_INFO **ret_si) {
1644 int r;
1645
1646 assert(certificate);
1647 assert(ret_p7);
1648
1649 /* This function sets up a new PKCS7 signing context. If a private key is provided, the context is
1650 * set up for "in-band" signing with PKCS7_dataFinal(). If a private key is not provided, the context
1651 * is set up for "out-of-band" signing, meaning the signature has to be provided by the user and
1652 * copied into the signer info's "enc_digest" field. If the signing hash algorithm is not provided,
1653 * SHA-256 is used. */
1654
1655 r = dlopen_libcrypto(LOG_DEBUG);
1656 if (r < 0)
1657 return r;
1658
1659 _cleanup_(PKCS7_freep) PKCS7 *p7 = sym_PKCS7_new();
1660 if (!p7)
1661 return log_oom();
1662
1663 if (sym_PKCS7_set_type(p7, NID_pkcs7_signed) == 0)
1664 return log_debug_errno(SYNTHETIC_ERRNO(EIO), "Failed to set PKCS7 type: %s",
1665 sym_ERR_error_string(sym_ERR_get_error(), NULL));
1666
1667 if (sym_PKCS7_content_new(p7, NID_pkcs7_data) == 0)
1668 return log_debug_errno(SYNTHETIC_ERRNO(EIO), "Failed to set PKCS7 content: %s",
1669 sym_ERR_error_string(sym_ERR_get_error(), NULL));
1670
1671 if (sym_PKCS7_add_certificate(p7, certificate) == 0)
1672 return log_debug_errno(SYNTHETIC_ERRNO(EIO), "Failed to set PKCS7 certificate: %s",
1673 sym_ERR_error_string(sym_ERR_get_error(), NULL));
1674
1675 int x509_pknid = 0;
1676 if (sym_X509_get_signature_info(certificate, NULL, &x509_pknid, NULL, NULL) == 0)
1677 return log_debug_errno(SYNTHETIC_ERRNO(EIO), "Failed to get X509 digest NID: %s",
1678 sym_ERR_error_string(sym_ERR_get_error(), NULL));
1679
1680 const EVP_MD *md = sym_EVP_get_digestbyname(hash_algorithm ?: "SHA256");
1681 if (!md)
1682 return log_debug_errno(SYNTHETIC_ERRNO(EIO), "Failed to get digest algorithm '%s'",
1683 hash_algorithm ?: "SHA256");
1684
1685 _cleanup_(PKCS7_SIGNER_INFO_freep) PKCS7_SIGNER_INFO *si = sym_PKCS7_SIGNER_INFO_new();
1686 if (!si)
1687 return log_oom();
1688
1689 if (private_key) {
1690 if (sym_PKCS7_SIGNER_INFO_set(si, certificate, private_key, md) <= 0)
1691 return log_debug_errno(SYNTHETIC_ERRNO(EIO), "Failed to configure signer info: %s",
1692 sym_ERR_error_string(sym_ERR_get_error(), NULL));
1693 } else {
1694 if (sym_ASN1_INTEGER_set(si->version, 1) == 0)
1695 return log_debug_errno(SYNTHETIC_ERRNO(EIO), "Failed to set signer info version: %s",
1696 sym_ERR_error_string(sym_ERR_get_error(), NULL));
1697
1698 if (sym_X509_NAME_set(&si->issuer_and_serial->issuer, sym_X509_get_issuer_name(certificate)) == 0)
1699 return log_debug_errno(SYNTHETIC_ERRNO(EIO), "Failed to set signer info issuer: %s",
1700 sym_ERR_error_string(sym_ERR_get_error(), NULL));
1701
1702 sym_ASN1_INTEGER_free(si->issuer_and_serial->serial);
1703 si->issuer_and_serial->serial = sym_ASN1_INTEGER_dup(sym_X509_get0_serialNumber(certificate));
1704 if (!si->issuer_and_serial->serial)
1705 return log_debug_errno(SYNTHETIC_ERRNO(EIO), "Failed to set signer info serial: %s",
1706 sym_ERR_error_string(sym_ERR_get_error(), NULL));
1707
1708 if (sym_X509_ALGOR_set0(si->digest_alg, sym_OBJ_nid2obj(sym_EVP_MD_get_type(md)), V_ASN1_NULL, NULL) == 0)
1709 return log_debug_errno(SYNTHETIC_ERRNO(EIO), "Failed to set signer info digest algorithm: %s",
1710 sym_ERR_error_string(sym_ERR_get_error(), NULL));
1711
1712 if (sym_X509_ALGOR_set0(si->digest_enc_alg, sym_OBJ_nid2obj(x509_pknid), V_ASN1_NULL, NULL) == 0)
1713 return log_debug_errno(SYNTHETIC_ERRNO(EIO), "Failed to set signer info signing algorithm: %s",
1714 sym_ERR_error_string(sym_ERR_get_error(), NULL));
1715 }
1716
1717 if (sym_PKCS7_add_signer(p7, si) == 0)
1718 return log_debug_errno(SYNTHETIC_ERRNO(EIO), "Failed to set PKCS7 signer info: %s",
1719 sym_ERR_error_string(sym_ERR_get_error(), NULL));
1720
1721 *ret_p7 = TAKE_PTR(p7);
1722 if (ret_si)
1723 /* We do not pass ownership here, 'si' object remains owned by 'p7' object. */
1724 *ret_si = si;
1725
1726 TAKE_PTR(si);
1727
1728 return 0;
1729 }
1730
1731 int string_hashsum(
1732 const char *s,
1733 size_t len,
1734 const char *md_algorithm,
1735 char **ret) {
1736
1737 _cleanup_free_ void *hash = NULL;
1738 size_t hash_size;
1739 _cleanup_free_ char *enc = NULL;
1740 int r;
1741
1742 assert(s || len == 0);
1743 assert(md_algorithm);
1744 assert(ret);
1745
1746 r = openssl_digest(md_algorithm, s, len, &hash, &hash_size);
1747 if (r < 0)
1748 return r;
1749
1750 enc = hexmem(hash, hash_size);
1751 if (!enc)
1752 return -ENOMEM;
1753
1754 *ret = TAKE_PTR(enc);
1755 return 0;
1756 }
1757
1758 static int ecc_pkey_generate_volume_keys(
1759 EVP_PKEY *pkey,
1760 void **ret_decrypted_key,
1761 size_t *ret_decrypted_key_size,
1762 void **ret_saved_key,
1763 size_t *ret_saved_key_size) {
1764
1765 assert(ret_decrypted_key);
1766 assert(ret_decrypted_key_size);
1767 assert(ret_saved_key);
1768 assert(ret_saved_key_size);
1769
1770 _cleanup_(EVP_PKEY_freep) EVP_PKEY *pkey_new = NULL;
1771 _cleanup_(erase_and_freep) void *decrypted_key = NULL;
1772 _cleanup_free_ unsigned char *saved_key = NULL;
1773 size_t decrypted_key_size, saved_key_size;
1774 int r;
1775
1776 _cleanup_free_ char *curve_name = NULL;
1777 size_t len = 0;
1778
1779 r = dlopen_libcrypto(LOG_DEBUG);
1780 if (r < 0)
1781 return r;
1782
1783 if (sym_EVP_PKEY_get_group_name(pkey, NULL, 0, &len) != 1 || len == 0)
1784 return log_openssl_errors("Failed to determine PKEY group name length");
1785
1786 len++;
1787 curve_name = new(char, len);
1788 if (!curve_name)
1789 return log_oom_debug();
1790
1791 if (sym_EVP_PKEY_get_group_name(pkey, curve_name, len, &len) != 1)
1792 return log_openssl_errors("Failed to get PKEY group name");
1793
1794 r = ecc_pkey_new(sym_OBJ_sn2nid(curve_name), &pkey_new);
1795 if (r < 0)
1796 return log_debug_errno(r, "Failed to generate a new EC keypair: %m");
1797
1798 r = ecc_ecdh(pkey_new, pkey, &decrypted_key, &decrypted_key_size);
1799 if (r < 0)
1800 return log_debug_errno(r, "Failed to derive shared secret: %m");
1801
1802 /* EVP_PKEY_get1_encoded_public_key() always returns uncompressed format of EC points.
1803 See https://github.com/openssl/openssl/discussions/22835 */
1804 saved_key_size = sym_EVP_PKEY_get1_encoded_public_key(pkey_new, &saved_key);
1805 if (saved_key_size == 0)
1806 return log_openssl_errors("Failed to convert the generated public key to SEC1 format");
1807
1808 *ret_decrypted_key = TAKE_PTR(decrypted_key);
1809 *ret_decrypted_key_size = decrypted_key_size;
1810 *ret_saved_key = TAKE_PTR(saved_key);
1811 *ret_saved_key_size = saved_key_size;
1812 return 0;
1813 }
1814
1815 static int rsa_pkey_generate_volume_keys(
1816 EVP_PKEY *pkey,
1817 const char *digest_alg,
1818 void **ret_decrypted_key,
1819 size_t *ret_decrypted_key_size,
1820 void **ret_saved_key,
1821 size_t *ret_saved_key_size) {
1822
1823 _cleanup_(erase_and_freep) void *decrypted_key = NULL;
1824 _cleanup_free_ void *saved_key = NULL;
1825 size_t decrypted_key_size, saved_key_size;
1826 int r;
1827
1828 assert(digest_alg);
1829 assert(ret_decrypted_key);
1830 assert(ret_decrypted_key_size);
1831 assert(ret_saved_key);
1832 assert(ret_saved_key_size);
1833
1834 r = rsa_pkey_to_suitable_key_size(pkey, &decrypted_key_size);
1835 if (r < 0)
1836 return log_debug_errno(r, "Failed to determine RSA public key size.");
1837
1838 log_debug("Generating %zu bytes random key.", decrypted_key_size);
1839
1840 decrypted_key = malloc(decrypted_key_size);
1841 if (!decrypted_key)
1842 return log_oom_debug();
1843
1844 r = crypto_random_bytes(decrypted_key, decrypted_key_size);
1845 if (r < 0)
1846 return log_debug_errno(r, "Failed to generate random key: %m");
1847
1848 r = rsa_oaep_encrypt_bytes(
1849 pkey,
1850 digest_alg,
1851 /* label= */ NULL, /* matches PKCS#11 CKZ_DATA_SPECIFIED with empty source */
1852 decrypted_key, decrypted_key_size,
1853 &saved_key, &saved_key_size);
1854 if (r < 0)
1855 return log_debug_errno(r, "Failed to RSA-OAEP encrypt random key: %m");
1856
1857 *ret_decrypted_key = TAKE_PTR(decrypted_key);
1858 *ret_decrypted_key_size = decrypted_key_size;
1859 *ret_saved_key = TAKE_PTR(saved_key);
1860 *ret_saved_key_size = saved_key_size;
1861 return 0;
1862 }
1863
1864 int pkey_generate_volume_keys(
1865 EVP_PKEY *pkey,
1866 const char *rsa_oaep_digest_alg,
1867 void **ret_decrypted_key,
1868 size_t *ret_decrypted_key_size,
1869 void **ret_saved_key,
1870 size_t *ret_saved_key_size) {
1871
1872 int r;
1873
1874 assert(pkey);
1875 assert(ret_decrypted_key);
1876 assert(ret_decrypted_key_size);
1877 assert(ret_saved_key);
1878 assert(ret_saved_key_size);
1879
1880 r = dlopen_libcrypto(LOG_DEBUG);
1881 if (r < 0)
1882 return r;
1883
1884 int type = sym_EVP_PKEY_get_base_id(pkey);
1885 switch (type) {
1886
1887 case EVP_PKEY_RSA:
1888 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);
1889
1890 case EVP_PKEY_EC:
1891 return ecc_pkey_generate_volume_keys(pkey, ret_decrypted_key, ret_decrypted_key_size, ret_saved_key, ret_saved_key_size);
1892
1893 case NID_undef:
1894 return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "Failed to determine a type of public key.");
1895
1896 default:
1897 return log_debug_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "Unsupported public key type: %s", sym_OBJ_nid2sn(type));
1898 }
1899 }
1900
1901 static int load_key_from_provider(
1902 const char *provider,
1903 const char *private_key_uri,
1904 UI_METHOD *ui_method,
1905 EVP_PKEY **ret) {
1906
1907 int r;
1908
1909 assert(provider);
1910 assert(private_key_uri);
1911 assert(ret);
1912
1913 r = dlopen_libcrypto(LOG_DEBUG);
1914 if (r < 0)
1915 return r;
1916
1917 /* Load the provider so that this can work without any custom written configuration in /etc/.
1918 * Also load the 'default' as that seems to be the recommendation. */
1919 if (!sym_OSSL_PROVIDER_try_load(/* ctx= */ NULL, provider, /* retain_fallbacks= */ true))
1920 return log_openssl_errors("Failed to load OpenSSL provider '%s'", provider);
1921 if (!sym_OSSL_PROVIDER_try_load(/* ctx= */ NULL, "default", /* retain_fallbacks= */ true))
1922 return log_openssl_errors("Failed to load OpenSSL provider 'default'");
1923
1924 _cleanup_(OSSL_STORE_closep) OSSL_STORE_CTX *store = sym_OSSL_STORE_open(
1925 private_key_uri,
1926 ui_method,
1927 /* ui_data= */ NULL,
1928 /* post_process= */ NULL,
1929 /* post_process_data= */ NULL);
1930 if (!store)
1931 return log_openssl_errors("Failed to open OpenSSL store via '%s'", private_key_uri);
1932
1933 if (sym_OSSL_STORE_expect(store, OSSL_STORE_INFO_PKEY) == 0)
1934 return log_openssl_errors("Failed to filter store by private keys");
1935
1936 _cleanup_(OSSL_STORE_INFO_freep) OSSL_STORE_INFO *info = sym_OSSL_STORE_load(store);
1937 if (!info)
1938 return log_openssl_errors("Failed to load OpenSSL store via '%s'", private_key_uri);
1939
1940 _cleanup_(EVP_PKEY_freep) EVP_PKEY *private_key = sym_OSSL_STORE_INFO_get1_PKEY(info);
1941 if (!private_key)
1942 return log_openssl_errors("Failed to load private key via '%s'", private_key_uri);
1943
1944 *ret = TAKE_PTR(private_key);
1945
1946 return 0;
1947 }
1948
1949 static int load_key_from_engine(const char *engine, const char *private_key_uri, UI_METHOD *ui_method, EVP_PKEY **ret) {
1950 #if !defined(OPENSSL_NO_ENGINE) && !defined(OPENSSL_NO_DEPRECATED_3_0)
1951 int r;
1952 #endif
1953
1954 assert(engine);
1955 assert(private_key_uri);
1956 assert(ret);
1957
1958 #if !defined(OPENSSL_NO_ENGINE) && !defined(OPENSSL_NO_DEPRECATED_3_0)
1959 r = dlopen_libcrypto(LOG_DEBUG);
1960 if (r < 0)
1961 return r;
1962
1963 DISABLE_WARNING_DEPRECATED_DECLARATIONS;
1964 _cleanup_(ENGINE_freep) ENGINE *e = sym_ENGINE_by_id(engine);
1965 if (!e)
1966 return log_openssl_errors("Failed to load signing engine '%s'", engine);
1967
1968 if (sym_ENGINE_init(e) == 0)
1969 return log_openssl_errors("Failed to initialize signing engine '%s'", engine);
1970
1971 _cleanup_(EVP_PKEY_freep) EVP_PKEY *private_key = sym_ENGINE_load_private_key(e, private_key_uri, ui_method, /* callback_data= */ NULL);
1972 if (!private_key)
1973 return log_openssl_errors("Failed to load private key from '%s'", private_key_uri);
1974 REENABLE_WARNING;
1975
1976 *ret = TAKE_PTR(private_key);
1977
1978 return 0;
1979 #else
1980 return -EOPNOTSUPP;
1981 #endif
1982 }
1983
1984 #ifndef OPENSSL_NO_UI_CONSOLE
1985 static int openssl_ask_password_ui_read(UI *ui, UI_STRING *uis) {
1986 int r;
1987
1988 switch(sym_UI_get_string_type(uis)) {
1989 case UIT_PROMPT: {
1990 /* If no ask password request was configured use the default openssl UI. */
1991 AskPasswordRequest *req = (AskPasswordRequest*) sym_UI_method_get_ex_data(sym_UI_get_method(ui), 0);
1992 if (!req)
1993 return (sym_UI_method_get_reader(sym_UI_OpenSSL()))(ui, uis);
1994
1995 req->message = sym_UI_get0_output_string(uis);
1996
1997 _cleanup_strv_free_ char **l = NULL;
1998 r = ask_password_auto(req, ASK_PASSWORD_ACCEPT_CACHED|ASK_PASSWORD_PUSH_CACHE, &l);
1999 if (r < 0) {
2000 log_error_errno(r, "Failed to query for PIN: %m");
2001 return 0;
2002 }
2003
2004 if (strv_length(l) != 1) {
2005 log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Expected only a single password/pin.");
2006 return 0;
2007 }
2008
2009 if (sym_UI_set_result(ui, uis, *l) != 0) {
2010 log_openssl_errors("Failed to set user interface result");
2011 return 0;
2012 }
2013
2014 return 1;
2015 }
2016 default:
2017 return (sym_UI_method_get_reader(sym_UI_OpenSSL()))(ui, uis);
2018 }
2019 }
2020 #endif
2021
2022 static int openssl_load_private_key_from_file(const char *path, EVP_PKEY **ret) {
2023 _cleanup_(erase_and_freep) char *rawkey = NULL;
2024 _cleanup_(BIO_freep) BIO *kb = NULL;
2025 _cleanup_(EVP_PKEY_freep) EVP_PKEY *pk = NULL;
2026 size_t rawkeysz;
2027 int r;
2028
2029 assert(path);
2030 assert(ret);
2031
2032 r = dlopen_libcrypto(LOG_DEBUG);
2033 if (r < 0)
2034 return r;
2035
2036 r = read_full_file_full(
2037 AT_FDCWD, path, UINT64_MAX, SIZE_MAX,
2038 READ_FULL_FILE_SECURE|READ_FULL_FILE_WARN_WORLD_READABLE|READ_FULL_FILE_CONNECT_SOCKET,
2039 NULL,
2040 &rawkey, &rawkeysz);
2041 if (r < 0)
2042 return log_debug_errno(r, "Failed to read key file '%s': %m", path);
2043
2044 kb = sym_BIO_new_mem_buf(rawkey, rawkeysz);
2045 if (!kb)
2046 return log_oom_debug();
2047
2048 pk = sym_PEM_read_bio_PrivateKey(kb, NULL, NULL, NULL);
2049 if (!pk)
2050 return log_debug_errno(SYNTHETIC_ERRNO(EIO), "Failed to parse PEM private key: %s",
2051 sym_ERR_error_string(sym_ERR_get_error(), NULL));
2052
2053 *ret = TAKE_PTR(pk);
2054
2055 return 0;
2056 }
2057
2058 static int openssl_ask_password_ui_new(const AskPasswordRequest *request, OpenSSLAskPasswordUI **ret) {
2059 #ifndef OPENSSL_NO_UI_CONSOLE
2060 int r;
2061 #endif
2062
2063 assert(request);
2064 assert(ret);
2065
2066 #ifndef OPENSSL_NO_UI_CONSOLE
2067 r = dlopen_libcrypto(LOG_DEBUG);
2068 if (r < 0)
2069 return r;
2070
2071 _cleanup_(UI_destroy_methodp) UI_METHOD *method = sym_UI_create_method("systemd-ask-password");
2072 if (!method)
2073 return log_openssl_errors("Failed to initialize openssl user interface");
2074
2075 if (sym_UI_method_set_reader(method, openssl_ask_password_ui_read) != 0)
2076 return log_openssl_errors("Failed to set openssl user interface reader");
2077
2078 OpenSSLAskPasswordUI *ui = new(OpenSSLAskPasswordUI, 1);
2079 if (!ui)
2080 return log_oom_debug();
2081
2082 *ui = (OpenSSLAskPasswordUI) {
2083 .method = TAKE_PTR(method),
2084 .request = *request,
2085 };
2086
2087 sym_UI_set_default_method(ui->method);
2088
2089 if (sym_UI_method_set_ex_data(ui->method, 0, &ui->request) == 0)
2090 return log_openssl_errors("Failed to set extra data for UI method");
2091
2092 *ret = TAKE_PTR(ui);
2093 return 0;
2094 #else
2095 return -EOPNOTSUPP;
2096 #endif
2097 }
2098
2099 static int load_x509_certificate_from_file(const char *path, X509 **ret) {
2100 _cleanup_free_ char *rawcert = NULL;
2101 _cleanup_(X509_freep) X509 *cert = NULL;
2102 _cleanup_(BIO_freep) BIO *cb = NULL;
2103 size_t rawcertsz;
2104 int r;
2105
2106 assert(path);
2107 assert(ret);
2108
2109 r = dlopen_libcrypto(LOG_DEBUG);
2110 if (r < 0)
2111 return r;
2112
2113 r = read_full_file_full(
2114 AT_FDCWD, path, UINT64_MAX, SIZE_MAX,
2115 READ_FULL_FILE_CONNECT_SOCKET,
2116 NULL,
2117 &rawcert, &rawcertsz);
2118 if (r < 0)
2119 return log_debug_errno(r, "Failed to read certificate file '%s': %m", path);
2120
2121 cb = sym_BIO_new_mem_buf(rawcert, rawcertsz);
2122 if (!cb)
2123 return log_oom_debug();
2124
2125 cert = sym_PEM_read_bio_X509(cb, NULL, NULL, NULL);
2126 if (!cert)
2127 return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG), "Failed to parse X.509 certificate: %s",
2128 sym_ERR_error_string(sym_ERR_get_error(), NULL));
2129
2130 *ret = TAKE_PTR(cert);
2131
2132 return 0;
2133 }
2134
2135 static int load_x509_certificate_from_provider(const char *provider, const char *certificate_uri, X509 **ret) {
2136 int r;
2137
2138 assert(provider);
2139 assert(certificate_uri);
2140 assert(ret);
2141
2142 r = dlopen_libcrypto(LOG_DEBUG);
2143 if (r < 0)
2144 return r;
2145
2146 /* Load the provider so that this can work without any custom written configuration in /etc/.
2147 * Also load the 'default' as that seems to be the recommendation. */
2148 if (!sym_OSSL_PROVIDER_try_load(/* ctx= */ NULL, provider, /* retain_fallbacks= */ true))
2149 return log_openssl_errors("Failed to load OpenSSL provider '%s'", provider);
2150 if (!sym_OSSL_PROVIDER_try_load(/* ctx= */ NULL, "default", /* retain_fallbacks= */ true))
2151 return log_openssl_errors("Failed to load OpenSSL provider 'default'");
2152
2153 _cleanup_(OSSL_STORE_closep) OSSL_STORE_CTX *store = sym_OSSL_STORE_open(
2154 certificate_uri,
2155 /* ui_method= */ NULL,
2156 /* ui_method= */ NULL,
2157 /* post_process= */ NULL,
2158 /* post_process_data= */ NULL);
2159 if (!store)
2160 return log_openssl_errors("Failed to open OpenSSL store via '%s'", certificate_uri);
2161
2162 if (sym_OSSL_STORE_expect(store, OSSL_STORE_INFO_CERT) == 0)
2163 return log_openssl_errors("Failed to filter store by X.509 certificates");
2164
2165 _cleanup_(OSSL_STORE_INFO_freep) OSSL_STORE_INFO *info = sym_OSSL_STORE_load(store);
2166 if (!info)
2167 return log_openssl_errors("Failed to load OpenSSL store via '%s'", certificate_uri);
2168
2169 _cleanup_(X509_freep) X509 *cert = sym_OSSL_STORE_INFO_get1_CERT(info);
2170 if (!cert)
2171 return log_openssl_errors("Failed to load certificate via '%s'", certificate_uri);
2172
2173 *ret = TAKE_PTR(cert);
2174
2175 return 0;
2176 }
2177
2178 OpenSSLAskPasswordUI* openssl_ask_password_ui_free(OpenSSLAskPasswordUI *ui) {
2179 if (!ui)
2180 return NULL;
2181
2182 #ifndef OPENSSL_NO_UI_CONSOLE
2183 assert(sym_UI_get_default_method() == ui->method);
2184 sym_UI_set_default_method(sym_UI_OpenSSL());
2185 sym_UI_destroy_method(ui->method);
2186 #endif
2187 return mfree(ui);
2188 }
2189
2190 int x509_fingerprint(X509 *cert, uint8_t buffer[static SHA256_DIGEST_SIZE]) {
2191 _cleanup_free_ uint8_t *der = NULL;
2192 int dersz, r;
2193
2194 assert(cert);
2195
2196 r = dlopen_libcrypto(LOG_DEBUG);
2197 if (r < 0)
2198 return r;
2199
2200 dersz = sym_i2d_X509(cert, &der);
2201 if (dersz < 0)
2202 return log_openssl_errors("Unable to convert PEM certificate to DER format");
2203
2204 sha256_direct(der, dersz, buffer);
2205 return 0;
2206 }
2207
2208 int openssl_load_x509_certificate(
2209 CertificateSourceType certificate_source_type,
2210 const char *certificate_source,
2211 const char *certificate,
2212 X509 **ret) {
2213
2214 int r;
2215
2216 assert(certificate);
2217
2218 switch (certificate_source_type) {
2219
2220 case OPENSSL_CERTIFICATE_SOURCE_FILE:
2221 r = load_x509_certificate_from_file(certificate, ret);
2222 break;
2223 case OPENSSL_CERTIFICATE_SOURCE_PROVIDER:
2224 r = load_x509_certificate_from_provider(certificate_source, certificate, ret);
2225 break;
2226 default:
2227 assert_not_reached();
2228 }
2229 if (r < 0)
2230 return log_debug_errno(
2231 r,
2232 "Failed to load certificate '%s' from OpenSSL certificate source %s: %m",
2233 certificate,
2234 certificate_source);
2235
2236 return 0;
2237 }
2238
2239 int openssl_load_private_key(
2240 KeySourceType private_key_source_type,
2241 const char *private_key_source,
2242 const char *private_key,
2243 const AskPasswordRequest *request,
2244 EVP_PKEY **ret_private_key,
2245 OpenSSLAskPasswordUI **ret_user_interface) {
2246
2247 int r;
2248
2249 /* The caller must keep the OpenSSLAskPasswordUI object alive as long as the EVP_PKEY object so that
2250 * the user can enter any needed hardware token pin to unlock the private key when needed. */
2251
2252 assert(private_key);
2253 assert(request);
2254 assert(ret_private_key);
2255 assert(ret_user_interface);
2256
2257 if (private_key_source_type == OPENSSL_KEY_SOURCE_FILE) {
2258 r = openssl_load_private_key_from_file(private_key, ret_private_key);
2259 if (r < 0)
2260 return r;
2261
2262 *ret_user_interface = NULL;
2263 } else {
2264 _cleanup_(openssl_ask_password_ui_freep) OpenSSLAskPasswordUI *ui = NULL;
2265 r = openssl_ask_password_ui_new(request, &ui);
2266 if (r < 0)
2267 return log_debug_errno(r, "Failed to allocate ask-password user interface: %m");
2268
2269 UI_METHOD *ui_method = NULL;
2270 #ifndef OPENSSL_NO_UI_CONSOLE
2271 ui_method = ui->method;
2272 #endif
2273
2274 switch (private_key_source_type) {
2275
2276 case OPENSSL_KEY_SOURCE_ENGINE:
2277 r = load_key_from_engine(private_key_source, private_key, ui_method, ret_private_key);
2278 break;
2279 case OPENSSL_KEY_SOURCE_PROVIDER:
2280 r = load_key_from_provider(private_key_source, private_key, ui_method, ret_private_key);
2281 break;
2282 default:
2283 assert_not_reached();
2284 }
2285 if (r < 0)
2286 return log_debug_errno(
2287 r,
2288 "Failed to load key '%s' from OpenSSL private key source %s: %m",
2289 private_key,
2290 private_key_source);
2291
2292 *ret_user_interface = TAKE_PTR(ui);
2293 }
2294
2295 return 0;
2296 }
2297
2298 int openssl_extract_public_key(EVP_PKEY *private_key, EVP_PKEY **ret) {
2299 int r;
2300
2301 assert(private_key);
2302 assert(ret);
2303
2304 r = dlopen_libcrypto(LOG_DEBUG);
2305 if (r < 0)
2306 return r;
2307
2308 _cleanup_(memstream_done) MemStream m = {};
2309 FILE *tf = memstream_init(&m);
2310 if (!tf)
2311 return -ENOMEM;
2312
2313 if (sym_i2d_PUBKEY_fp(tf, private_key) != 1)
2314 return -EIO;
2315
2316 _cleanup_(erase_and_freep) char *buf = NULL;
2317 size_t len;
2318 r = memstream_finalize(&m, &buf, &len);
2319 if (r < 0)
2320 return r;
2321
2322 const unsigned char *t = (const unsigned char*) buf;
2323 if (!sym_d2i_PUBKEY(ret, &t, len))
2324 return -EIO;
2325
2326 return 0;
2327 }
2328 #endif
2329
2330 int parse_openssl_certificate_source_argument(
2331 const char *argument,
2332 char **certificate_source,
2333 CertificateSourceType *certificate_source_type) {
2334
2335 CertificateSourceType type;
2336 const char *e = NULL;
2337 int r;
2338
2339 assert(argument);
2340 assert(certificate_source);
2341 assert(certificate_source_type);
2342
2343 if (streq(argument, "file"))
2344 type = OPENSSL_CERTIFICATE_SOURCE_FILE;
2345 else if ((e = startswith(argument, "provider:")))
2346 type = OPENSSL_CERTIFICATE_SOURCE_PROVIDER;
2347 else
2348 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid certificate source '%s'", argument);
2349
2350 r = free_and_strdup_warn(certificate_source, e);
2351 if (r < 0)
2352 return r;
2353
2354 *certificate_source_type = type;
2355
2356 return 0;
2357 }
2358
2359 int parse_openssl_key_source_argument(
2360 const char *argument,
2361 char **private_key_source,
2362 KeySourceType *private_key_source_type) {
2363
2364 KeySourceType type;
2365 const char *e = NULL;
2366 int r;
2367
2368 assert(argument);
2369 assert(private_key_source);
2370 assert(private_key_source_type);
2371
2372 if (streq(argument, "file"))
2373 type = OPENSSL_KEY_SOURCE_FILE;
2374 else if ((e = startswith(argument, "engine:")))
2375 type = OPENSSL_KEY_SOURCE_ENGINE;
2376 else if ((e = startswith(argument, "provider:")))
2377 type = OPENSSL_KEY_SOURCE_PROVIDER;
2378 else
2379 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid private key source '%s'", argument);
2380
2381 r = free_and_strdup_warn(private_key_source, e);
2382 if (r < 0)
2383 return r;
2384
2385 *private_key_source_type = type;
2386
2387 return 0;
2388 }