diff --git a/man/systemd-cryptenroll.xml b/man/systemd-cryptenroll.xml
index 041337ab8a..e6bbe2be63 100644
--- a/man/systemd-cryptenroll.xml
+++ b/man/systemd-cryptenroll.xml
@@ -314,10 +314,10 @@
URI
Enroll a PKCS#11 security token or smartcard (e.g. a YubiKey). Expects a PKCS#11 URI
- that allows to find an X.509 certificate on the token. The URI must also be suitable to find
- a related private key after changing the type of object in it. Alternatively the special value
- auto may be specified, in order to automatically determine the suitable URI if
- a single security token containing a single key pair is plugged in. The special value
+ that allows to find an X.509 certificate or a public key on the token. The URI must also be suitable
+ to find a related private key after changing the type of object in it. Alternatively the special
+ value auto may be specified, in order to automatically determine the suitable URI
+ if a single security token containing a single key pair is plugged in. The special value
list may be used to enumerate all suitable PKCS#11 tokens currently plugged in.
diff --git a/src/basic/memory-util.c b/src/basic/memory-util.c
index fcedae2d41..ed6024fa4a 100644
--- a/src/basic/memory-util.c
+++ b/src/basic/memory-util.c
@@ -39,3 +39,19 @@ bool memeqbyte(uint8_t byte, const void *data, size_t length) {
/* Now we know first 16 bytes match, memcmp() with self. */
return memcmp(data, p + 16, length) == 0;
}
+
+void *memdup_reverse(const void *mem, size_t size) {
+ assert(mem);
+ assert(size != 0);
+
+ void *p = malloc(size);
+ if (!p)
+ return NULL;
+
+ uint8_t *p_dst = p;
+ const uint8_t *p_src = mem;
+ for (size_t i = 0, k = size; i < size; i++, k--)
+ p_dst[i] = p_src[k-1];
+
+ return p;
+}
diff --git a/src/basic/memory-util.h b/src/basic/memory-util.h
index 11795135f9..294aed67df 100644
--- a/src/basic/memory-util.h
+++ b/src/basic/memory-util.h
@@ -107,3 +107,6 @@ static inline void erase_and_freep(void *p) {
static inline void erase_char(char *p) {
explicit_bzero_safe(p, sizeof(char));
}
+
+/* Makes a copy of the buffer with reversed order of bytes */
+void *memdup_reverse(const void *mem, size_t size);
diff --git a/src/cryptenroll/cryptenroll-pkcs11.c b/src/cryptenroll/cryptenroll-pkcs11.c
index ea969102cb..6b70a147c3 100644
--- a/src/cryptenroll/cryptenroll-pkcs11.c
+++ b/src/cryptenroll/cryptenroll-pkcs11.c
@@ -43,7 +43,7 @@ int enroll_pkcs11(
_cleanup_free_ char *keyslot_as_string = NULL, *private_uri = NULL;
size_t decrypted_key_size, saved_key_size;
_cleanup_free_ void *saved_key = NULL;
- _cleanup_(X509_freep) X509 *cert = NULL;
+ _cleanup_(EVP_PKEY_freep) EVP_PKEY *pkey = NULL;
ssize_t base64_encoded_size;
const char *node;
int r;
@@ -55,11 +55,11 @@ int enroll_pkcs11(
assert_se(node = crypt_get_device_name(cd));
- r = pkcs11_acquire_certificate(uri, "volume enrollment operation", "drive-harddisk", &cert, NULL);
+ r = pkcs11_acquire_public_key(uri, "volume enrollment operation", "drive-harddisk", &pkey, NULL);
if (r < 0)
return r;
- r = x509_generate_volume_keys(cert, &decrypted_key, &decrypted_key_size, &saved_key, &saved_key_size);
+ r = pkey_generate_volume_keys(pkey, &decrypted_key, &decrypted_key_size, &saved_key, &saved_key_size);
if (r < 0)
return log_error_errno(r, "Failed to generate volume keys: %m");
@@ -86,8 +86,9 @@ int enroll_pkcs11(
if (asprintf(&keyslot_as_string, "%i", keyslot) < 0)
return log_oom();
- /* Change 'type=cert' in the provided URI to 'type=private' before storing in a LUKS2 header.
- This allows users to use output of some PKCS#11 tools directly without modifications. */
+ /* Change 'type=cert' or 'type=public' in the provided URI to 'type=private' before storing in
+ a LUKS2 header. This allows users to use output of some PKCS#11 tools directly without
+ modifications. */
r = uri_set_private_class(uri, &private_uri);
if (r < 0)
return r;
diff --git a/src/home/homectl-pkcs11.c b/src/home/homectl-pkcs11.c
index 6ae291ed93..5c54ec016e 100644
--- a/src/home/homectl-pkcs11.c
+++ b/src/home/homectl-pkcs11.c
@@ -10,6 +10,87 @@
#include "pkcs11-util.h"
#include "strv.h"
+int identity_add_token_pin(JsonVariant **v, const char *pin) {
+ _cleanup_(json_variant_unrefp) JsonVariant *w = NULL, *l = NULL;
+ _cleanup_strv_free_erase_ char **pins = NULL;
+ int r;
+
+ assert(v);
+
+ if (isempty(pin))
+ return 0;
+
+ w = json_variant_ref(json_variant_by_key(*v, "secret"));
+ l = json_variant_ref(json_variant_by_key(w, "tokenPin"));
+
+ r = json_variant_strv(l, &pins);
+ if (r < 0)
+ return log_error_errno(r, "Failed to convert PIN array: %m");
+
+ if (strv_contains(pins, pin))
+ return 0;
+
+ r = strv_extend(&pins, pin);
+ if (r < 0)
+ return log_oom();
+
+ strv_uniq(pins);
+
+ l = json_variant_unref(l);
+
+ r = json_variant_new_array_strv(&l, pins);
+ if (r < 0)
+ return log_error_errno(r, "Failed to allocate new PIN array JSON: %m");
+
+ json_variant_sensitive(l);
+
+ r = json_variant_set_field(&w, "tokenPin", l);
+ if (r < 0)
+ return log_error_errno(r, "Failed to update PIN field: %m");
+
+ r = json_variant_set_field(v, "secret", w);
+ if (r < 0)
+ return log_error_errno(r, "Failed to update secret object: %m");
+
+ return 1;
+}
+
+#if HAVE_P11KIT
+
+static int add_pkcs11_token_uri(JsonVariant **v, const char *uri) {
+ _cleanup_(json_variant_unrefp) JsonVariant *w = NULL;
+ _cleanup_strv_free_ char **l = NULL;
+ int r;
+
+ assert(v);
+ assert(uri);
+
+ w = json_variant_ref(json_variant_by_key(*v, "pkcs11TokenUri"));
+ if (w) {
+ r = json_variant_strv(w, &l);
+ if (r < 0)
+ return log_error_errno(r, "Failed to parse PKCS#11 token list: %m");
+
+ if (strv_contains(l, uri))
+ return 0;
+ }
+
+ r = strv_extend(&l, uri);
+ if (r < 0)
+ return log_oom();
+
+ w = json_variant_unref(w);
+ r = json_variant_new_array_strv(&w, l);
+ if (r < 0)
+ return log_error_errno(r, "Failed to create PKCS#11 token URI JSON: %m");
+
+ r = json_variant_set_field(v, "pkcs11TokenUri", w);
+ if (r < 0)
+ return log_error_errno(r, "Failed to update PKCS#11 token URI list: %m");
+
+ return 0;
+}
+
static int add_pkcs11_encrypted_key(
JsonVariant **v,
const char *uri,
@@ -63,113 +144,20 @@ static int add_pkcs11_encrypted_key(
return 0;
}
-static int add_pkcs11_token_uri(JsonVariant **v, const char *uri) {
- _cleanup_(json_variant_unrefp) JsonVariant *w = NULL;
- _cleanup_strv_free_ char **l = NULL;
- int r;
-
- assert(v);
- assert(uri);
-
- w = json_variant_ref(json_variant_by_key(*v, "pkcs11TokenUri"));
- if (w) {
- r = json_variant_strv(w, &l);
- if (r < 0)
- return log_error_errno(r, "Failed to parse PKCS#11 token list: %m");
-
- if (strv_contains(l, uri))
- return 0;
- }
-
- r = strv_extend(&l, uri);
- if (r < 0)
- return log_oom();
-
- w = json_variant_unref(w);
- r = json_variant_new_array_strv(&w, l);
- if (r < 0)
- return log_error_errno(r, "Failed to create PKCS#11 token URI JSON: %m");
-
- r = json_variant_set_field(v, "pkcs11TokenUri", w);
- if (r < 0)
- return log_error_errno(r, "Failed to update PKCS#11 token URI list: %m");
-
- return 0;
-}
-
-int identity_add_token_pin(JsonVariant **v, const char *pin) {
- _cleanup_(json_variant_unrefp) JsonVariant *w = NULL, *l = NULL;
- _cleanup_strv_free_erase_ char **pins = NULL;
- int r;
-
- assert(v);
-
- if (isempty(pin))
- return 0;
-
- w = json_variant_ref(json_variant_by_key(*v, "secret"));
- l = json_variant_ref(json_variant_by_key(w, "tokenPin"));
-
- r = json_variant_strv(l, &pins);
- if (r < 0)
- return log_error_errno(r, "Failed to convert PIN array: %m");
-
- if (strv_contains(pins, pin))
- return 0;
-
- r = strv_extend(&pins, pin);
- if (r < 0)
- return log_oom();
-
- strv_uniq(pins);
-
- l = json_variant_unref(l);
-
- r = json_variant_new_array_strv(&l, pins);
- if (r < 0)
- return log_error_errno(r, "Failed to allocate new PIN array JSON: %m");
-
- json_variant_sensitive(l);
-
- r = json_variant_set_field(&w, "tokenPin", l);
- if (r < 0)
- return log_error_errno(r, "Failed to update PIN field: %m");
-
- r = json_variant_set_field(v, "secret", w);
- if (r < 0)
- return log_error_errno(r, "Failed to update secret object: %m");
-
- return 1;
-}
-
-static int acquire_pkcs11_certificate(
- const char *uri,
- const char *askpw_friendly_name,
- const char *askpw_icon_name,
- X509 **ret_cert,
- char **ret_pin_used) {
-#if HAVE_P11KIT
- return pkcs11_acquire_certificate(uri, askpw_friendly_name, askpw_icon_name, ret_cert, ret_pin_used);
-#else
- return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP),
- "PKCS#11 tokens not supported on this build.");
-#endif
-}
-
int identity_add_pkcs11_key_data(JsonVariant **v, const char *uri) {
_cleanup_(erase_and_freep) void *decrypted_key = NULL, *saved_key = NULL;
_cleanup_(erase_and_freep) char *pin = NULL;
size_t decrypted_key_size, saved_key_size;
- _cleanup_(X509_freep) X509 *cert = NULL;
+ _cleanup_(EVP_PKEY_freep) EVP_PKEY *pkey = NULL;
int r;
assert(v);
- r = acquire_pkcs11_certificate(uri, "home directory operation", "user-home", &cert, &pin);
+ r = pkcs11_acquire_public_key(uri, "home directory operation", "user-home", &pkey, &pin);
if (r < 0)
return r;
- r = x509_generate_volume_keys(cert, &decrypted_key, &decrypted_key_size, &saved_key, &saved_key_size);
+ r = pkey_generate_volume_keys(pkey, &decrypted_key, &decrypted_key_size, &saved_key, &saved_key_size);
if (r < 0)
return log_error_errno(r, "Failed to generate volume keys: %m");
@@ -196,3 +184,5 @@ int identity_add_pkcs11_key_data(JsonVariant **v, const char *uri) {
return 0;
}
+
+#endif
diff --git a/src/home/homectl-pkcs11.h b/src/home/homectl-pkcs11.h
index 5c30feeed4..424777facd 100644
--- a/src/home/homectl-pkcs11.h
+++ b/src/home/homectl-pkcs11.h
@@ -5,7 +5,13 @@
int identity_add_token_pin(JsonVariant **v, const char *pin);
+#if HAVE_P11KIT
int identity_add_pkcs11_key_data(JsonVariant **v, const char *token_uri);
+#else
+static inline int identity_add_pkcs11_key_data(JsonVariant **v, const char *token_uri) {
+ return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "PKCS#11 tokens not supported on this build.");
+}
+#endif
int list_pkcs11_tokens(void);
int find_pkcs11_token_auto(char **ret);
diff --git a/src/shared/openssl-util.c b/src/shared/openssl-util.c
index d4a689cf85..6cd521623e 100644
--- a/src/shared/openssl-util.c
+++ b/src/shared/openssl-util.c
@@ -1,8 +1,11 @@
/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#include
+
#include "alloc-util.h"
#include "fd-util.h"
#include "hexdecoct.h"
+#include "memory-util.h"
#include "openssl-util.h"
#include "random-util.h"
#include "string-util.h"
@@ -624,19 +627,47 @@ int rsa_pkey_to_suitable_key_size(
return 0;
}
-/* Generate RSA public key from provided "n" and "e" values. Note that if "e" is a number (e.g. uint32_t), it
- * must be provided here big-endian, e.g. wrap it with htobe32(). */
+/* 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;
assert(n);
+ assert(n_size != 0);
assert(e);
+ assert(e_size != 0);
assert(ret);
- _cleanup_(EVP_PKEY_CTX_freep) EVP_PKEY_CTX *ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_RSA, NULL);
+#if OPENSSL_VERSION_MAJOR >= 3
+ _cleanup_(EVP_PKEY_CTX_freep) EVP_PKEY_CTX *ctx = EVP_PKEY_CTX_new_from_name(NULL, "RSA", NULL);
if (!ctx)
return log_openssl_errors("Failed to create new EVP_PKEY_CTX");
+ if (EVP_PKEY_fromdata_init(ctx) <= 0)
+ return log_openssl_errors("Failed to initialize EVP_PKEY_CTX");
+
+ OSSL_PARAM params[3];
+
+#if __BYTE_ORDER == __BIG_ENDIAN
+ params[0] = OSSL_PARAM_construct_BN(OSSL_PKEY_PARAM_RSA_N, (void*)n, n_size);
+ params[1] = OSSL_PARAM_construct_BN(OSSL_PKEY_PARAM_RSA_E, (void*)e, e_size);
+#else
+ _cleanup_free_ void *native_n = memdup_reverse(n, n_size);
+ if (!native_n)
+ return log_oom_debug();
+
+ _cleanup_free_ void *native_e = memdup_reverse(e, e_size);
+ if (!native_e)
+ return log_oom_debug();
+
+ params[0] = OSSL_PARAM_construct_BN(OSSL_PKEY_PARAM_RSA_N, native_n, n_size);
+ params[1] = OSSL_PARAM_construct_BN(OSSL_PKEY_PARAM_RSA_E, native_e, e_size);
+#endif
+ params[2] = OSSL_PARAM_construct_end();
+
+ if (EVP_PKEY_fromdata(ctx, &pkey, EVP_PKEY_PUBLIC_KEY, params) <= 0)
+ return log_openssl_errors("Failed to create RSA EVP_PKEY");
+#else
_cleanup_(BN_freep) BIGNUM *bn_n = BN_bin2bn(n, n_size, NULL);
if (!bn_n)
return log_openssl_errors("Failed to create BIGNUM for RSA n");
@@ -645,27 +676,6 @@ int rsa_pkey_from_n_e(const void *n, size_t n_size, const void *e, size_t e_size
if (!bn_e)
return log_openssl_errors("Failed to create BIGNUM for RSA e");
-#if OPENSSL_VERSION_MAJOR >= 3
- if (EVP_PKEY_fromdata_init(ctx) <= 0)
- return log_openssl_errors("Failed to initialize EVP_PKEY_CTX");
-
- _cleanup_(OSSL_PARAM_BLD_freep) OSSL_PARAM_BLD *bld = OSSL_PARAM_BLD_new();
- if (!bld)
- return log_openssl_errors("Failed to create new OSSL_PARAM_BLD");
-
- if (!OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_N, bn_n))
- return log_openssl_errors("Failed to set RSA OSSL_PKEY_PARAM_RSA_N");
-
- if (!OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_E, bn_e))
- return log_openssl_errors("Failed to set RSA OSSL_PKEY_PARAM_RSA_E");
-
- _cleanup_(OSSL_PARAM_freep) OSSL_PARAM *params = OSSL_PARAM_BLD_to_param(bld);
- if (!params)
- return log_openssl_errors("Failed to build RSA OSSL_PARAM");
-
- if (EVP_PKEY_fromdata(ctx, &pkey, EVP_PKEY_PUBLIC_KEY, params) <= 0)
- return log_openssl_errors("Failed to create RSA EVP_PKEY");
-#else
_cleanup_(RSA_freep) RSA *rsa_key = RSA_new();
if (!rsa_key)
return log_openssl_errors("Failed to create new RSA");
@@ -1255,23 +1265,19 @@ static int rsa_pkey_generate_volume_keys(
return 0;
}
-int x509_generate_volume_keys(
- X509 *cert,
+int pkey_generate_volume_keys(
+ EVP_PKEY *pkey,
void **ret_decrypted_key,
size_t *ret_decrypted_key_size,
void **ret_saved_key,
size_t *ret_saved_key_size) {
- assert(cert);
+ assert(pkey);
assert(ret_decrypted_key);
assert(ret_decrypted_key_size);
assert(ret_saved_key);
assert(ret_saved_key_size);
- EVP_PKEY *pkey = X509_get0_pubkey(cert);
- if (!pkey)
- return log_openssl_errors("Failed to extract public key from X.509 certificate.");
-
#if OPENSSL_VERSION_MAJOR >= 3
int type = EVP_PKEY_get_base_id(pkey);
#else
diff --git a/src/shared/openssl-util.h b/src/shared/openssl-util.h
index 2ca3e8c1ce..1a9055af01 100644
--- a/src/shared/openssl-util.h
+++ b/src/shared/openssl-util.h
@@ -40,6 +40,7 @@ DEFINE_TRIVIAL_CLEANUP_FUNC_FULL(PKCS7*, PKCS7_free, NULL);
DEFINE_TRIVIAL_CLEANUP_FUNC_FULL(SSL*, SSL_free, NULL);
DEFINE_TRIVIAL_CLEANUP_FUNC_FULL(BIO*, BIO_free, NULL);
DEFINE_TRIVIAL_CLEANUP_FUNC_FULL(EVP_MD_CTX*, EVP_MD_CTX_free, NULL);
+DEFINE_TRIVIAL_CLEANUP_FUNC_FULL(ASN1_OCTET_STRING*, ASN1_OCTET_STRING_free, NULL);
#if OPENSSL_VERSION_MAJOR >= 3
DEFINE_TRIVIAL_CLEANUP_FUNC_FULL(EVP_CIPHER*, EVP_CIPHER_free, NULL);
DEFINE_TRIVIAL_CLEANUP_FUNC_FULL(EVP_KDF*, EVP_KDF_free, NULL);
@@ -108,7 +109,7 @@ int ecc_pkey_new(int curve_id, EVP_PKEY **ret);
int ecc_ecdh(const EVP_PKEY *private_pkey, const EVP_PKEY *peer_pkey, void **ret_shared_secret, size_t *ret_shared_secret_size);
-int x509_generate_volume_keys(X509 *cert, void **ret_decrypted_key, size_t *ret_decrypted_key_size, void **ret_saved_key, size_t *ret_saved_key_size);
+int pkey_generate_volume_keys(EVP_PKEY *pkey, void **ret_decrypted_key, size_t *ret_decrypted_key_size, void **ret_saved_key, size_t *ret_saved_key_size);
int pubkey_fingerprint(EVP_PKEY *pk, const EVP_MD *md, void **ret, size_t *ret_size);
diff --git a/src/shared/pkcs11-util.c b/src/shared/pkcs11-util.c
index 2f583f232e..a172f646ca 100644
--- a/src/shared/pkcs11-util.c
+++ b/src/shared/pkcs11-util.c
@@ -527,13 +527,294 @@ int pkcs11_token_find_x509_certificate(
}
#if HAVE_OPENSSL
+static int read_public_key_info(
+ CK_FUNCTION_LIST *m,
+ CK_SESSION_HANDLE session,
+ CK_OBJECT_HANDLE object,
+ EVP_PKEY **ret_pkey) {
+
+ CK_ATTRIBUTE attribute = { CKA_PUBLIC_KEY_INFO, NULL_PTR, 0 };
+ _cleanup_(EVP_PKEY_freep) EVP_PKEY *pkey = NULL;
+ CK_RV rv;
+
+ rv = m->C_GetAttributeValue(session, object, &attribute, 1);
+ if (rv != CKR_OK)
+ return log_debug_errno(SYNTHETIC_ERRNO(EINVAL),
+ "Failed to get size of CKA_PUBLIC_KEY_INFO: %s", sym_p11_kit_strerror(rv));
+
+ if (attribute.ulValueLen == 0)
+ return log_debug_errno(SYNTHETIC_ERRNO(ENOENT), "CKA_PUBLIC_KEY_INFO is empty");
+
+ _cleanup_free_ void *buffer = malloc(attribute.ulValueLen);
+ if (!buffer)
+ return log_oom_debug();
+
+ attribute.pValue = buffer;
+
+ rv = m->C_GetAttributeValue(session, object, &attribute, 1);
+ if (rv != CKR_OK)
+ return log_debug_errno(SYNTHETIC_ERRNO(EIO),
+ "Failed to read CKA_PUBLIC_KEY_INFO: %s", sym_p11_kit_strerror(rv));
+
+ const unsigned char *value = attribute.pValue;
+ pkey = d2i_PUBKEY(NULL, &value, attribute.ulValueLen);
+ if (!pkey)
+ return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG), "Failed to parse CKA_PUBLIC_KEY_INFO");
+
+ *ret_pkey = TAKE_PTR(pkey);
+ return 0;
+}
+
+int pkcs11_token_read_public_key(
+ CK_FUNCTION_LIST *m,
+ CK_SESSION_HANDLE session,
+ CK_OBJECT_HANDLE object,
+ EVP_PKEY **ret_pkey) {
+
+ _cleanup_(EVP_PKEY_freep) EVP_PKEY *pkey = NULL;
+ CK_RV rv;
+ int r;
+
+ r = read_public_key_info(m, session, object, &pkey);
+ if (r >= 0) {
+ *ret_pkey = TAKE_PTR(pkey);
+ return 0;
+ }
+
+ CK_KEY_TYPE key_type;
+ CK_ATTRIBUTE attribute = { CKA_KEY_TYPE, &key_type, sizeof(key_type) };
+
+ rv = m->C_GetAttributeValue(session, object, &attribute, 1);
+ if (rv != CKR_OK)
+ return log_debug_errno(SYNTHETIC_ERRNO(EIO),
+ "Failed to get CKA_KEY_TYPE of a public key: %s", sym_p11_kit_strerror(rv));
+
+ switch (key_type) {
+ case CKK_RSA: {
+ CK_ATTRIBUTE rsa_attributes[] = {
+ { CKA_MODULUS, NULL_PTR, 0 },
+ { CKA_PUBLIC_EXPONENT, NULL_PTR, 0 },
+ };
+
+ rv = m->C_GetAttributeValue(session, object, rsa_attributes, ELEMENTSOF(rsa_attributes));
+ if (rv != CKR_OK)
+ return log_debug_errno(SYNTHETIC_ERRNO(EIO),
+ "Failed to get size of attributes of an RSA public key: %s", sym_p11_kit_strerror(rv));
+
+ if (rsa_attributes[0].ulValueLen == 0)
+ return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "An RSA public key has empty CKA_MODULUS.");
+
+ _cleanup_free_ void *modulus = malloc(rsa_attributes[0].ulValueLen);
+ if (!modulus)
+ return log_oom_debug();
+
+ rsa_attributes[0].pValue = modulus;
+
+ if (rsa_attributes[1].ulValueLen == 0)
+ return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "An RSA public key has empty CKA_PUBLIC_EXPONENT.");
+
+ _cleanup_free_ void *public_exponent = malloc(rsa_attributes[1].ulValueLen);
+ if (!public_exponent)
+ return log_oom_debug();
+
+ rsa_attributes[1].pValue = public_exponent;
+
+ rv = m->C_GetAttributeValue(session, object, rsa_attributes, ELEMENTSOF(rsa_attributes));
+ if (rv != CKR_OK)
+ return log_debug_errno(SYNTHETIC_ERRNO(EIO),
+ "Failed to get attributes of an RSA public key: %s", sym_p11_kit_strerror(rv));
+
+ size_t n_size = rsa_attributes[0].ulValueLen, e_size = rsa_attributes[1].ulValueLen;
+ r = rsa_pkey_from_n_e(rsa_attributes[0].pValue, n_size, rsa_attributes[1].pValue, e_size, &pkey);
+ if (r < 0)
+ return log_debug_errno(r, "Failed to create an EVP_PKEY from RSA parameters.");
+
+ break;
+ }
+ case CKK_EC: {
+ CK_ATTRIBUTE ec_attributes[] = {
+ { CKA_EC_PARAMS, NULL_PTR, 0 },
+ { CKA_EC_POINT, NULL_PTR, 0 },
+ };
+
+ rv = m->C_GetAttributeValue(session, object, ec_attributes, ELEMENTSOF(ec_attributes));
+ if (rv != CKR_OK)
+ return log_debug_errno(SYNTHETIC_ERRNO(EIO),
+ "Failed to get size of attributes of an EC public key: %s", sym_p11_kit_strerror(rv));
+
+ if (ec_attributes[0].ulValueLen == 0)
+ return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "An EC public key has empty CKA_EC_PARAMS.");
+
+ _cleanup_free_ void *ec_group = malloc(ec_attributes[0].ulValueLen);
+ if (!ec_group)
+ return log_oom_debug();
+
+ ec_attributes[0].pValue = ec_group;
+
+ if (ec_attributes[1].ulValueLen == 0)
+ return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "An EC public key has empty CKA_EC_POINT.");
+
+ _cleanup_free_ void *ec_point = malloc(ec_attributes[1].ulValueLen);
+ if (!ec_point)
+ return log_oom_debug();
+
+ ec_attributes[1].pValue = ec_point;
+
+ rv = m->C_GetAttributeValue(session, object, ec_attributes, ELEMENTSOF(ec_attributes));
+ if (rv != CKR_OK)
+ return log_debug_errno(SYNTHETIC_ERRNO(EIO),
+ "Failed to get attributes of an EC public key: %s", sym_p11_kit_strerror(rv));
+
+ _cleanup_(EC_GROUP_freep) EC_GROUP *group = NULL;
+ _cleanup_(ASN1_OCTET_STRING_freep) ASN1_OCTET_STRING *os = NULL;
+
+ const unsigned char *ec_params_value = ec_attributes[0].pValue;
+ group = d2i_ECPKParameters(NULL, &ec_params_value, ec_attributes[0].ulValueLen);
+ if (!group)
+ return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "Unable to decode CKA_EC_PARAMS.");
+
+ const unsigned char *ec_point_value = ec_attributes[1].pValue;
+ os = d2i_ASN1_OCTET_STRING(NULL, &ec_point_value, ec_attributes[1].ulValueLen);
+ if (!os)
+ return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "Unable to decode CKA_EC_POINT.");
+
+#if OPENSSL_VERSION_MAJOR >= 3
+ _cleanup_(EVP_PKEY_CTX_freep) EVP_PKEY_CTX *ctx = EVP_PKEY_CTX_new_from_name(NULL, "EC", NULL);
+ if (!ctx)
+ return log_debug_errno(SYNTHETIC_ERRNO(EIO), "Failed to create an EVP_PKEY_CTX for EC.");
+
+ if (EVP_PKEY_fromdata_init(ctx) != 1)
+ return log_debug_errno(SYNTHETIC_ERRNO(EIO), "Failed to init an EVP_PKEY_CTX for EC.");
+
+ OSSL_PARAM ec_params[8] = {
+ OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY, os->data, os->length)
+ };
+
+ _cleanup_free_ void *order = NULL, *p = NULL, *a = NULL, *b = NULL, *generator = NULL;
+ size_t order_size, p_size, a_size, b_size, generator_size;
+
+ int nid = EC_GROUP_get_curve_name(group);
+ if (nid != NID_undef) {
+ const char* name = OSSL_EC_curve_nid2name(nid);
+ ec_params[1] = OSSL_PARAM_construct_utf8_string(OSSL_PKEY_PARAM_GROUP_NAME, (char*)name, strlen(name));
+ ec_params[2] = OSSL_PARAM_construct_end();
+ } else {
+ const char *field_type = EC_GROUP_get_field_type(group) == NID_X9_62_prime_field ?
+ "prime-field" : "characteristic-two-field";
+
+ const BIGNUM *bn_order = EC_GROUP_get0_order(group);
+
+ _cleanup_(BN_CTX_freep) BN_CTX *bnctx = BN_CTX_new();
+ if (!bnctx)
+ return log_oom_debug();
+
+ _cleanup_(BN_freep) BIGNUM *bn_p = BN_new();
+ if (!bn_p)
+ return log_oom_debug();
+
+ _cleanup_(BN_freep) BIGNUM *bn_a = BN_new();
+ if (!bn_a)
+ return log_oom_debug();
+
+ _cleanup_(BN_freep) BIGNUM *bn_b = BN_new();
+ if (!bn_b)
+ return log_oom_debug();
+
+ if (EC_GROUP_get_curve(group, bn_p, bn_a, bn_b, bnctx) != 1)
+ return log_debug_errno(SYNTHETIC_ERRNO(EIO), "Failed to extract EC parameters from EC_GROUP.");
+
+ order_size = BN_num_bytes(bn_order);
+ p_size = BN_num_bytes(bn_p);
+ a_size = BN_num_bytes(bn_a);
+ b_size = BN_num_bytes(bn_b);
+
+ order = malloc(order_size);
+ if (!order)
+ return log_oom_debug();
+
+ p = malloc(p_size);
+ if (!p)
+ return log_oom_debug();
+
+ a = malloc(a_size);
+ if (!a)
+ return log_oom_debug();
+
+ b = malloc(b_size);
+ if (!b)
+ return log_oom_debug();
+
+ if (BN_bn2nativepad(bn_order, order, order_size) <= 0 ||
+ BN_bn2nativepad(bn_p, p, p_size) <= 0 ||
+ BN_bn2nativepad(bn_a, a, a_size) <= 0 ||
+ BN_bn2nativepad(bn_b, b, b_size) <= 0 )
+ return log_debug_errno(SYNTHETIC_ERRNO(EIO), "Failed to store EC parameters in native byte order.");
+
+ const EC_POINT *point_gen = EC_GROUP_get0_generator(group);
+ generator_size = EC_POINT_point2oct(group, point_gen, POINT_CONVERSION_UNCOMPRESSED, NULL, 0, bnctx);
+ if (generator_size == 0)
+ return log_debug_errno(SYNTHETIC_ERRNO(EIO), "Failed to determine size of a EC generator.");
+
+ generator = malloc(generator_size);
+ if (!generator)
+ return log_oom_debug();
+
+ generator_size = EC_POINT_point2oct(group, point_gen, POINT_CONVERSION_UNCOMPRESSED, generator, generator_size, bnctx);
+ if (generator_size == 0)
+ return log_debug_errno(SYNTHETIC_ERRNO(EIO), "Failed to convert a EC generator to octet string.");
+
+ ec_params[1] = OSSL_PARAM_construct_utf8_string(OSSL_PKEY_PARAM_EC_FIELD_TYPE, (char*)field_type, strlen(field_type));
+ ec_params[2] = OSSL_PARAM_construct_octet_string(OSSL_PKEY_PARAM_EC_GENERATOR, generator, generator_size);
+ ec_params[3] = OSSL_PARAM_construct_BN(OSSL_PKEY_PARAM_EC_ORDER, order, order_size);
+ ec_params[4] = OSSL_PARAM_construct_BN(OSSL_PKEY_PARAM_EC_P, p, p_size);
+ ec_params[5] = OSSL_PARAM_construct_BN(OSSL_PKEY_PARAM_EC_A, a, a_size);
+ ec_params[6] = OSSL_PARAM_construct_BN(OSSL_PKEY_PARAM_EC_B, b, b_size);
+ ec_params[7] = OSSL_PARAM_construct_end();
+ }
+
+ if (EVP_PKEY_fromdata(ctx, &pkey, EVP_PKEY_PUBLIC_KEY, ec_params) != 1)
+ return log_debug_errno(SYNTHETIC_ERRNO(EIO), "Failed to create EVP_PKEY from EC parameters.");
+#else
+ _cleanup_(EC_POINT_freep) EC_POINT *point = EC_POINT_new(group);
+ if (!point)
+ return log_oom_debug();
+
+ if (EC_POINT_oct2point(group, point, os->data, os->length, NULL) != 1)
+ return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "Unable to decode CKA_EC_POINT.");
+
+ _cleanup_(EC_KEY_freep) EC_KEY *ec_key = EC_KEY_new();
+ if (!ec_key)
+ return log_oom_debug();
+
+ if (EC_KEY_set_group(ec_key, group) != 1)
+ return log_debug_errno(SYNTHETIC_ERRNO(EIO), "Failed to set group for EC_KEY.");
+
+ if (EC_KEY_set_public_key(ec_key, point) != 1)
+ return log_debug_errno(SYNTHETIC_ERRNO(EIO), "Failed to set public key for EC_KEY.");
+
+ pkey = EVP_PKEY_new();
+ if (!pkey)
+ return log_oom_debug();
+
+ if (EVP_PKEY_set1_EC_KEY(pkey, ec_key) != 1)
+ return log_debug_errno(SYNTHETIC_ERRNO(EIO), "Failed to assign EC_KEY to EVP_PKEY.");
+#endif
+ break;
+ }
+ default:
+ return log_debug_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "Unsupported type of public key: %lu", key_type);
+ }
+
+ *ret_pkey = TAKE_PTR(pkey);
+ return 0;
+}
+
int pkcs11_token_read_x509_certificate(
CK_FUNCTION_LIST *m,
CK_SESSION_HANDLE session,
CK_OBJECT_HANDLE object,
X509 **ret_cert) {
- _cleanup_free_ void *buffer = NULL;
_cleanup_free_ char *t = NULL;
CK_ATTRIBUTE attribute = {
.type = CKA_VALUE
@@ -541,7 +822,6 @@ int pkcs11_token_read_x509_certificate(
CK_RV rv;
_cleanup_(X509_freep) X509 *x509 = NULL;
X509_NAME *name = NULL;
- const unsigned char *p;
int r;
r = dlopen_p11kit();
@@ -550,32 +830,32 @@ int pkcs11_token_read_x509_certificate(
rv = m->C_GetAttributeValue(session, object, &attribute, 1);
if (rv != CKR_OK)
- return log_error_errno(SYNTHETIC_ERRNO(EIO),
+ return log_debug_errno(SYNTHETIC_ERRNO(EIO),
"Failed to read X.509 certificate size off token: %s", sym_p11_kit_strerror(rv));
- buffer = malloc(attribute.ulValueLen);
+ _cleanup_free_ void *buffer = malloc(attribute.ulValueLen);
if (!buffer)
- return log_oom();
+ return log_oom_debug();
attribute.pValue = buffer;
rv = m->C_GetAttributeValue(session, object, &attribute, 1);
if (rv != CKR_OK)
- return log_error_errno(SYNTHETIC_ERRNO(EIO),
+ return log_debug_errno(SYNTHETIC_ERRNO(EIO),
"Failed to read X.509 certificate data off token: %s", sym_p11_kit_strerror(rv));
- p = attribute.pValue;
+ const unsigned char *p = attribute.pValue;
x509 = d2i_X509(NULL, &p, attribute.ulValueLen);
if (!x509)
- return log_error_errno(SYNTHETIC_ERRNO(EBADMSG), "Failed parse X.509 certificate.");
+ return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG), "Failed to parse X.509 certificate.");
name = X509_get_subject_name(x509);
if (!name)
- return log_error_errno(SYNTHETIC_ERRNO(EBADMSG), "Failed to acquire X.509 subject name.");
+ return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG), "Failed to acquire X.509 subject name.");
t = X509_NAME_oneline(name, NULL, 0);
if (!t)
- return log_error_errno(SYNTHETIC_ERRNO(EIO), "Failed to format X.509 subject name as string.");
+ return log_debug_errno(SYNTHETIC_ERRNO(EIO), "Failed to format X.509 subject name as string.");
log_debug("Using X.509 certificate issued for '%s'.", t);
@@ -1360,20 +1640,20 @@ int pkcs11_find_token(
}
#if HAVE_OPENSSL
-struct pkcs11_acquire_certificate_callback_data {
+struct pkcs11_acquire_public_key_callback_data {
char *pin_used;
- X509 *cert;
+ EVP_PKEY *pkey;
const char *askpw_friendly_name, *askpw_icon_name;
AskPasswordFlags askpw_flags;
bool headless;
};
-static void pkcs11_acquire_certificate_callback_data_release(struct pkcs11_acquire_certificate_callback_data *data) {
+static void pkcs11_acquire_public_key_callback_data_release(struct pkcs11_acquire_public_key_callback_data *data) {
erase_and_free(data->pin_used);
- X509_free(data->cert);
+ EVP_PKEY_free(data->pkey);
}
-static int pkcs11_acquire_certificate_callback(
+static int pkcs11_acquire_public_key_callback(
CK_FUNCTION_LIST *m,
CK_SESSION_HANDLE session,
CK_SLOT_ID slot_id,
@@ -1383,8 +1663,16 @@ static int pkcs11_acquire_certificate_callback(
void *userdata) {
_cleanup_(erase_and_freep) char *pin_used = NULL;
- struct pkcs11_acquire_certificate_callback_data *data = ASSERT_PTR(userdata);
- CK_OBJECT_HANDLE object;
+ _cleanup_(EVP_PKEY_freep) EVP_PKEY *pkey = NULL;
+ CK_OBJECT_CLASS class;
+ CK_CERTIFICATE_TYPE type;
+ CK_ATTRIBUTE candidate_attributes[] = {
+ { CKA_CLASS, &class, sizeof(class) },
+ { CKA_CERTIFICATE_TYPE, &type, sizeof(type) },
+ };
+ CK_OBJECT_HANDLE candidate, public_key = CK_INVALID_HANDLE, certificate = CK_INVALID_HANDLE;
+ uint8_t n_public_keys = 0, n_certificates = 0;
+ CK_RV rv;
int r;
assert(m);
@@ -1392,6 +1680,8 @@ static int pkcs11_acquire_certificate_callback(
assert(token_info);
assert(uri);
+ struct pkcs11_acquire_public_key_callback_data *data = ASSERT_PTR(userdata);
+
/* Called for every token matching our URI */
r = pkcs11_token_login(
@@ -1410,40 +1700,141 @@ static int pkcs11_acquire_certificate_callback(
if (r < 0)
return r;
- r = pkcs11_token_find_x509_certificate(m, session, uri, &object);
- if (r < 0)
- return r;
+ CK_ULONG n_attributes;
+ CK_ATTRIBUTE *attributes = sym_p11_kit_uri_get_attributes(uri, &n_attributes);
+ for (CK_ULONG i = 0; i < n_attributes; i++) {
+ switch (attributes[i].type) {
+ case CKA_CLASS: {
+ CK_OBJECT_CLASS requested_class = *((CK_OBJECT_CLASS*) attributes[i].pValue);
+ if (requested_class != CKO_PUBLIC_KEY && requested_class != CKO_CERTIFICATE)
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
+ "Selected PKCS#11 object is not a public key or certificate, refusing.");
+ break;
+ }
- r = pkcs11_token_read_x509_certificate(m, session, object, &data->cert);
- if (r < 0)
- return r;
+ case CKA_CERTIFICATE_TYPE: {
+ CK_CERTIFICATE_TYPE requested_type = *((CK_CERTIFICATE_TYPE*) attributes[i].pValue);
+ if (requested_type != CKC_X_509)
+ return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "Selected PKCS#11 object is not an X.509 certificate, refusing.");
+ break;
+ }}
+ }
+ rv = m->C_FindObjectsInit(session, attributes, n_attributes);
+ if (rv != CKR_OK)
+ return log_error_errno(SYNTHETIC_ERRNO(EIO),
+ "Failed to initialize object find call: %s", sym_p11_kit_strerror(rv));
+
+ for (;;) {
+ CK_ULONG n;
+ rv = m->C_FindObjects(session, &candidate, 1, &n);
+ if (rv != CKR_OK)
+ return log_error_errno(SYNTHETIC_ERRNO(EIO),
+ "Failed to find objects: %s", sym_p11_kit_strerror(rv));
+
+ if (n == 0)
+ break;
+
+ candidate_attributes[0].ulValueLen = sizeof(class);
+ candidate_attributes[1].ulValueLen = sizeof(type);
+ rv = m->C_GetAttributeValue(session, candidate, candidate_attributes, ELEMENTSOF(candidate_attributes));
+ if (rv != CKR_OK && rv != CKR_ATTRIBUTE_TYPE_INVALID)
+ return log_error_errno(SYNTHETIC_ERRNO(EIO),
+ "Failed to get attributes of a selected candidate: %s", sym_p11_kit_strerror(rv));
+
+ if (candidate_attributes[0].ulValueLen == CK_UNAVAILABLE_INFORMATION) {
+ log_debug("Failed to get CKA_CLASS of a selected candidate");
+ continue;
+ }
+
+ if (class == CKO_PUBLIC_KEY) {
+ n_public_keys++;
+ if (n_public_keys > 1)
+ break;
+ public_key = candidate;
+ continue;
+ }
+
+ if (class == CKO_CERTIFICATE) {
+ if (candidate_attributes[1].ulValueLen == CK_UNAVAILABLE_INFORMATION) {
+ log_debug("Failed to get CKA_CERTIFICATE_TYPE of a selected candidate");
+ continue;
+ }
+ if (type != CKC_X_509)
+ continue;
+ n_certificates++;
+ if (n_certificates > 1)
+ break;
+ certificate = candidate;
+ continue;
+ }
+ }
+
+ rv = m->C_FindObjectsFinal(session);
+ if (rv != CKR_OK)
+ return log_error_errno(SYNTHETIC_ERRNO(EIO),
+ "Failed to finalize object find call: %s", sym_p11_kit_strerror(rv));
+
+ if (n_public_keys == 0 && n_certificates == 0)
+ return log_error_errno(SYNTHETIC_ERRNO(ENOENT),
+ "Failed to find selected public key or X.509 certificate.");
+
+ if (n_public_keys > 1)
+ return log_error_errno(SYNTHETIC_ERRNO(ENOTUNIQ),
+ "Provided URI matches multiple public keys, refusing.");
+
+ if (n_certificates > 1)
+ return log_error_errno(SYNTHETIC_ERRNO(ENOTUNIQ),
+ "Provided URI matches multiple certificates, refusing.");
+
+ if (n_public_keys != 0) {
+ r = pkcs11_token_read_public_key(m, session, public_key, &pkey);
+ if (r >= 0)
+ goto success;
+ }
+
+ if (n_certificates == 0)
+ return log_error_errno(r, "Failed to read a found public key.");
+
+ {
+ _cleanup_(X509_freep) X509 *cert = NULL;
+
+ r = pkcs11_token_read_x509_certificate(m, session, certificate, &cert);
+ if (r < 0)
+ return log_error_errno(r, "Failed to read a found X.509 certificate.");
+
+ pkey = X509_get_pubkey(cert);
+ if (!pkey)
+ return log_error_errno(SYNTHETIC_ERRNO(EIO), "Failed to extract public key from X.509 certificate.");
+ }
+success:
/* Let's read some random data off the token and write it to the kernel pool before we generate our
* random key from it. This way we can claim the quality of the RNG is at least as good as the
* kernel's and the token's pool */
(void) pkcs11_token_acquire_rng(m, session);
data->pin_used = TAKE_PTR(pin_used);
- return 1;
+ data->pkey = TAKE_PTR(pkey);
+ return 0;
}
-int pkcs11_acquire_certificate(
+int pkcs11_acquire_public_key(
const char *uri,
const char *askpw_friendly_name,
const char *askpw_icon_name,
- X509 **ret_cert,
+ EVP_PKEY **ret_pkey,
char **ret_pin_used) {
- _cleanup_(pkcs11_acquire_certificate_callback_data_release) struct pkcs11_acquire_certificate_callback_data data = {
+ _cleanup_(pkcs11_acquire_public_key_callback_data_release) struct pkcs11_acquire_public_key_callback_data data = {
.askpw_friendly_name = askpw_friendly_name,
.askpw_icon_name = askpw_icon_name,
};
int r;
assert(uri);
- assert(ret_cert);
+ assert(ret_pkey);
- r = pkcs11_find_token(uri, pkcs11_acquire_certificate_callback, &data);
+ r = pkcs11_find_token(uri, pkcs11_acquire_public_key_callback, &data);
if (r == -EAGAIN) /* pkcs11_find_token() doesn't log about this error, but all others */
return log_error_errno(SYNTHETIC_ERRNO(ENXIO),
"Specified PKCS#11 token with URI '%s' not found.",
@@ -1451,11 +1842,9 @@ int pkcs11_acquire_certificate(
if (r < 0)
return r;
- *ret_cert = TAKE_PTR(data.cert);
-
+ *ret_pkey = TAKE_PTR(data.pkey);
if (ret_pin_used)
*ret_pin_used = TAKE_PTR(data.pin_used);
-
return 0;
}
#endif
diff --git a/src/shared/pkcs11-util.h b/src/shared/pkcs11-util.h
index d901bbea91..838f90b6c1 100644
--- a/src/shared/pkcs11-util.h
+++ b/src/shared/pkcs11-util.h
@@ -2,6 +2,7 @@
#pragma once
#if HAVE_OPENSSL
+# include
# include
#endif
#include
@@ -57,6 +58,7 @@ int pkcs11_token_login(CK_FUNCTION_LIST *m, CK_SESSION_HANDLE session, CK_SLOT_I
int pkcs11_token_find_related_object(CK_FUNCTION_LIST *m, CK_SESSION_HANDLE session, CK_OBJECT_HANDLE prototype, CK_OBJECT_CLASS class, CK_OBJECT_HANDLE *ret_object);
int pkcs11_token_find_x509_certificate(CK_FUNCTION_LIST *m, CK_SESSION_HANDLE session, P11KitUri *search_uri, CK_OBJECT_HANDLE *ret_object);
#if HAVE_OPENSSL
+int pkcs11_token_read_public_key(CK_FUNCTION_LIST *m, CK_SESSION_HANDLE session, CK_OBJECT_HANDLE object, EVP_PKEY **ret_pkey);
int pkcs11_token_read_x509_certificate(CK_FUNCTION_LIST *m, CK_SESSION_HANDLE session, CK_OBJECT_HANDLE object, X509 **ret_cert);
#endif
@@ -69,7 +71,7 @@ typedef int (*pkcs11_find_token_callback_t)(CK_FUNCTION_LIST *m, CK_SESSION_HAND
int pkcs11_find_token(const char *pkcs11_uri, pkcs11_find_token_callback_t callback, void *userdata);
#if HAVE_OPENSSL
-int pkcs11_acquire_certificate(const char *uri, const char *askpw_friendly_name, const char *askpw_icon_name, X509 **ret_cert, char **ret_pin_used);
+int pkcs11_acquire_public_key(const char *uri, const char *askpw_friendly_name, const char *askpw_icon_name, EVP_PKEY **ret_pkey, char **ret_pin_used);
#endif
typedef struct {
diff --git a/test/TEST-24-CRYPTSETUP/test.sh b/test/TEST-24-CRYPTSETUP/test.sh
index cfb746a4db..757c39a449 100755
--- a/test/TEST-24-CRYPTSETUP/test.sh
+++ b/test/TEST-24-CRYPTSETUP/test.sh
@@ -145,6 +145,10 @@ EOF
mkdir -p "$initdir/etc/systemd/system/systemd-cryptsetup@.service.d"
cat >"$initdir/etc/systemd/system/systemd-cryptsetup@.service.d/PKCS11.conf" <