1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
10 #include "sd-device.h"
12 #include "alloc-util.h"
13 #include "ask-password-api.h"
14 #include "cryptsetup-fido2.h"
15 #include "cryptsetup-keyfile.h"
16 #include "cryptsetup-pkcs11.h"
17 #include "cryptsetup-tpm2.h"
18 #include "cryptsetup-util.h"
19 #include "device-util.h"
25 #include "fstab-util.h"
26 #include "hexdecoct.h"
27 #include "libfido2-util.h"
29 #include "main-func.h"
30 #include "memory-util.h"
31 #include "mount-util.h"
32 #include "nulstr-util.h"
33 #include "parse-util.h"
34 #include "path-util.h"
35 #include "pkcs11-util.h"
36 #include "pretty-print.h"
37 #include "process-util.h"
38 #include "random-util.h"
39 #include "string-table.h"
41 #include "tpm2-util.h"
44 #define ANY_LUKS "LUKS"
45 /* as in src/cryptsetup.h */
46 #define CRYPT_SECTOR_SIZE 512U
47 #define CRYPT_MAX_SECTOR_SIZE 4096U
49 typedef enum PassphraseType
{
51 PASSPHRASE_REGULAR
= 1 << 0,
52 PASSPHRASE_RECOVERY_KEY
= 1 << 1,
53 PASSPHRASE_BOTH
= PASSPHRASE_REGULAR
|PASSPHRASE_RECOVERY_KEY
,
55 _PASSPHRASE_TYPE_INVALID
= -1,
58 static const char *arg_type
= NULL
; /* ANY_LUKS, CRYPT_LUKS1, CRYPT_LUKS2, CRYPT_TCRYPT, CRYPT_BITLK or CRYPT_PLAIN */
59 static char *arg_cipher
= NULL
;
60 static unsigned arg_key_size
= 0;
61 static unsigned arg_sector_size
= CRYPT_SECTOR_SIZE
;
62 static int arg_key_slot
= CRYPT_ANY_SLOT
;
63 static unsigned arg_keyfile_size
= 0;
64 static uint64_t arg_keyfile_offset
= 0;
65 static bool arg_keyfile_erase
= false;
66 static bool arg_try_empty_password
= false;
67 static char *arg_hash
= NULL
;
68 static char *arg_header
= NULL
;
69 static unsigned arg_tries
= 3;
70 static bool arg_readonly
= false;
71 static bool arg_verify
= false;
72 static AskPasswordFlags arg_ask_password_flags
= 0;
73 static bool arg_discards
= false;
74 static bool arg_same_cpu_crypt
= false;
75 static bool arg_submit_from_crypt_cpus
= false;
76 static bool arg_no_read_workqueue
= false;
77 static bool arg_no_write_workqueue
= false;
78 static bool arg_tcrypt_hidden
= false;
79 static bool arg_tcrypt_system
= false;
80 static bool arg_tcrypt_veracrypt
= false;
81 static char **arg_tcrypt_keyfiles
= NULL
;
82 static uint64_t arg_offset
= 0;
83 static uint64_t arg_skip
= 0;
84 static usec_t arg_timeout
= USEC_INFINITY
;
85 static char *arg_pkcs11_uri
= NULL
;
86 static bool arg_pkcs11_uri_auto
= false;
87 static char *arg_fido2_device
= NULL
;
88 static bool arg_fido2_device_auto
= false;
89 static void *arg_fido2_cid
= NULL
;
90 static size_t arg_fido2_cid_size
= 0;
91 static char *arg_fido2_rp_id
= NULL
;
92 static char *arg_tpm2_device
= NULL
;
93 static bool arg_tpm2_device_auto
= false;
94 static uint32_t arg_tpm2_pcr_mask
= UINT32_MAX
;
95 static char *arg_tpm2_signature
= NULL
;
96 static bool arg_tpm2_pin
= false;
97 static bool arg_headless
= false;
98 static usec_t arg_token_timeout_usec
= 30*USEC_PER_SEC
;
100 STATIC_DESTRUCTOR_REGISTER(arg_cipher
, freep
);
101 STATIC_DESTRUCTOR_REGISTER(arg_hash
, freep
);
102 STATIC_DESTRUCTOR_REGISTER(arg_header
, freep
);
103 STATIC_DESTRUCTOR_REGISTER(arg_tcrypt_keyfiles
, strv_freep
);
104 STATIC_DESTRUCTOR_REGISTER(arg_pkcs11_uri
, freep
);
105 STATIC_DESTRUCTOR_REGISTER(arg_fido2_device
, freep
);
106 STATIC_DESTRUCTOR_REGISTER(arg_fido2_cid
, freep
);
107 STATIC_DESTRUCTOR_REGISTER(arg_fido2_rp_id
, freep
);
108 STATIC_DESTRUCTOR_REGISTER(arg_tpm2_device
, freep
);
109 STATIC_DESTRUCTOR_REGISTER(arg_tpm2_signature
, freep
);
111 static const char* const passphrase_type_table
[_PASSPHRASE_TYPE_MAX
] = {
112 [PASSPHRASE_REGULAR
] = "passphrase",
113 [PASSPHRASE_RECOVERY_KEY
] = "recovery key",
114 [PASSPHRASE_BOTH
] = "passphrase or recovery key",
117 const char* passphrase_type_to_string(PassphraseType t
);
118 PassphraseType
passphrase_type_from_string(const char *s
);
120 DEFINE_STRING_TABLE_LOOKUP(passphrase_type
, PassphraseType
);
122 /* Options Debian's crypttab knows we don't:
133 static int parse_one_option(const char *option
) {
139 /* Handled outside of this tool */
140 if (STR_IN_SET(option
, "noauto", "auto", "nofail", "fail", "_netdev", "keyfile-timeout"))
143 if (startswith(option
, "keyfile-timeout="))
146 if ((val
= startswith(option
, "cipher="))) {
147 r
= free_and_strdup(&arg_cipher
, val
);
151 } else if ((val
= startswith(option
, "size="))) {
153 r
= safe_atou(val
, &arg_key_size
);
155 log_error_errno(r
, "Failed to parse %s, ignoring: %m", option
);
159 if (arg_key_size
% 8) {
160 log_error("size= not a multiple of 8, ignoring.");
166 } else if ((val
= startswith(option
, "sector-size="))) {
168 r
= safe_atou(val
, &arg_sector_size
);
170 log_error_errno(r
, "Failed to parse %s, ignoring: %m", option
);
174 if (arg_sector_size
% 2) {
175 log_error("sector-size= not a multiple of 2, ignoring.");
179 if (arg_sector_size
< CRYPT_SECTOR_SIZE
|| arg_sector_size
> CRYPT_MAX_SECTOR_SIZE
) {
180 log_error("sector-size= is outside of %u and %u, ignoring.", CRYPT_SECTOR_SIZE
, CRYPT_MAX_SECTOR_SIZE
);
184 } else if ((val
= startswith(option
, "key-slot=")) ||
185 (val
= startswith(option
, "keyslot="))) {
188 r
= safe_atoi(val
, &arg_key_slot
);
190 log_error_errno(r
, "Failed to parse %s, ignoring: %m", option
);
194 } else if ((val
= startswith(option
, "tcrypt-keyfile="))) {
196 arg_type
= CRYPT_TCRYPT
;
197 if (path_is_absolute(val
)) {
198 if (strv_extend(&arg_tcrypt_keyfiles
, val
) < 0)
201 log_error("Key file path \"%s\" is not absolute. Ignoring.", val
);
203 } else if ((val
= startswith(option
, "keyfile-size="))) {
205 r
= safe_atou(val
, &arg_keyfile_size
);
207 log_error_errno(r
, "Failed to parse %s, ignoring: %m", option
);
211 } else if ((val
= startswith(option
, "keyfile-offset="))) {
213 r
= safe_atou64(val
, &arg_keyfile_offset
);
215 log_error_errno(r
, "Failed to parse %s, ignoring: %m", option
);
219 } else if ((val
= startswith(option
, "keyfile-erase="))) {
221 r
= parse_boolean(val
);
223 log_error_errno(r
, "Failed to parse %s, ignoring: %m", option
);
227 arg_keyfile_erase
= r
;
229 } else if (streq(option
, "keyfile-erase"))
230 arg_keyfile_erase
= true;
232 else if ((val
= startswith(option
, "hash="))) {
233 r
= free_and_strdup(&arg_hash
, val
);
237 } else if ((val
= startswith(option
, "header="))) {
240 if (!path_is_absolute(val
))
241 return log_error_errno(SYNTHETIC_ERRNO(EINVAL
),
242 "Header path \"%s\" is not absolute, refusing.", val
);
245 return log_error_errno(SYNTHETIC_ERRNO(EINVAL
),
246 "Duplicate header= option, refusing.");
248 arg_header
= strdup(val
);
252 } else if ((val
= startswith(option
, "tries="))) {
254 r
= safe_atou(val
, &arg_tries
);
256 log_error_errno(r
, "Failed to parse %s, ignoring: %m", option
);
260 } else if (STR_IN_SET(option
, "readonly", "read-only"))
262 else if (streq(option
, "verify"))
264 else if ((val
= startswith(option
, "password-echo="))) {
265 if (streq(val
, "masked"))
266 arg_ask_password_flags
&= ~(ASK_PASSWORD_ECHO
|ASK_PASSWORD_SILENT
);
268 r
= parse_boolean(val
);
270 log_warning_errno(r
, "Invalid password-echo= option \"%s\", ignoring.", val
);
274 SET_FLAG(arg_ask_password_flags
, ASK_PASSWORD_ECHO
, r
);
275 SET_FLAG(arg_ask_password_flags
, ASK_PASSWORD_SILENT
, !r
);
277 } else if (STR_IN_SET(option
, "allow-discards", "discard"))
279 else if (streq(option
, "same-cpu-crypt"))
280 arg_same_cpu_crypt
= true;
281 else if (streq(option
, "submit-from-crypt-cpus"))
282 arg_submit_from_crypt_cpus
= true;
283 else if (streq(option
, "no-read-workqueue"))
284 arg_no_read_workqueue
= true;
285 else if (streq(option
, "no-write-workqueue"))
286 arg_no_write_workqueue
= true;
287 else if (streq(option
, "luks"))
289 /* since cryptsetup 2.3.0 (Feb 2020) */
291 else if (streq(option
, "bitlk"))
292 arg_type
= CRYPT_BITLK
;
294 else if (streq(option
, "tcrypt"))
295 arg_type
= CRYPT_TCRYPT
;
296 else if (STR_IN_SET(option
, "tcrypt-hidden", "tcrypthidden")) {
297 arg_type
= CRYPT_TCRYPT
;
298 arg_tcrypt_hidden
= true;
299 } else if (streq(option
, "tcrypt-system")) {
300 arg_type
= CRYPT_TCRYPT
;
301 arg_tcrypt_system
= true;
302 } else if (STR_IN_SET(option
, "tcrypt-veracrypt", "veracrypt")) {
303 arg_type
= CRYPT_TCRYPT
;
304 arg_tcrypt_veracrypt
= true;
305 } else if (STR_IN_SET(option
, "plain", "swap", "tmp") ||
306 startswith(option
, "tmp="))
307 arg_type
= CRYPT_PLAIN
;
308 else if ((val
= startswith(option
, "timeout="))) {
310 r
= parse_sec_fix_0(val
, &arg_timeout
);
312 log_error_errno(r
, "Failed to parse %s, ignoring: %m", option
);
316 } else if ((val
= startswith(option
, "offset="))) {
318 r
= safe_atou64(val
, &arg_offset
);
320 return log_error_errno(r
, "Failed to parse %s: %m", option
);
322 } else if ((val
= startswith(option
, "skip="))) {
324 r
= safe_atou64(val
, &arg_skip
);
326 return log_error_errno(r
, "Failed to parse %s: %m", option
);
328 } else if ((val
= startswith(option
, "pkcs11-uri="))) {
330 if (streq(val
, "auto")) {
331 arg_pkcs11_uri
= mfree(arg_pkcs11_uri
);
332 arg_pkcs11_uri_auto
= true;
334 if (!pkcs11_uri_valid(val
))
335 return log_error_errno(SYNTHETIC_ERRNO(EINVAL
), "pkcs11-uri= parameter expects a PKCS#11 URI, refusing");
337 r
= free_and_strdup(&arg_pkcs11_uri
, val
);
341 arg_pkcs11_uri_auto
= false;
344 } else if ((val
= startswith(option
, "fido2-device="))) {
346 if (streq(val
, "auto")) {
347 arg_fido2_device
= mfree(arg_fido2_device
);
348 arg_fido2_device_auto
= true;
350 r
= free_and_strdup(&arg_fido2_device
, val
);
354 arg_fido2_device_auto
= false;
357 } else if ((val
= startswith(option
, "fido2-cid="))) {
359 if (streq(val
, "auto"))
360 arg_fido2_cid
= mfree(arg_fido2_cid
);
362 _cleanup_free_
void *cid
= NULL
;
365 r
= unbase64mem(val
, SIZE_MAX
, &cid
, &cid_size
);
367 return log_error_errno(r
, "Failed to decode FIDO2 CID data: %m");
370 arg_fido2_cid
= TAKE_PTR(cid
);
371 arg_fido2_cid_size
= cid_size
;
374 /* Turn on FIDO2 as side-effect, if not turned on yet. */
375 if (!arg_fido2_device
&& !arg_fido2_device_auto
)
376 arg_fido2_device_auto
= true;
378 } else if ((val
= startswith(option
, "fido2-rp="))) {
380 r
= free_and_strdup(&arg_fido2_rp_id
, val
);
384 } else if ((val
= startswith(option
, "tpm2-device="))) {
386 if (streq(val
, "auto")) {
387 arg_tpm2_device
= mfree(arg_tpm2_device
);
388 arg_tpm2_device_auto
= true;
390 r
= free_and_strdup(&arg_tpm2_device
, val
);
394 arg_tpm2_device_auto
= false;
397 } else if ((val
= startswith(option
, "tpm2-pcrs="))) {
399 r
= tpm2_parse_pcr_argument(val
, &arg_tpm2_pcr_mask
);
403 } else if ((val
= startswith(option
, "tpm2-signature="))) {
405 if (!path_is_absolute(val
))
406 return log_error_errno(SYNTHETIC_ERRNO(EINVAL
),
407 "TPM2 signature path \"%s\" is not absolute, refusing.", val
);
409 r
= free_and_strdup(&arg_tpm2_signature
, val
);
413 } else if ((val
= startswith(option
, "tpm2-pin="))) {
415 r
= parse_boolean(val
);
417 log_error_errno(r
, "Failed to parse %s, ignoring: %m", option
);
423 } else if ((val
= startswith(option
, "try-empty-password="))) {
425 r
= parse_boolean(val
);
427 log_error_errno(r
, "Failed to parse %s, ignoring: %m", option
);
431 arg_try_empty_password
= r
;
433 } else if (streq(option
, "try-empty-password"))
434 arg_try_empty_password
= true;
435 else if ((val
= startswith(option
, "headless="))) {
437 r
= parse_boolean(val
);
439 log_error_errno(r
, "Failed to parse %s, ignoring: %m", option
);
444 } else if (streq(option
, "headless"))
447 else if ((val
= startswith(option
, "token-timeout="))) {
449 r
= parse_sec_fix_0(val
, &arg_token_timeout_usec
);
451 log_error_errno(r
, "Failed to parse %s, ignoring: %m", option
);
455 } else if (!streq(option
, "x-initrd.attach"))
456 log_warning("Encountered unknown /etc/crypttab option '%s', ignoring.", option
);
461 static int parse_options(const char *options
) {
465 _cleanup_free_
char *word
= NULL
;
468 r
= extract_first_word(&options
, &word
, ",", EXTRACT_DONT_COALESCE_SEPARATORS
| EXTRACT_UNESCAPE_SEPARATORS
);
470 return log_error_errno(r
, "Failed to parse options: %m");
474 r
= parse_one_option(word
);
479 /* sanity-check options */
480 if (arg_type
&& !streq(arg_type
, CRYPT_PLAIN
)) {
482 log_warning("offset= ignored with type %s", arg_type
);
484 log_warning("skip= ignored with type %s", arg_type
);
490 static char* disk_description(const char *path
) {
491 static const char name_fields
[] =
493 "ID_MODEL_FROM_DATABASE\0"
496 _cleanup_(sd_device_unrefp
) sd_device
*device
= NULL
;
497 const char *i
, *name
;
502 if (stat(path
, &st
) < 0)
505 if (!S_ISBLK(st
.st_mode
))
508 if (sd_device_new_from_stat_rdev(&device
, &st
) < 0)
511 if (sd_device_get_property_value(device
, "ID_PART_ENTRY_NAME", &name
) >= 0) {
512 _cleanup_free_
char *unescaped
= NULL
;
515 /* ID_PART_ENTRY_NAME uses \x style escaping, using libblkid's blkid_encode_string(). Let's
516 * reverse this here to make the string more human friendly in case people embed spaces or
517 * other weird stuff. */
519 l
= cunescape(name
, UNESCAPE_RELAX
, &unescaped
);
521 log_debug_errno(l
, "Failed to unescape ID_PART_ENTRY_NAME, skipping device: %m");
525 if (!isempty(unescaped
) && !string_has_cc(unescaped
, NULL
))
526 return TAKE_PTR(unescaped
);
529 /* These need no unescaping. */
530 NULSTR_FOREACH(i
, name_fields
)
531 if (sd_device_get_property_value(device
, i
, &name
) >= 0 &&
538 static char *disk_mount_point(const char *label
) {
539 _cleanup_free_
char *device
= NULL
;
540 _cleanup_endmntent_
FILE *f
= NULL
;
543 /* Yeah, we don't support native systemd unit files here for now */
545 device
= strjoin("/dev/mapper/", label
);
549 f
= setmntent(fstab_path(), "re");
553 while ((m
= getmntent(f
)))
554 if (path_equal(m
->mnt_fsname
, device
))
555 return strdup(m
->mnt_dir
);
560 static char *friendly_disk_name(const char *src
, const char *vol
) {
561 _cleanup_free_
char *description
= NULL
, *mount_point
= NULL
;
562 char *name_buffer
= NULL
;
568 description
= disk_description(src
);
569 mount_point
= disk_mount_point(vol
);
571 /* If the description string is simply the volume name, then let's not show this twice */
572 if (description
&& streq(vol
, description
))
573 description
= mfree(description
);
575 if (mount_point
&& description
)
576 r
= asprintf(&name_buffer
, "%s (%s) on %s", description
, vol
, mount_point
);
577 else if (mount_point
)
578 r
= asprintf(&name_buffer
, "%s on %s", vol
, mount_point
);
579 else if (description
)
580 r
= asprintf(&name_buffer
, "%s (%s)", description
, vol
);
589 static PassphraseType
check_registered_passwords(struct crypt_device
*cd
) {
590 _cleanup_free_
bool *slots
= NULL
;
592 PassphraseType passphrase_type
= PASSPHRASE_NONE
;
596 if (!streq_ptr(crypt_get_type(cd
), CRYPT_LUKS2
)) {
597 log_debug("%s: not a LUKS2 device, only passphrases are supported", crypt_get_device_name(cd
));
598 return PASSPHRASE_REGULAR
;
601 /* Search all used slots */
602 assert_se((slot_max
= crypt_keyslot_max(CRYPT_LUKS2
)) > 0);
603 slots
= new(bool, slot_max
);
607 for (int slot
= 0; slot
< slot_max
; slot
++)
608 slots
[slot
] = IN_SET(crypt_keyslot_status(cd
, slot
), CRYPT_SLOT_ACTIVE
, CRYPT_SLOT_ACTIVE_LAST
);
610 /* Iterate all LUKS2 tokens and keep track of all their slots */
611 for (int token
= 0; token
< sym_crypt_token_max(CRYPT_LUKS2
); token
++) {
612 _cleanup_(json_variant_unrefp
) JsonVariant
*v
= NULL
;
617 tk
= cryptsetup_get_token_as_json(cd
, token
, NULL
, &v
);
618 if (IN_SET(tk
, -ENOENT
, -EINVAL
))
621 log_warning_errno(tk
, "Failed to read JSON token data, ignoring: %m");
625 w
= json_variant_by_key(v
, "type");
626 if (!w
|| !json_variant_is_string(w
)) {
627 log_warning("Token JSON data lacks type field, ignoring.");
631 type
= json_variant_string(w
);
632 if (STR_IN_SET(type
, "systemd-recovery", "systemd-pkcs11", "systemd-fido2", "systemd-tpm2")) {
634 /* At least exists one recovery key */
635 if (streq(type
, "systemd-recovery"))
636 passphrase_type
|= PASSPHRASE_RECOVERY_KEY
;
638 w
= json_variant_by_key(v
, "keyslots");
639 if (!w
|| !json_variant_is_array(w
)) {
640 log_warning("Token JSON data lacks keyslots field, ignoring.");
644 JSON_VARIANT_ARRAY_FOREACH(z
, w
) {
648 if (!json_variant_is_string(z
)) {
649 log_warning("Token JSON data's keyslot field is not an array of strings, ignoring.");
653 at
= safe_atou(json_variant_string(z
), &u
);
655 log_warning_errno(at
, "Token JSON data's keyslot field is not an integer formatted as string, ignoring.");
659 if (u
>= (unsigned) slot_max
) {
660 log_warning_errno(at
, "Token JSON data's keyslot field exceeds the maximum value allowed, ignoring.");
669 /* Check if any of the slots is not referenced by systemd tokens */
670 for (int slot
= 0; slot
< slot_max
; slot
++)
672 passphrase_type
|= PASSPHRASE_REGULAR
;
676 /* All the slots are referenced by systemd tokens, so if a recovery key is not enrolled,
677 * we will not be able to enter a passphrase. */
678 return passphrase_type
;
681 static int get_password(
686 PassphraseType passphrase_type
,
689 _cleanup_free_
char *friendly
= NULL
, *text
= NULL
, *disk_path
= NULL
;
690 _cleanup_strv_free_erase_
char **passwords
= NULL
;
693 AskPasswordFlags flags
= arg_ask_password_flags
| ASK_PASSWORD_PUSH_CACHE
;
700 return log_error_errno(SYNTHETIC_ERRNO(ENOPKG
), "Password querying disabled via 'headless' option.");
702 friendly
= friendly_disk_name(src
, vol
);
706 if (asprintf(&text
, "Please enter %s for disk %s:", passphrase_type_to_string(passphrase_type
), friendly
) < 0)
709 disk_path
= cescape(src
);
713 id
= strjoina("cryptsetup:", disk_path
);
715 r
= ask_password_auto(text
, "drive-harddisk", id
, "cryptsetup", "cryptsetup.passphrase", until
,
716 flags
| (accept_cached
*ASK_PASSWORD_ACCEPT_CACHED
),
719 return log_error_errno(r
, "Failed to query password: %m");
722 _cleanup_strv_free_erase_
char **passwords2
= NULL
;
724 assert(strv_length(passwords
) == 1);
726 if (asprintf(&text
, "Please enter %s for disk %s (verification):", passphrase_type_to_string(passphrase_type
), friendly
) < 0)
729 id
= strjoina("cryptsetup-verification:", disk_path
);
731 r
= ask_password_auto(text
, "drive-harddisk", id
, "cryptsetup", "cryptsetup.passphrase", until
, flags
, &passwords2
);
733 return log_error_errno(r
, "Failed to query verification password: %m");
735 assert(strv_length(passwords2
) == 1);
737 if (!streq(passwords
[0], passwords2
[0]))
738 return log_warning_errno(SYNTHETIC_ERRNO(EAGAIN
),
739 "Passwords did not match, retrying.");
742 strv_uniq(passwords
);
744 STRV_FOREACH(p
, passwords
) {
747 if (strlen(*p
)+1 >= arg_key_size
)
750 /* Pad password if necessary */
751 c
= new(char, arg_key_size
);
755 strncpy(c
, *p
, arg_key_size
);
760 *ret
= TAKE_PTR(passwords
);
765 static int attach_tcrypt(
766 struct crypt_device
*cd
,
768 const char *key_file
,
769 const void *key_data
,
770 size_t key_data_size
,
775 _cleanup_(erase_and_freep
) char *passphrase
= NULL
;
776 struct crypt_params_tcrypt params
= {
777 .flags
= CRYPT_TCRYPT_LEGACY_MODES
,
778 .keyfiles
= (const char **)arg_tcrypt_keyfiles
,
779 .keyfiles_count
= strv_length(arg_tcrypt_keyfiles
)
784 assert(key_file
|| key_data
|| !strv_isempty(passwords
));
786 if (arg_pkcs11_uri
|| arg_pkcs11_uri_auto
|| arg_fido2_device
|| arg_fido2_device_auto
|| arg_tpm2_device
|| arg_tpm2_device_auto
)
787 /* Ask for a regular password */
788 return log_error_errno(SYNTHETIC_ERRNO(EAGAIN
),
789 "Sorry, but tcrypt devices are currently not supported in conjunction with pkcs11/fido2/tpm2 support.");
791 if (arg_tcrypt_hidden
)
792 params
.flags
|= CRYPT_TCRYPT_HIDDEN_HEADER
;
794 if (arg_tcrypt_system
)
795 params
.flags
|= CRYPT_TCRYPT_SYSTEM_HEADER
;
797 if (arg_tcrypt_veracrypt
)
798 params
.flags
|= CRYPT_TCRYPT_VERA_MODES
;
801 params
.passphrase
= key_data
;
802 params
.passphrase_size
= key_data_size
;
805 r
= read_one_line_file(key_file
, &passphrase
);
807 log_error_errno(r
, "Failed to read password file '%s': %m", key_file
);
808 return -EAGAIN
; /* log with the actual error, but return EAGAIN */
811 params
.passphrase
= passphrase
;
813 params
.passphrase
= passwords
[0];
815 params
.passphrase_size
= strlen(params
.passphrase
);
818 r
= crypt_load(cd
, CRYPT_TCRYPT
, ¶ms
);
822 log_error_errno(r
, "Failed to activate using discovered key. (Key not correct?)");
825 log_error_errno(r
, "Failed to activate using password file '%s'. (Key data not correct?)", key_file
);
827 return -EAGAIN
; /* log the actual error, but return EAGAIN */
830 return log_error_errno(r
, "Failed to load tcrypt superblock on device %s: %m", crypt_get_device_name(cd
));
833 r
= crypt_activate_by_volume_key(cd
, name
, NULL
, 0, flags
);
835 return log_error_errno(r
, "Failed to activate tcrypt device %s: %m", crypt_get_device_name(cd
));
840 static char *make_bindname(const char *volume
) {
843 if (asprintf(&s
, "@%" PRIx64
"/cryptsetup/%s", random_u64(), volume
) < 0)
849 static int make_security_device_monitor(
850 sd_event
**ret_event
,
851 sd_device_monitor
**ret_monitor
) {
852 _cleanup_(sd_device_monitor_unrefp
) sd_device_monitor
*monitor
= NULL
;
853 _cleanup_(sd_event_unrefp
) sd_event
*event
= NULL
;
859 /* Waits for a device with "security-device" tag to show up in udev */
861 r
= sd_event_default(&event
);
863 return log_error_errno(r
, "Failed to allocate event loop: %m");
865 r
= sd_event_add_time_relative(event
, NULL
, CLOCK_MONOTONIC
, arg_token_timeout_usec
, USEC_PER_SEC
, NULL
, INT_TO_PTR(-ETIMEDOUT
));
867 return log_error_errno(r
, "Failed to install timeout event source: %m");
869 r
= sd_device_monitor_new(&monitor
);
871 return log_error_errno(r
, "Failed to allocate device monitor: %m");
873 (void) sd_device_monitor_set_description(monitor
, "security-device");
875 r
= sd_device_monitor_filter_add_match_tag(monitor
, "security-device");
877 return log_error_errno(r
, "Failed to configure device monitor: %m");
879 r
= sd_device_monitor_attach_event(monitor
, event
);
881 return log_error_errno(r
, "Failed to attach device monitor: %m");
883 r
= sd_device_monitor_start(monitor
, NULL
, NULL
);
885 return log_error_errno(r
, "Failed to start device monitor: %m");
887 *ret_event
= TAKE_PTR(event
);
888 *ret_monitor
= TAKE_PTR(monitor
);
892 static int run_security_device_monitor(
894 sd_device_monitor
*monitor
) {
895 bool processed
= false;
901 /* Runs the event loop for the device monitor until either something happens, or the time-out is
907 r
= sd_event_get_exit_code(event
, &x
);
910 return log_error_errno(r
, "Failed to query exit code from event loop: %m");
912 /* On ENODATA we aren't told to exit yet. */
914 assert(x
== -ETIMEDOUT
);
915 return log_notice_errno(SYNTHETIC_ERRNO(EAGAIN
),
916 "Timed out waiting for security device, aborting security device based authentication attempt.");
919 /* Wait for one event, and then eat all subsequent events until there are no further ones */
920 r
= sd_event_run(event
, processed
? 0 : UINT64_MAX
);
922 return log_error_errno(r
, "Failed to run event loop: %m");
923 if (r
== 0) /* no events queued anymore */
930 static bool libcryptsetup_plugins_support(void) {
931 #if HAVE_LIBCRYPTSETUP_PLUGINS
934 /* Permit a way to disable libcryptsetup token module support, for debugging purposes. */
935 r
= getenv_bool("SYSTEMD_CRYPTSETUP_USE_TOKEN_MODULE");
936 if (r
< 0 && r
!= -ENXIO
)
937 log_debug_errno(r
, "Failed to parse $SYSTEMD_CRYPTSETUP_USE_TOKEN_MODULE env var: %m");
941 return crypt_token_external_path();
947 #if HAVE_LIBCRYPTSETUP_PLUGINS
948 static int acquire_pins_from_env_variable(char ***ret_pins
) {
949 _cleanup_(erase_and_freep
) char *envpin
= NULL
;
950 _cleanup_strv_free_erase_
char **pins
= NULL
;
955 r
= getenv_steal_erase("PIN", &envpin
);
957 return log_error_errno(r
, "Failed to acquire PIN from environment: %m");
959 pins
= strv_new(envpin
);
964 *ret_pins
= TAKE_PTR(pins
);
970 static int crypt_activate_by_token_pin_ask_password(
971 struct crypt_device
*cd
,
977 uint32_t activation_flags
,
979 const char *key_name
,
980 const char *credential_name
) {
982 #if HAVE_LIBCRYPTSETUP_PLUGINS
983 AskPasswordFlags flags
= ASK_PASSWORD_PUSH_CACHE
| ASK_PASSWORD_ACCEPT_CACHED
;
984 _cleanup_strv_free_erase_
char **pins
= NULL
;
987 r
= crypt_activate_by_token_pin(cd
, name
, type
, CRYPT_ANY_TOKEN
, NULL
, 0, usrptr
, activation_flags
);
988 if (r
> 0) /* returns unlocked keyslot id on success */
990 if (r
!= -ENOANO
) /* needs pin or pin is wrong */
993 r
= acquire_pins_from_env_variable(&pins
);
997 STRV_FOREACH(p
, pins
) {
998 r
= crypt_activate_by_token_pin(cd
, name
, type
, CRYPT_ANY_TOKEN
, *p
, strlen(*p
), usrptr
, activation_flags
);
999 if (r
> 0) /* returns unlocked keyslot id on success */
1001 if (r
!= -ENOANO
) /* needs pin or pin is wrong */
1006 return log_error_errno(SYNTHETIC_ERRNO(ENOPKG
), "PIN querying disabled via 'headless' option. Use the '$PIN' environment variable.");
1009 pins
= strv_free_erase(pins
);
1010 r
= ask_password_auto(message
, "drive-harddisk", NULL
, key_name
, credential_name
, until
, flags
, &pins
);
1014 STRV_FOREACH(p
, pins
) {
1015 r
= crypt_activate_by_token_pin(cd
, name
, type
, CRYPT_ANY_TOKEN
, *p
, strlen(*p
), usrptr
, activation_flags
);
1016 if (r
> 0) /* returns unlocked keyslot id on success */
1018 if (r
!= -ENOANO
) /* needs pin or pin is wrong */
1022 flags
&= ~ASK_PASSWORD_ACCEPT_CACHED
;
1030 static int attach_luks2_by_fido2_via_plugin(
1031 struct crypt_device
*cd
,
1036 uint32_t activation_flags
) {
1038 return crypt_activate_by_token_pin_ask_password(
1046 "Please enter security token PIN:",
1048 "cryptsetup.fido2-pin");
1051 static int attach_luks_or_plain_or_bitlk_by_fido2(
1052 struct crypt_device
*cd
,
1054 const char *key_file
,
1055 const void *key_data
,
1056 size_t key_data_size
,
1059 bool pass_volume_key
) {
1061 _cleanup_(sd_device_monitor_unrefp
) sd_device_monitor
*monitor
= NULL
;
1062 _cleanup_(erase_and_freep
) void *decrypted_key
= NULL
;
1063 _cleanup_(sd_event_unrefp
) sd_event
*event
= NULL
;
1064 _cleanup_free_
void *discovered_salt
= NULL
, *discovered_cid
= NULL
;
1065 size_t discovered_salt_size
, discovered_cid_size
, decrypted_key_size
, cid_size
= 0;
1066 _cleanup_free_
char *friendly
= NULL
, *discovered_rp_id
= NULL
;
1067 int keyslot
= arg_key_slot
, r
;
1068 const char *rp_id
= NULL
;
1069 const void *cid
= NULL
;
1070 Fido2EnrollFlags required
;
1071 bool use_libcryptsetup_plugin
= libcryptsetup_plugins_support();
1075 assert(arg_fido2_device
|| arg_fido2_device_auto
);
1077 if (arg_fido2_cid
) {
1078 if (!key_file
&& !key_data
)
1079 return log_error_errno(SYNTHETIC_ERRNO(EINVAL
),
1080 "FIDO2 mode with manual parameters selected, but no keyfile specified, refusing.");
1082 rp_id
= arg_fido2_rp_id
;
1083 cid
= arg_fido2_cid
;
1084 cid_size
= arg_fido2_cid_size
;
1086 /* For now and for compatibility, if the user explicitly configured FIDO2 support and we do
1087 * not read FIDO2 metadata off the LUKS2 header, default to the systemd 248 logic, where we
1088 * use PIN + UP when needed, and do not configure UV at all. Eventually, we should make this
1089 * explicitly configurable. */
1090 required
= FIDO2ENROLL_PIN_IF_NEEDED
| FIDO2ENROLL_UP_IF_NEEDED
| FIDO2ENROLL_UV_OMIT
;
1091 } else if (!use_libcryptsetup_plugin
) {
1092 r
= find_fido2_auto_data(
1096 &discovered_salt_size
,
1098 &discovered_cid_size
,
1102 if (IN_SET(r
, -ENOTUNIQ
, -ENXIO
))
1103 return log_debug_errno(SYNTHETIC_ERRNO(EAGAIN
),
1104 "Automatic FIDO2 metadata discovery was not possible because missing or not unique, falling back to traditional unlocking.");
1108 if ((required
& (FIDO2ENROLL_PIN
| FIDO2ENROLL_UP
| FIDO2ENROLL_UV
)) && arg_headless
)
1109 return log_error_errno(SYNTHETIC_ERRNO(ENOPKG
),
1110 "Local verification is required to unlock this volume, but the 'headless' parameter was set.");
1112 rp_id
= discovered_rp_id
;
1113 key_data
= discovered_salt
;
1114 key_data_size
= discovered_salt_size
;
1115 cid
= discovered_cid
;
1116 cid_size
= discovered_cid_size
;
1119 friendly
= friendly_disk_name(crypt_get_device_name(cd
), name
);
1124 if (use_libcryptsetup_plugin
&& !arg_fido2_cid
) {
1125 r
= attach_luks2_by_fido2_via_plugin(cd
, name
, until
, arg_headless
, arg_fido2_device
, flags
);
1126 if (IN_SET(r
, -ENOTUNIQ
, -ENXIO
, -ENOENT
))
1127 return log_debug_errno(SYNTHETIC_ERRNO(EAGAIN
),
1128 "Automatic FIDO2 metadata discovery was not possible because missing or not unique, falling back to traditional unlocking.");
1131 r
= acquire_fido2_key(
1137 key_file
, arg_keyfile_size
, arg_keyfile_offset
,
1138 key_data
, key_data_size
,
1142 &decrypted_key
, &decrypted_key_size
,
1143 arg_ask_password_flags
);
1148 if (r
!= -EAGAIN
) /* EAGAIN means: token not found */
1152 /* We didn't find the token. In this case, watch for it via udev. Let's
1153 * create an event loop and monitor first. */
1157 r
= make_security_device_monitor(&event
, &monitor
);
1161 log_notice("Security token not present for unlocking volume %s, please plug it in.", friendly
);
1163 /* Let's immediately rescan in case the token appeared in the time we needed
1164 * to create and configure the monitor */
1168 r
= run_security_device_monitor(event
, monitor
);
1172 log_debug("Got one or more potentially relevant udev events, rescanning FIDO2...");
1175 if (pass_volume_key
)
1176 r
= crypt_activate_by_volume_key(cd
, name
, decrypted_key
, decrypted_key_size
, flags
);
1178 _cleanup_(erase_and_freep
) char *base64_encoded
= NULL
;
1180 /* Before using this key as passphrase we base64 encode it, for compat with homed */
1182 r
= base64mem(decrypted_key
, decrypted_key_size
, &base64_encoded
);
1186 r
= crypt_activate_by_passphrase(cd
, name
, keyslot
, base64_encoded
, strlen(base64_encoded
), flags
);
1189 log_error_errno(r
, "Failed to activate with FIDO2 decrypted key. (Key incorrect?)");
1190 return -EAGAIN
; /* log actual error, but return EAGAIN */
1193 return log_error_errno(r
, "Failed to activate with FIDO2 acquired key: %m");
1198 static int attach_luks2_by_pkcs11_via_plugin(
1199 struct crypt_device
*cd
,
1201 const char *friendly_name
,
1206 #if HAVE_LIBCRYPTSETUP_PLUGINS
1209 if (!streq_ptr(crypt_get_type(cd
), CRYPT_LUKS2
))
1210 return log_error_errno(SYNTHETIC_ERRNO(EINVAL
), "Automatic PKCS#11 metadata requires LUKS2 device.");
1212 systemd_pkcs11_plugin_params params
= {
1213 .friendly_name
= friendly_name
,
1215 .headless
= headless
1218 r
= crypt_activate_by_token_pin(cd
, name
, "systemd-pkcs11", CRYPT_ANY_TOKEN
, NULL
, 0, ¶ms
, flags
);
1219 if (r
> 0) /* returns unlocked keyslot id on success */
1228 static int attach_luks_or_plain_or_bitlk_by_pkcs11(
1229 struct crypt_device
*cd
,
1231 const char *key_file
,
1232 const void *key_data
,
1233 size_t key_data_size
,
1236 bool pass_volume_key
) {
1238 _cleanup_(sd_device_monitor_unrefp
) sd_device_monitor
*monitor
= NULL
;
1239 _cleanup_free_
char *friendly
= NULL
, *discovered_uri
= NULL
;
1240 size_t decrypted_key_size
= 0, discovered_key_size
= 0;
1241 _cleanup_(erase_and_freep
) void *decrypted_key
= NULL
;
1242 _cleanup_(sd_event_unrefp
) sd_event
*event
= NULL
;
1243 _cleanup_free_
void *discovered_key
= NULL
;
1244 int keyslot
= arg_key_slot
, r
;
1245 const char *uri
= NULL
;
1246 bool use_libcryptsetup_plugin
= libcryptsetup_plugins_support();
1250 assert(arg_pkcs11_uri
|| arg_pkcs11_uri_auto
);
1252 if (arg_pkcs11_uri_auto
) {
1253 if (!use_libcryptsetup_plugin
) {
1254 r
= find_pkcs11_auto_data(cd
, &discovered_uri
, &discovered_key
, &discovered_key_size
, &keyslot
);
1255 if (IN_SET(r
, -ENOTUNIQ
, -ENXIO
))
1256 return log_debug_errno(SYNTHETIC_ERRNO(EAGAIN
),
1257 "Automatic PKCS#11 metadata discovery was not possible because missing or not unique, falling back to traditional unlocking.");
1261 uri
= discovered_uri
;
1262 key_data
= discovered_key
;
1263 key_data_size
= discovered_key_size
;
1266 uri
= arg_pkcs11_uri
;
1268 if (!key_file
&& !key_data
)
1269 return log_error_errno(SYNTHETIC_ERRNO(EINVAL
), "PKCS#11 mode selected but no key file specified, refusing.");
1272 friendly
= friendly_disk_name(crypt_get_device_name(cd
), name
);
1277 if (use_libcryptsetup_plugin
&& arg_pkcs11_uri_auto
)
1278 r
= attach_luks2_by_pkcs11_via_plugin(cd
, name
, friendly
, until
, arg_headless
, flags
);
1280 r
= decrypt_pkcs11_key(
1284 key_file
, arg_keyfile_size
, arg_keyfile_offset
,
1285 key_data
, key_data_size
,
1288 &decrypted_key
, &decrypted_key_size
);
1293 if (r
!= -EAGAIN
) /* EAGAIN means: token not found */
1297 /* We didn't find the token. In this case, watch for it via udev. Let's
1298 * create an event loop and monitor first. */
1302 r
= make_security_device_monitor(&event
, &monitor
);
1306 log_notice("Security token %s not present for unlocking volume %s, please plug it in.",
1309 /* Let's immediately rescan in case the token appeared in the time we needed
1310 * to create and configure the monitor */
1314 r
= run_security_device_monitor(event
, monitor
);
1318 log_debug("Got one or more potentially relevant udev events, rescanning PKCS#11...");
1320 assert(decrypted_key
);
1322 if (pass_volume_key
)
1323 r
= crypt_activate_by_volume_key(cd
, name
, decrypted_key
, decrypted_key_size
, flags
);
1325 _cleanup_(erase_and_freep
) char *base64_encoded
= NULL
;
1327 /* Before using this key as passphrase we base64 encode it. Why? For compatibility
1328 * with homed's PKCS#11 hookup: there we want to use the key we acquired through
1329 * PKCS#11 for other authentication/decryption mechanisms too, and some of them do
1330 * not take arbitrary binary blobs, but require NUL-terminated strings — most
1331 * importantly UNIX password hashes. Hence, for compatibility we want to use a string
1332 * without embedded NUL here too, and that's easiest to generate from a binary blob
1333 * via base64 encoding. */
1335 r
= base64mem(decrypted_key
, decrypted_key_size
, &base64_encoded
);
1339 r
= crypt_activate_by_passphrase(cd
, name
, keyslot
, base64_encoded
, strlen(base64_encoded
), flags
);
1342 log_error_errno(r
, "Failed to activate with PKCS#11 decrypted key. (Key incorrect?)");
1343 return -EAGAIN
; /* log actual error, but return EAGAIN */
1346 return log_error_errno(r
, "Failed to activate with PKCS#11 acquired key: %m");
1351 static int make_tpm2_device_monitor(
1352 sd_event
**ret_event
,
1353 sd_device_monitor
**ret_monitor
) {
1355 _cleanup_(sd_device_monitor_unrefp
) sd_device_monitor
*monitor
= NULL
;
1356 _cleanup_(sd_event_unrefp
) sd_event
*event
= NULL
;
1360 assert(ret_monitor
);
1362 r
= sd_event_default(&event
);
1364 return log_error_errno(r
, "Failed to allocate event loop: %m");
1366 r
= sd_event_add_time_relative(event
, NULL
, CLOCK_MONOTONIC
, arg_token_timeout_usec
, USEC_PER_SEC
, NULL
, INT_TO_PTR(-ETIMEDOUT
));
1368 return log_error_errno(r
, "Failed to install timeout event source: %m");
1370 r
= sd_device_monitor_new(&monitor
);
1372 return log_error_errno(r
, "Failed to allocate device monitor: %m");
1374 (void) sd_device_monitor_set_description(monitor
, "tpmrm");
1376 r
= sd_device_monitor_filter_add_match_subsystem_devtype(monitor
, "tpmrm", NULL
);
1378 return log_error_errno(r
, "Failed to configure device monitor: %m");
1380 r
= sd_device_monitor_attach_event(monitor
, event
);
1382 return log_error_errno(r
, "Failed to attach device monitor: %m");
1384 r
= sd_device_monitor_start(monitor
, NULL
, NULL
);
1386 return log_error_errno(r
, "Failed to start device monitor: %m");
1388 *ret_event
= TAKE_PTR(event
);
1389 *ret_monitor
= TAKE_PTR(monitor
);
1393 static int attach_luks2_by_tpm2_via_plugin(
1394 struct crypt_device
*cd
,
1400 #if HAVE_LIBCRYPTSETUP_PLUGINS
1401 systemd_tpm2_plugin_params params
= {
1402 .search_pcr_mask
= arg_tpm2_pcr_mask
,
1403 .device
= arg_tpm2_device
,
1404 .signature_path
= arg_tpm2_signature
,
1407 if (!libcryptsetup_plugins_support())
1408 return log_debug_errno(SYNTHETIC_ERRNO(EOPNOTSUPP
),
1409 "Libcryptsetup has external plugins support disabled.");
1411 return crypt_activate_by_token_pin_ask_password(
1419 "Please enter TPM2 PIN:",
1421 "cryptsetup.tpm2-pin");
1427 static int attach_luks_or_plain_or_bitlk_by_tpm2(
1428 struct crypt_device
*cd
,
1430 const char *key_file
,
1431 const void *key_data
,
1432 size_t key_data_size
,
1435 bool pass_volume_key
) {
1437 _cleanup_(sd_device_monitor_unrefp
) sd_device_monitor
*monitor
= NULL
;
1438 _cleanup_(erase_and_freep
) void *decrypted_key
= NULL
;
1439 _cleanup_(sd_event_unrefp
) sd_event
*event
= NULL
;
1440 _cleanup_free_
char *friendly
= NULL
;
1441 int keyslot
= arg_key_slot
, r
;
1442 size_t decrypted_key_size
;
1446 assert(arg_tpm2_device
|| arg_tpm2_device_auto
);
1448 friendly
= friendly_disk_name(crypt_get_device_name(cd
), name
);
1453 if (key_file
|| key_data
) {
1454 /* If key data is specified, use that */
1456 r
= acquire_tpm2_key(
1459 arg_tpm2_pcr_mask
== UINT32_MAX
? TPM2_PCR_MASK_DEFAULT
: arg_tpm2_pcr_mask
,
1461 /* pubkey= */ NULL
, /* pubkey_size= */ 0,
1462 /* pubkey_pcr_mask= */ 0,
1463 /* signature_path= */ NULL
,
1464 /* primary_alg= */ 0,
1465 key_file
, arg_keyfile_size
, arg_keyfile_offset
,
1466 key_data
, key_data_size
,
1467 /* policy_hash= */ NULL
, /* policy_hash_size= */ 0, /* we don't know the policy hash */
1468 arg_tpm2_pin
? TPM2_FLAGS_USE_PIN
: 0,
1471 arg_ask_password_flags
,
1472 &decrypted_key
, &decrypted_key_size
);
1475 if (IN_SET(r
, -EACCES
, -ENOLCK
))
1476 return log_error_errno(SYNTHETIC_ERRNO(EAGAIN
), "TPM2 PIN unlock failed, falling back to traditional unlocking.");
1477 if (ERRNO_IS_NOT_SUPPORTED(r
)) /* TPM2 support not compiled in? */
1478 return log_debug_errno(SYNTHETIC_ERRNO(EAGAIN
), "TPM2 support not available, falling back to traditional unlocking.");
1479 /* EAGAIN means: no tpm2 chip found */
1481 log_notice_errno(r
, "TPM2 operation failed, falling back to traditional unlocking: %m");
1482 return -EAGAIN
; /* Mangle error code: let's make any form of TPM2 failure non-fatal. */
1485 r
= attach_luks2_by_tpm2_via_plugin(cd
, name
, until
, arg_headless
, flags
);
1488 /* EAGAIN means: no tpm2 chip found
1489 * EOPNOTSUPP means: no libcryptsetup plugins support */
1491 return log_notice_errno(SYNTHETIC_ERRNO(EAGAIN
),
1492 "No TPM2 metadata matching the current system state found in LUKS2 header, falling back to traditional unlocking.");
1494 return log_debug_errno(SYNTHETIC_ERRNO(EAGAIN
),
1495 "No TPM2 metadata enrolled in LUKS2 header or TPM2 support not available, falling back to traditional unlocking.");
1496 if (!IN_SET(r
, -EOPNOTSUPP
, -EAGAIN
)) {
1497 log_notice_errno(r
, "TPM2 operation failed, falling back to traditional unlocking: %m");
1498 return -EAGAIN
; /* Mangle error code: let's make any form of TPM2 failure non-fatal. */
1502 if (r
== -EOPNOTSUPP
) { /* Plugin not available, let's process TPM2 stuff right here instead */
1503 _cleanup_free_
void *blob
= NULL
, *policy_hash
= NULL
;
1504 size_t blob_size
, policy_hash_size
;
1505 bool found_some
= false;
1506 int token
= 0; /* first token to look at */
1508 /* If no key data is specified, look for it in the header. In order to support
1509 * software upgrades we'll iterate through all suitable tokens, maybe one of them
1513 _cleanup_free_
void *pubkey
= NULL
;
1514 size_t pubkey_size
= 0;
1515 uint32_t hash_pcr_mask
, pubkey_pcr_mask
;
1516 uint16_t pcr_bank
, primary_alg
;
1517 TPM2Flags tpm2_flags
;
1519 r
= find_tpm2_auto_data(
1521 arg_tpm2_pcr_mask
, /* if != UINT32_MAX we'll only look for tokens with this PCR mask */
1522 token
, /* search for the token with this index, or any later index than this */
1525 &pubkey
, &pubkey_size
,
1529 &policy_hash
, &policy_hash_size
,
1534 /* No further TPM2 tokens found in the LUKS2 header. */
1535 return log_full_errno(found_some
? LOG_NOTICE
: LOG_DEBUG
,
1536 SYNTHETIC_ERRNO(EAGAIN
),
1538 ? "No TPM2 metadata matching the current system state found in LUKS2 header, falling back to traditional unlocking."
1539 : "No TPM2 metadata enrolled in LUKS2 header, falling back to traditional unlocking.");
1540 if (ERRNO_IS_NOT_SUPPORTED(r
)) /* TPM2 support not compiled in? */
1541 return log_debug_errno(SYNTHETIC_ERRNO(EAGAIN
), "TPM2 support not available, falling back to traditional unlocking.");
1547 r
= acquire_tpm2_key(
1552 pubkey
, pubkey_size
,
1556 /* key_file= */ NULL
, /* key_file_size= */ 0, /* key_file_offset= */ 0, /* no key file */
1558 policy_hash
, policy_hash_size
,
1562 arg_ask_password_flags
,
1563 &decrypted_key
, &decrypted_key_size
);
1564 if (IN_SET(r
, -EACCES
, -ENOLCK
))
1565 return log_notice_errno(SYNTHETIC_ERRNO(EAGAIN
), "TPM2 PIN unlock failed, falling back to traditional unlocking.");
1569 token
++; /* try a different token next time */
1574 /* EAGAIN means: no tpm2 chip found */
1576 log_notice_errno(r
, "TPM2 operation failed, falling back to traditional unlocking: %m");
1577 return -EAGAIN
; /* Mangle error code: let's make any form of TPM2 failure non-fatal. */
1582 /* We didn't find the TPM2 device. In this case, watch for it via udev. Let's create
1583 * an event loop and monitor first. */
1587 if (is_efi_boot() && !efi_has_tpm2())
1588 return log_notice_errno(SYNTHETIC_ERRNO(EAGAIN
),
1589 "No TPM2 hardware discovered and EFI firmware does not see it either, falling back to traditional unlocking.");
1591 r
= make_tpm2_device_monitor(&event
, &monitor
);
1595 log_info("TPM2 device not present for unlocking %s, waiting for it to become available.", friendly
);
1597 /* Let's immediately rescan in case the device appeared in the time we needed
1598 * to create and configure the monitor */
1602 r
= run_security_device_monitor(event
, monitor
);
1606 log_debug("Got one or more potentially relevant udev events, rescanning for TPM2...");
1608 assert(decrypted_key
);
1610 if (pass_volume_key
)
1611 r
= crypt_activate_by_volume_key(cd
, name
, decrypted_key
, decrypted_key_size
, flags
);
1613 _cleanup_(erase_and_freep
) char *base64_encoded
= NULL
;
1615 /* Before using this key as passphrase we base64 encode it, for compat with homed */
1617 r
= base64mem(decrypted_key
, decrypted_key_size
, &base64_encoded
);
1621 r
= crypt_activate_by_passphrase(cd
, name
, keyslot
, base64_encoded
, strlen(base64_encoded
), flags
);
1624 log_error_errno(r
, "Failed to activate with TPM2 decrypted key. (Key incorrect?)");
1625 return -EAGAIN
; /* log actual error, but return EAGAIN */
1628 return log_error_errno(r
, "Failed to activate with TPM2 acquired key: %m");
1633 static int attach_luks_or_plain_or_bitlk_by_key_data(
1634 struct crypt_device
*cd
,
1636 const void *key_data
,
1637 size_t key_data_size
,
1639 bool pass_volume_key
) {
1647 if (pass_volume_key
)
1648 r
= crypt_activate_by_volume_key(cd
, name
, key_data
, key_data_size
, flags
);
1650 r
= crypt_activate_by_passphrase(cd
, name
, arg_key_slot
, key_data
, key_data_size
, flags
);
1652 log_error_errno(r
, "Failed to activate. (Key incorrect?)");
1653 return -EAGAIN
; /* Log actual error, but return EAGAIN */
1656 return log_error_errno(r
, "Failed to activate: %m");
1661 static int attach_luks_or_plain_or_bitlk_by_key_file(
1662 struct crypt_device
*cd
,
1664 const char *key_file
,
1666 bool pass_volume_key
) {
1668 _cleanup_(erase_and_freep
) char *kfdata
= NULL
;
1669 _cleanup_free_
char *bindname
= NULL
;
1677 /* If we read the key via AF_UNIX, make this client recognizable */
1678 bindname
= make_bindname(name
);
1682 r
= read_full_file_full(
1684 arg_keyfile_offset
== 0 ? UINT64_MAX
: arg_keyfile_offset
,
1685 arg_keyfile_size
== 0 ? SIZE_MAX
: arg_keyfile_size
,
1686 READ_FULL_FILE_SECURE
|READ_FULL_FILE_WARN_WORLD_READABLE
|READ_FULL_FILE_CONNECT_SOCKET
,
1690 log_error_errno(r
, "Failed to activate, key file '%s' too large.", key_file
);
1694 log_error_errno(r
, "Failed to activate, key file '%s' missing.", key_file
);
1695 return -EAGAIN
; /* Log actual error, but return EAGAIN */
1698 return log_error_errno(r
, "Failed to read key file '%s': %m", key_file
);
1700 if (pass_volume_key
)
1701 r
= crypt_activate_by_volume_key(cd
, name
, kfdata
, kfsize
, flags
);
1703 r
= crypt_activate_by_passphrase(cd
, name
, arg_key_slot
, kfdata
, kfsize
, flags
);
1705 log_error_errno(r
, "Failed to activate with key file '%s'. (Key data incorrect?)", key_file
);
1706 return -EAGAIN
; /* Log actual error, but return EAGAIN */
1709 return log_error_errno(r
, "Failed to activate with key file '%s': %m", key_file
);
1714 static int attach_luks_or_plain_or_bitlk_by_passphrase(
1715 struct crypt_device
*cd
,
1719 bool pass_volume_key
) {
1727 STRV_FOREACH(p
, passwords
) {
1728 if (pass_volume_key
)
1729 r
= crypt_activate_by_volume_key(cd
, name
, *p
, arg_key_size
, flags
);
1731 r
= crypt_activate_by_passphrase(cd
, name
, arg_key_slot
, *p
, strlen(*p
), flags
);
1736 log_error_errno(r
, "Failed to activate with specified passphrase. (Passphrase incorrect?)");
1737 return -EAGAIN
; /* log actual error, but return EAGAIN */
1740 return log_error_errno(r
, "Failed to activate with specified passphrase: %m");
1745 static int attach_luks_or_plain_or_bitlk(
1746 struct crypt_device
*cd
,
1748 const char *key_file
,
1749 const void *key_data
,
1750 size_t key_data_size
,
1755 bool pass_volume_key
= false;
1761 if ((!arg_type
&& !crypt_get_type(cd
)) || streq_ptr(arg_type
, CRYPT_PLAIN
)) {
1762 struct crypt_params_plain params
= {
1763 .offset
= arg_offset
,
1765 .sector_size
= arg_sector_size
,
1767 const char *cipher
, *cipher_mode
;
1768 _cleanup_free_
char *truncated_cipher
= NULL
;
1770 if (streq_ptr(arg_hash
, "plain"))
1771 /* plain isn't a real hash type. it just means "use no hash" */
1774 params
.hash
= arg_hash
;
1776 /* for CRYPT_PLAIN, the behaviour of cryptsetup package is to not hash when a key
1777 * file is provided */
1778 params
.hash
= "ripemd160";
1783 l
= strcspn(arg_cipher
, "-");
1784 truncated_cipher
= strndup(arg_cipher
, l
);
1785 if (!truncated_cipher
)
1788 cipher
= truncated_cipher
;
1789 cipher_mode
= arg_cipher
[l
] ? arg_cipher
+l
+1 : "plain";
1792 cipher_mode
= "cbc-essiv:sha256";
1795 /* for CRYPT_PLAIN limit reads from keyfile to key length, and ignore keyfile-size */
1796 arg_keyfile_size
= arg_key_size
;
1798 /* In contrast to what the name crypt_format() might suggest this doesn't actually format
1799 * anything, it just configures encryption parameters when used for plain mode. */
1800 r
= crypt_format(cd
, CRYPT_PLAIN
, cipher
, cipher_mode
, NULL
, NULL
, arg_keyfile_size
, ¶ms
);
1802 return log_error_errno(r
, "Loading of cryptographic parameters failed: %m");
1804 /* hash == NULL implies the user passed "plain" */
1805 pass_volume_key
= !params
.hash
;
1808 log_info("Set cipher %s, mode %s, key size %i bits for device %s.",
1809 crypt_get_cipher(cd
),
1810 crypt_get_cipher_mode(cd
),
1811 crypt_get_volume_key_size(cd
)*8,
1812 crypt_get_device_name(cd
));
1814 if (arg_tpm2_device
|| arg_tpm2_device_auto
)
1815 return attach_luks_or_plain_or_bitlk_by_tpm2(cd
, name
, key_file
, key_data
, key_data_size
, until
, flags
, pass_volume_key
);
1816 if (arg_fido2_device
|| arg_fido2_device_auto
)
1817 return attach_luks_or_plain_or_bitlk_by_fido2(cd
, name
, key_file
, key_data
, key_data_size
, until
, flags
, pass_volume_key
);
1818 if (arg_pkcs11_uri
|| arg_pkcs11_uri_auto
)
1819 return attach_luks_or_plain_or_bitlk_by_pkcs11(cd
, name
, key_file
, key_data
, key_data_size
, until
, flags
, pass_volume_key
);
1821 return attach_luks_or_plain_or_bitlk_by_key_data(cd
, name
, key_data
, key_data_size
, flags
, pass_volume_key
);
1823 return attach_luks_or_plain_or_bitlk_by_key_file(cd
, name
, key_file
, flags
, pass_volume_key
);
1825 return attach_luks_or_plain_or_bitlk_by_passphrase(cd
, name
, passwords
, flags
, pass_volume_key
);
1828 static int help(void) {
1829 _cleanup_free_
char *link
= NULL
;
1832 r
= terminal_urlify_man("systemd-cryptsetup@.service", "8", &link
);
1836 printf("%s attach VOLUME SOURCEDEVICE [KEY-FILE] [OPTIONS]\n"
1837 "%s detach VOLUME\n\n"
1838 "Attaches or detaches an encrypted block device.\n"
1839 "\nSee the %s for details.\n",
1840 program_invocation_short_name
,
1841 program_invocation_short_name
,
1847 static uint32_t determine_flags(void) {
1851 flags
|= CRYPT_ACTIVATE_READONLY
;
1854 flags
|= CRYPT_ACTIVATE_ALLOW_DISCARDS
;
1856 if (arg_same_cpu_crypt
)
1857 flags
|= CRYPT_ACTIVATE_SAME_CPU_CRYPT
;
1859 if (arg_submit_from_crypt_cpus
)
1860 flags
|= CRYPT_ACTIVATE_SUBMIT_FROM_CRYPT_CPUS
;
1862 if (arg_no_read_workqueue
)
1863 flags
|= CRYPT_ACTIVATE_NO_READ_WORKQUEUE
;
1865 if (arg_no_write_workqueue
)
1866 flags
|= CRYPT_ACTIVATE_NO_WRITE_WORKQUEUE
;
1868 #ifdef CRYPT_ACTIVATE_SERIALIZE_MEMORY_HARD_PBKDF
1869 /* Try to decrease the risk of OOM event if memory hard key derivation function is in use */
1870 /* https://gitlab.com/cryptsetup/cryptsetup/issues/446/ */
1871 flags
|= CRYPT_ACTIVATE_SERIALIZE_MEMORY_HARD_PBKDF
;
1877 static void remove_and_erasep(const char **p
) {
1883 r
= unlinkat_deallocate(AT_FDCWD
, *p
, UNLINK_ERASE
);
1884 if (r
< 0 && r
!= -ENOENT
)
1885 log_warning_errno(r
, "Unable to erase key file '%s', ignoring: %m", *p
);
1888 static int run(int argc
, char *argv
[]) {
1889 _cleanup_(crypt_freep
) struct crypt_device
*cd
= NULL
;
1893 if (argv_looks_like_help(argc
, argv
))
1897 return log_error_errno(SYNTHETIC_ERRNO(EINVAL
),
1898 "This program requires at least two arguments.");
1902 cryptsetup_enable_logging(NULL
);
1908 if (streq(verb
, "attach")) {
1909 _unused_
_cleanup_(remove_and_erasep
) const char *destroy_key_file
= NULL
;
1910 _cleanup_(erase_and_freep
) void *key_data
= NULL
;
1911 const char *volume
, *source
, *key_file
, *options
;
1912 crypt_status_info status
;
1913 size_t key_data_size
= 0;
1917 PassphraseType passphrase_type
= PASSPHRASE_NONE
;
1919 /* Arguments: systemd-cryptsetup attach VOLUME SOURCE-DEVICE [KEY-FILE] [OPTIONS] */
1922 return log_error_errno(SYNTHETIC_ERRNO(EINVAL
), "attach requires at least two arguments.");
1926 key_file
= mangle_none(argc
>= 5 ? argv
[4] : NULL
);
1927 options
= mangle_none(argc
>= 6 ? argv
[5] : NULL
);
1929 if (!filename_is_valid(volume
))
1930 return log_error_errno(SYNTHETIC_ERRNO(EINVAL
), "Volume name '%s' is not valid.", volume
);
1932 if (key_file
&& !path_is_absolute(key_file
)) {
1933 log_warning("Password file path '%s' is not absolute. Ignoring.", key_file
);
1938 r
= parse_options(options
);
1943 log_debug("%s %s ← %s type=%s cipher=%s", __func__
,
1944 volume
, source
, strempty(arg_type
), strempty(arg_cipher
));
1946 /* A delicious drop of snake oil */
1947 (void) mlockall(MCL_FUTURE
);
1950 _cleanup_free_
char *bindname
= NULL
;
1953 bindname
= make_bindname(volume
);
1957 /* If a key file is not explicitly specified, search for a key in a well defined
1958 * search path, and load it. */
1960 fn
= strjoina(volume
, ".key");
1963 STRV_MAKE("/etc/cryptsetup-keys.d", "/run/cryptsetup-keys.d"),
1965 &key_data
, &key_data_size
);
1969 log_debug("Automatically discovered key for volume '%s'.", volume
);
1970 } else if (arg_keyfile_erase
)
1971 destroy_key_file
= key_file
; /* let's get this baby erased when we leave */
1974 log_debug("LUKS header: %s", arg_header
);
1975 r
= crypt_init(&cd
, arg_header
);
1977 r
= crypt_init(&cd
, source
);
1979 return log_error_errno(r
, "crypt_init() failed: %m");
1981 cryptsetup_enable_logging(cd
);
1983 status
= crypt_status(cd
, volume
);
1984 if (IN_SET(status
, CRYPT_ACTIVE
, CRYPT_BUSY
)) {
1985 log_info("Volume %s already active.", volume
);
1989 flags
= determine_flags();
1991 until
= usec_add(now(CLOCK_MONOTONIC
), arg_timeout
);
1992 if (until
== USEC_INFINITY
)
1995 if (arg_key_size
== 0)
1996 arg_key_size
= 256U / 8U;
2001 /* Ideally we'd do this on the open fd, but since this is just a
2002 * warning it's OK to do this in two steps. */
2003 if (stat(key_file
, &st
) >= 0 && S_ISREG(st
.st_mode
) && (st
.st_mode
& 0005))
2004 log_warning("Key file %s is world-readable. This is not a good idea!", key_file
);
2007 if (!arg_type
|| STR_IN_SET(arg_type
, ANY_LUKS
, CRYPT_LUKS1
, CRYPT_LUKS2
)) {
2008 r
= crypt_load(cd
, !arg_type
|| streq(arg_type
, ANY_LUKS
) ? CRYPT_LUKS
: arg_type
, NULL
);
2010 return log_error_errno(r
, "Failed to load LUKS superblock on device %s: %m", crypt_get_device_name(cd
));
2013 r
= crypt_set_data_device(cd
, source
);
2015 return log_error_errno(r
, "Failed to set LUKS data device %s: %m", source
);
2018 /* Tokens are available in LUKS2 only, but it is ok to call (and fail) with LUKS1. */
2019 if (!key_file
&& !key_data
&& getenv_bool("SYSTEMD_CRYPTSETUP_USE_TOKEN_MODULE") != 0) {
2020 r
= crypt_activate_by_token_pin_ask_password(
2028 "Please enter LUKS2 token PIN:",
2030 "cryptsetup.luks2-pin");
2032 log_debug("Volume %s activated with LUKS token id %i.", volume
, r
);
2036 log_debug_errno(r
, "Token activation unsuccessful for device %s: %m", crypt_get_device_name(cd
));
2040 /* since cryptsetup 2.3.0 (Feb 2020) */
2042 if (streq_ptr(arg_type
, CRYPT_BITLK
)) {
2043 r
= crypt_load(cd
, CRYPT_BITLK
, NULL
);
2045 return log_error_errno(r
, "Failed to load Bitlocker superblock on device %s: %m", crypt_get_device_name(cd
));
2049 for (tries
= 0; arg_tries
== 0 || tries
< arg_tries
; tries
++) {
2050 _cleanup_strv_free_erase_
char **passwords
= NULL
;
2052 /* When we were able to acquire multiple keys, let's always process them in this order:
2054 * 1. A key acquired via PKCS#11 or FIDO2 token, or TPM2 chip
2055 * 2. The discovered key: i.e. key_data + key_data_size
2056 * 3. The configured key: i.e. key_file + arg_keyfile_offset + arg_keyfile_size
2057 * 4. The empty password, in case arg_try_empty_password is set
2058 * 5. We enquire the user for a password
2061 if (!key_file
&& !key_data
&& !arg_pkcs11_uri
&& !arg_pkcs11_uri_auto
&& !arg_fido2_device
&& !arg_fido2_device_auto
&& !arg_tpm2_device
&& !arg_tpm2_device_auto
) {
2063 if (arg_try_empty_password
) {
2064 /* Hmm, let's try an empty password now, but only once */
2065 arg_try_empty_password
= false;
2067 key_data
= strdup("");
2073 /* Ask the user for a passphrase or recovery key only as last resort, if we have
2074 * nothing else to check for */
2075 if (passphrase_type
== PASSPHRASE_NONE
) {
2076 passphrase_type
= check_registered_passwords(cd
);
2077 if (passphrase_type
== PASSPHRASE_NONE
)
2078 return log_error_errno(SYNTHETIC_ERRNO(EINVAL
), "No passphrase or recovery key registered.");
2081 r
= get_password(volume
, source
, until
, tries
== 0 && !arg_verify
, passphrase_type
, &passwords
);
2089 if (streq_ptr(arg_type
, CRYPT_TCRYPT
))
2090 r
= attach_tcrypt(cd
, volume
, key_file
, key_data
, key_data_size
, passwords
, flags
);
2092 r
= attach_luks_or_plain_or_bitlk(cd
, volume
, key_file
, key_data
, key_data_size
, passwords
, flags
, until
);
2098 /* Key not correct? Let's try again! */
2101 key_data
= erase_and_free(key_data
);
2103 arg_pkcs11_uri
= mfree(arg_pkcs11_uri
);
2104 arg_pkcs11_uri_auto
= false;
2105 arg_fido2_device
= mfree(arg_fido2_device
);
2106 arg_fido2_device_auto
= false;
2107 arg_tpm2_device
= mfree(arg_tpm2_device
);
2108 arg_tpm2_device_auto
= false;
2111 if (arg_tries
!= 0 && tries
>= arg_tries
)
2112 return log_error_errno(SYNTHETIC_ERRNO(EPERM
), "Too many attempts to activate; giving up.");
2114 } else if (streq(verb
, "detach")) {
2119 if (!filename_is_valid(volume
))
2120 return log_error_errno(SYNTHETIC_ERRNO(EINVAL
), "Volume name '%s' is not valid.", volume
);
2122 r
= crypt_init_by_name(&cd
, volume
);
2124 log_info("Volume %s already inactive.", volume
);
2128 return log_error_errno(r
, "crypt_init_by_name() failed: %m");
2130 cryptsetup_enable_logging(cd
);
2132 r
= crypt_deactivate(cd
, volume
);
2134 return log_error_errno(r
, "Failed to deactivate: %m");
2137 return log_error_errno(SYNTHETIC_ERRNO(EINVAL
), "Unknown verb %s.", verb
);
2142 DEFINE_MAIN_FUNCTION(run
);