#include <errno.h>

#include <mntent.h>

#include <sys/mman.h>

#include <sys/stat.h>

#include <sys/types.h>

#include <unistd.h>

#include "sd-device.h"

#include "alloc-util.h"

#include "ask-password-api.h"

#include "cryptsetup-fido2.h"

#include "cryptsetup-keyfile.h"

#include "cryptsetup-pkcs11.h"

#include "cryptsetup-tpm2.h"

#include "cryptsetup-util.h"

#include "device-util.h"

#include "efi-loader.h"

#include "escape.h"

#include "fileio.h"

#include "fs-util.h"

#include "fstab-util.h"

#include "hexdecoct.h"

#include "libfido2-util.h"

#include "log.h"

#include "main-func.h"

#include "memory-util.h"

#include "mount-util.h"

#include "nulstr-util.h"

#include "parse-util.h"

#include "path-util.h"

#include "pkcs11-util.h"

#include "pretty-print.h"

#include "random-util.h"

#include "string-util.h"

#include "strv.h"

#include "tpm2-util.h"

#define ANY_LUKS "LUKS"

#define CRYPT_SECTOR_SIZE 512

#define CRYPT_MAX_SECTOR_SIZE 4096

static const char *arg_type = NULL; /* ANY_LUKS, CRYPT_LUKS1, CRYPT_LUKS2, CRYPT_TCRYPT, CRYPT_BITLK or CRYPT_PLAIN */

static char *arg_cipher = NULL;

static unsigned arg_key_size = 0;

static unsigned arg_sector_size = CRYPT_SECTOR_SIZE;

static int arg_key_slot = CRYPT_ANY_SLOT;

static unsigned arg_keyfile_size = 0;

static uint64_t arg_keyfile_offset = 0;

static bool arg_keyfile_erase = false;

static bool arg_try_empty_password = false;

static char *arg_hash = NULL;

static char *arg_header = NULL;

static unsigned arg_tries = 3;

static bool arg_readonly = false;

static bool arg_verify = false;

static AskPasswordFlags arg_ask_password_flags = 0;

static bool arg_discards = false;

static bool arg_same_cpu_crypt = false;

static bool arg_submit_from_crypt_cpus = false;

static bool arg_no_read_workqueue = false;

static bool arg_no_write_workqueue = false;

static bool arg_tcrypt_hidden = false;

static bool arg_tcrypt_system = false;

static bool arg_tcrypt_veracrypt = false;

static char **arg_tcrypt_keyfiles = NULL;

static uint64_t arg_offset = 0;

static uint64_t arg_skip = 0;

static usec_t arg_timeout = USEC_INFINITY;

static char *arg_pkcs11_uri = NULL;

static bool arg_pkcs11_uri_auto = false;

static char *arg_fido2_device = NULL;

static bool arg_fido2_device_auto = false;

static void *arg_fido2_cid = NULL;

static size_t arg_fido2_cid_size = 0;

static char *arg_fido2_rp_id = NULL;

static char *arg_tpm2_device = NULL;

static bool arg_tpm2_device_auto = false;

static uint32_t arg_tpm2_pcr_mask = UINT32_MAX;

static bool arg_headless = false;

STATIC_DESTRUCTOR_REGISTER(arg_cipher, freep);

STATIC_DESTRUCTOR_REGISTER(arg_hash, freep);

STATIC_DESTRUCTOR_REGISTER(arg_header, freep);

STATIC_DESTRUCTOR_REGISTER(arg_tcrypt_keyfiles, strv_freep);

STATIC_DESTRUCTOR_REGISTER(arg_pkcs11_uri, freep);

STATIC_DESTRUCTOR_REGISTER(arg_fido2_device, freep);

STATIC_DESTRUCTOR_REGISTER(arg_fido2_cid, freep);

STATIC_DESTRUCTOR_REGISTER(arg_fido2_rp_id, freep);

STATIC_DESTRUCTOR_REGISTER(arg_tpm2_device, freep);

static int parse_one_option(const char *option) {

const char *val;

int r;

assert(option);

/* Handled outside of this tool */

if (STR_IN_SET(option, "noauto", "auto", "nofail", "fail", "_netdev", "keyfile-timeout"))

return 0;

if (startswith(option, "keyfile-timeout="))

return 0;

if ((val = startswith(option, "cipher="))) {

r = free_and_strdup(&arg_cipher, val);

if (r < 0)

return log_oom();

} else if ((val = startswith(option, "size="))) {

r = safe_atou(val, &arg_key_size);

if (r < 0) {

log_error_errno(r, "Failed to parse %s, ignoring: %m", option);

return 0;

}

if (arg_key_size % 8) {

log_error("size= not a multiple of 8, ignoring.");

return 0;

}

arg_key_size /= 8;

} else if ((val = startswith(option, "sector-size="))) {

r = safe_atou(val, &arg_sector_size);

if (r < 0) {

log_error_errno(r, "Failed to parse %s, ignoring: %m", option);

return 0;

}

if (arg_sector_size % 2) {

log_error("sector-size= not a multiple of 2, ignoring.");

return 0;

}

if (arg_sector_size < CRYPT_SECTOR_SIZE || arg_sector_size > CRYPT_MAX_SECTOR_SIZE) {

log_error("sector-size= is outside of %u and %u, ignoring.", CRYPT_SECTOR_SIZE, CRYPT_MAX_SECTOR_SIZE);

return 0;

}

} else if ((val = startswith(option, "key-slot=")) ||

(val = startswith(option, "keyslot="))) {

arg_type = ANY_LUKS;

r = safe_atoi(val, &arg_key_slot);

if (r < 0) {

log_error_errno(r, "Failed to parse %s, ignoring: %m", option);

return 0;

}

} else if ((val = startswith(option, "tcrypt-keyfile="))) {

arg_type = CRYPT_TCRYPT;

if (path_is_absolute(val)) {

if (strv_extend(&arg_tcrypt_keyfiles, val) < 0)

return log_oom();

} else

log_error("Key file path \"%s\" is not absolute. Ignoring.", val);

} else if ((val = startswith(option, "keyfile-size="))) {

r = safe_atou(val, &arg_keyfile_size);

if (r < 0) {

log_error_errno(r, "Failed to parse %s, ignoring: %m", option);

return 0;

}

} else if ((val = startswith(option, "keyfile-offset="))) {

r = safe_atou64(val, &arg_keyfile_offset);

if (r < 0) {

log_error_errno(r, "Failed to parse %s, ignoring: %m", option);

return 0;

}

} else if ((val = startswith(option, "keyfile-erase="))) {

r = parse_boolean(val);

if (r < 0) {

log_error_errno(r, "Failed to parse %s, ignoring: %m", option);

return 0;

}

arg_keyfile_erase = r;

} else if (streq(option, "keyfile-erase"))

arg_keyfile_erase = true;

else if ((val = startswith(option, "hash="))) {

r = free_and_strdup(&arg_hash, val);

if (r < 0)

return log_oom();

} else if ((val = startswith(option, "header="))) {

arg_type = ANY_LUKS;

if (!path_is_absolute(val))

return log_error_errno(SYNTHETIC_ERRNO(EINVAL),

"Header path \"%s\" is not absolute, refusing.", val);

if (arg_header)

return log_error_errno(SYNTHETIC_ERRNO(EINVAL),

"Duplicate header= option, refusing.");

arg_header = strdup(val);

if (!arg_header)

return log_oom();

} else if ((val = startswith(option, "tries="))) {

r = safe_atou(val, &arg_tries);

if (r < 0) {

log_error_errno(r, "Failed to parse %s, ignoring: %m", option);

return 0;

}

} else if (STR_IN_SET(option, "readonly", "read-only"))

arg_readonly = true;

else if (streq(option, "verify"))

arg_verify = true;

else if ((val = startswith(option, "password-echo="))) {

if (streq(val, "masked"))

arg_ask_password_flags &= ~(ASK_PASSWORD_ECHO|ASK_PASSWORD_SILENT);

else {

r = parse_boolean(val);

if (r < 0) {

log_warning_errno(r, "Invalid password-echo= option \"%s\", ignoring.", val);

return 0;

}

SET_FLAG(arg_ask_password_flags, ASK_PASSWORD_ECHO, r);

SET_FLAG(arg_ask_password_flags, ASK_PASSWORD_SILENT, !r);

}

} else if (STR_IN_SET(option, "allow-discards", "discard"))

arg_discards = true;

else if (streq(option, "same-cpu-crypt"))

arg_same_cpu_crypt = true;

else if (streq(option, "submit-from-crypt-cpus"))

arg_submit_from_crypt_cpus = true;

else if (streq(option, "no-read-workqueue"))

arg_no_read_workqueue = true;

else if (streq(option, "no-write-workqueue"))

arg_no_write_workqueue = true;

else if (streq(option, "luks"))

arg_type = ANY_LUKS;

#ifdef CRYPT_BITLK

else if (streq(option, "bitlk"))

arg_type = CRYPT_BITLK;

else if (streq(option, "tcrypt"))

arg_type = CRYPT_TCRYPT;

else if (STR_IN_SET(option, "tcrypt-hidden", "tcrypthidden")) {

arg_type = CRYPT_TCRYPT;

arg_tcrypt_hidden = true;

} else if (streq(option, "tcrypt-system")) {

arg_type = CRYPT_TCRYPT;

arg_tcrypt_system = true;

} else if (STR_IN_SET(option, "tcrypt-veracrypt", "veracrypt")) {

arg_type = CRYPT_TCRYPT;

arg_tcrypt_veracrypt = true;

} else if (STR_IN_SET(option, "plain", "swap", "tmp") ||

startswith(option, "tmp="))

arg_type = CRYPT_PLAIN;

else if ((val = startswith(option, "timeout="))) {

r = parse_sec_fix_0(val, &arg_timeout);

if (r < 0) {

log_error_errno(r, "Failed to parse %s, ignoring: %m", option);

return 0;

}

} else if ((val = startswith(option, "offset="))) {

r = safe_atou64(val, &arg_offset);

if (r < 0)

return log_error_errno(r, "Failed to parse %s: %m", option);

} else if ((val = startswith(option, "skip="))) {

r = safe_atou64(val, &arg_skip);

if (r < 0)

return log_error_errno(r, "Failed to parse %s: %m", option);

} else if ((val = startswith(option, "pkcs11-uri="))) {

if (streq(val, "auto")) {

arg_pkcs11_uri = mfree(arg_pkcs11_uri);

arg_pkcs11_uri_auto = true;

} else {

if (!pkcs11_uri_valid(val))

return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "pkcs11-uri= parameter expects a PKCS#11 URI, refusing");

r = free_and_strdup(&arg_pkcs11_uri, val);

if (r < 0)

return log_oom();

arg_pkcs11_uri_auto = false;

}

} else if ((val = startswith(option, "fido2-device="))) {

if (streq(val, "auto")) {

arg_fido2_device = mfree(arg_fido2_device);

arg_fido2_device_auto = true;

} else {

r = free_and_strdup(&arg_fido2_device, val);

if (r < 0)

return log_oom();

arg_fido2_device_auto = false;

}

} else if ((val = startswith(option, "fido2-cid="))) {

if (streq(val, "auto"))

arg_fido2_cid = mfree(arg_fido2_cid);

else {

_cleanup_free_ void *cid = NULL;

size_t cid_size;

r = unbase64mem(val, SIZE_MAX, &cid, &cid_size);

if (r < 0)

return log_error_errno(r, "Failed to decode FIDO2 CID data: %m");

free(arg_fido2_cid);

arg_fido2_cid = TAKE_PTR(cid);

arg_fido2_cid_size = cid_size;

}

/* Turn on FIDO2 as side-effect, if not turned on yet. */

if (!arg_fido2_device && !arg_fido2_device_auto)

arg_fido2_device_auto = true;

} else if ((val = startswith(option, "fido2-rp="))) {

r = free_and_strdup(&arg_fido2_rp_id, val);

if (r < 0)

return log_oom();

} else if ((val = startswith(option, "tpm2-device="))) {

if (streq(val, "auto")) {

arg_tpm2_device = mfree(arg_tpm2_device);

arg_tpm2_device_auto = true;

} else {

r = free_and_strdup(&arg_tpm2_device, val);

if (r < 0)

return log_oom();

arg_tpm2_device_auto = false;

}

} else if ((val = startswith(option, "tpm2-pcrs="))) {

if (isempty(val))

arg_tpm2_pcr_mask = 0;

else {

uint32_t mask;

r = tpm2_parse_pcrs(val, &mask);

if (r < 0)

return r;

if (arg_tpm2_pcr_mask == UINT32_MAX)

arg_tpm2_pcr_mask = mask;

else

arg_tpm2_pcr_mask |= mask;

}

} else if ((val = startswith(option, "try-empty-password="))) {

r = parse_boolean(val);

if (r < 0) {

log_error_errno(r, "Failed to parse %s, ignoring: %m", option);

return 0;

}

arg_try_empty_password = r;

} else if (streq(option, "try-empty-password"))

arg_try_empty_password = true;

else if ((val = startswith(option, "headless="))) {

r = parse_boolean(val);

if (r < 0) {

log_error_errno(r, "Failed to parse %s, ignoring: %m", option);

return 0;

}

arg_headless = r;

} else if (streq(option, "headless"))

arg_headless = true;

else if (!streq(option, "x-initrd.attach"))

log_warning("Encountered unknown /etc/crypttab option '%s', ignoring.", option);

return 0;

}

static int parse_options(const char *options) {

assert(options);

for (;;) {

_cleanup_free_ char *word = NULL;

int r;

r = extract_first_word(&options, &word, ",", EXTRACT_DONT_COALESCE_SEPARATORS | EXTRACT_UNESCAPE_SEPARATORS);

if (r < 0)

return log_error_errno(r, "Failed to parse options: %m");

if (r == 0)

break;

r = parse_one_option(word);

if (r < 0)

return r;

}

/* sanity-check options */

if (arg_type && !streq(arg_type, CRYPT_PLAIN)) {

if (arg_offset != 0)

log_warning("offset= ignored with type %s", arg_type);

if (arg_skip != 0)

log_warning("skip= ignored with type %s", arg_type);

}

return 0;

}

static char* disk_description(const char *path) {

static const char name_fields[] =

"DM_NAME\0"

"ID_MODEL_FROM_DATABASE\0"

"ID_MODEL\0";

_cleanup_(sd_device_unrefp) sd_device *device = NULL;

const char *i, *name;

struct stat st;

int r;

assert(path);

if (stat(path, &st) < 0)

return NULL;

if (!S_ISBLK(st.st_mode))

return NULL;

if (sd_device_new_from_stat_rdev(&device, &st) < 0)

return NULL;

if (sd_device_get_property_value(device, "ID_PART_ENTRY_NAME", &name) >= 0) {

_cleanup_free_ char *unescaped = NULL;

/* ID_PART_ENTRY_NAME uses \x style escaping, using libblkid's blkid_encode_string(). Let's

r = cunescape(name, UNESCAPE_RELAX, &unescaped);

if (r < 0) {

log_debug_errno(r, "Failed to unescape ID_PART_ENTRY_NAME, skipping device: %m");

return NULL;

}

if (!isempty(unescaped) && !string_has_cc(unescaped, NULL))

return TAKE_PTR(unescaped);

}

/* These need no unescaping. */

NULSTR_FOREACH(i, name_fields)

if (sd_device_get_property_value(device, i, &name) >= 0 &&

!isempty(name))

return strdup(name);

return NULL;

}

static char *disk_mount_point(const char *label) {

_cleanup_free_ char *device = NULL;

_cleanup_endmntent_ FILE *f = NULL;

struct mntent *m;

/* Yeah, we don't support native systemd unit files here for now */

device = strjoin("/dev/mapper/", label);

if (!device)

return NULL;

f = setmntent(fstab_path(), "re");

if (!f)

return NULL;

while ((m = getmntent(f)))

if (path_equal(m->mnt_fsname, device))

return strdup(m->mnt_dir);

return NULL;

}

static char *friendly_disk_name(const char *src, const char *vol) {

_cleanup_free_ char *description = NULL, *mount_point = NULL;

char *name_buffer = NULL;

int r;

assert(src);

assert(vol);

description = disk_description(src);

mount_point = disk_mount_point(vol);

/* If the description string is simply the volume name, then let's not show this twice */

if (description && streq(vol, description))

description = mfree(description);

if (mount_point && description)

r = asprintf(&name_buffer, "%s (%s) on %s", description, vol, mount_point);

else if (mount_point)

r = asprintf(&name_buffer, "%s on %s", vol, mount_point);

else if (description)

r = asprintf(&name_buffer, "%s (%s)", description, vol);

else

return strdup(vol);

if (r < 0)

return NULL;

return name_buffer;

}

static int get_password(

char ***ret) {

_cleanup_free_ char *friendly = NULL, *text = NULL, *disk_path = NULL;

_cleanup_strv_free_erase_ char **passwords = NULL;

char **p, *id;

int r = 0;

AskPasswordFlags flags = arg_ask_password_flags | ASK_PASSWORD_PUSH_CACHE;

assert(vol);

assert(src);

assert(ret);

if (arg_headless)

return log_error_errno(SYNTHETIC_ERRNO(ENOPKG), "Password querying disabled via 'headless' option.");

friendly = friendly_disk_name(src, vol);

if (!friendly)

return log_oom();

if (asprintf(&text, "Please enter passphrase for disk %s:", friendly) < 0)

return log_oom();

disk_path = cescape(src);

if (!disk_path)

return log_oom();

id = strjoina("cryptsetup:", disk_path);

r = ask_password_auto(text, "drive-harddisk", id, "cryptsetup", "cryptsetup.passphrase", until,

flags | (accept_cached*ASK_PASSWORD_ACCEPT_CACHED),

&passwords);

if (r < 0)

return log_error_errno(r, "Failed to query password: %m");

if (arg_verify) {

_cleanup_strv_free_erase_ char **passwords2 = NULL;

assert(strv_length(passwords) == 1);

if (asprintf(&text, "Please enter passphrase for disk %s (verification):", friendly) < 0)

return log_oom();

id = strjoina("cryptsetup-verification:", disk_path);

r = ask_password_auto(text, "drive-harddisk", id, "cryptsetup", "cryptsetup.passphrase", until, flags, &passwords2);

if (r < 0)

return log_error_errno(r, "Failed to query verification password: %m");

assert(strv_length(passwords2) == 1);

if (!streq(passwords[0], passwords2[0]))

return log_warning_errno(SYNTHETIC_ERRNO(EAGAIN),

"Passwords did not match, retrying.");

}

strv_uniq(passwords);

STRV_FOREACH(p, passwords) {

char *c;

if (strlen(*p)+1 >= arg_key_size)

continue;

/* Pad password if necessary */

c = new(char, arg_key_size);

if (!c)

return log_oom();

strncpy(c, *p, arg_key_size);

erase_and_free(*p);

*p = TAKE_PTR(c);

}

*ret = TAKE_PTR(passwords);

return 0;

}

static int attach_tcrypt(

uint32_t flags) {

int r = 0;

_cleanup_(erase_and_freep) char *passphrase = NULL;

struct crypt_params_tcrypt params = {

.flags = CRYPT_TCRYPT_LEGACY_MODES,

.keyfiles = (const char **)arg_tcrypt_keyfiles,

.keyfiles_count = strv_length(arg_tcrypt_keyfiles)

};

assert(cd);

assert(name);

assert(key_file || key_data || !strv_isempty(passwords));

if (arg_pkcs11_uri || arg_pkcs11_uri_auto || arg_fido2_device || arg_fido2_device_auto || arg_tpm2_device || arg_tpm2_device_auto)

/* Ask for a regular password */

return log_error_errno(SYNTHETIC_ERRNO(EAGAIN),

"Sorry, but tcrypt devices are currently not supported in conjunction with pkcs11/fido2/tpm2 support.");

if (arg_tcrypt_hidden)

params.flags |= CRYPT_TCRYPT_HIDDEN_HEADER;

if (arg_tcrypt_system)

params.flags |= CRYPT_TCRYPT_SYSTEM_HEADER;

if (arg_tcrypt_veracrypt)

params.flags |= CRYPT_TCRYPT_VERA_MODES;

if (key_data) {

params.passphrase = key_data;

params.passphrase_size = key_data_size;

} else {

if (key_file) {

r = read_one_line_file(key_file, &passphrase);

if (r < 0) {

log_error_errno(r, "Failed to read password file '%s': %m", key_file);

return -EAGAIN; /* log with the actual error, but return EAGAIN */

}

params.passphrase = passphrase;

} else

params.passphrase = passwords[0];

params.passphrase_size = strlen(params.passphrase);

}

r = crypt_load(cd, CRYPT_TCRYPT, &params);

if (r < 0) {

if (r == -EPERM) {

if (key_data)

log_error_errno(r, "Failed to activate using discovered key. (Key not correct?)");

if (key_file)

log_error_errno(r, "Failed to activate using password file '%s'. (Key data not correct?)", key_file);

return -EAGAIN; /* log the actual error, but return EAGAIN */

}

return log_error_errno(r, "Failed to load tcrypt superblock on device %s: %m", crypt_get_device_name(cd));

}

r = crypt_activate_by_volume_key(cd, name, NULL, 0, flags);

if (r < 0)

return log_error_errno(r, "Failed to activate tcrypt device %s: %m", crypt_get_device_name(cd));

return 0;

}

static char *make_bindname(const char *volume) {

char *s;

if (asprintf(&s, "@%" PRIx64"/cryptsetup/%s", random_u64(), volume) < 0)

return NULL;

return s;

}

static int make_security_device_monitor(sd_event *event, sd_device_monitor **ret) {

_cleanup_(sd_device_monitor_unrefp) sd_device_monitor *monitor = NULL;

int r;

assert(ret);

r = sd_device_monitor_new(&monitor);

if (r < 0)

return log_error_errno(r, "Failed to allocate device monitor: %m");

r = sd_device_monitor_filter_add_match_tag(monitor, "security-device");

if (r < 0)

return log_error_errno(r, "Failed to configure device monitor: %m");

r = sd_device_monitor_attach_event(monitor, event);

if (r < 0)

return log_error_errno(r, "Failed to attach device monitor: %m");

r = sd_device_monitor_start(monitor, NULL, NULL);

if (r < 0)

return log_error_errno(r, "Failed to start device monitor: %m");

*ret = TAKE_PTR(monitor);

return 0;

}

static int attach_luks_or_plain_or_bitlk_by_fido2(

bool pass_volume_key) {

_cleanup_(sd_device_monitor_unrefp) sd_device_monitor *monitor = NULL;

_cleanup_(erase_and_freep) void *decrypted_key = NULL;

_cleanup_(sd_event_unrefp) sd_event *event = NULL;

_cleanup_free_ void *discovered_salt = NULL, *discovered_cid = NULL;

size_t discovered_salt_size, discovered_cid_size, cid_size, decrypted_key_size;

_cleanup_free_ char *friendly = NULL, *discovered_rp_id = NULL;

int keyslot = arg_key_slot, r;

const char *rp_id;

const void *cid;

Fido2EnrollFlags required;

assert(cd);

assert(name);

assert(arg_fido2_device || arg_fido2_device_auto);

if (arg_fido2_cid) {

if (!key_file && !key_data)

return log_error_errno(SYNTHETIC_ERRNO(EINVAL),

"FIDO2 mode with manual parameters selected, but no keyfile specified, refusing.");

rp_id = arg_fido2_rp_id;

cid = arg_fido2_cid;

cid_size = arg_fido2_cid_size;

/* For now and for compatibility, if the user explicitly configured FIDO2 support and we do

required = FIDO2ENROLL_PIN_IF_NEEDED | FIDO2ENROLL_UP_IF_NEEDED | FIDO2ENROLL_UV_OMIT;

} else {

r = find_fido2_auto_data(

cd,

&discovered_rp_id,

&discovered_salt,

&discovered_salt_size,

&discovered_cid,

&discovered_cid_size,

&keyslot,

&required);

if (IN_SET(r, -ENOTUNIQ, -ENXIO))

return log_debug_errno(SYNTHETIC_ERRNO(EAGAIN),

"Automatic FIDO2 metadata discovery was not possible because missing or not unique, falling back to traditional unlocking.");

if (r < 0)

return r;

if ((required & (FIDO2ENROLL_PIN | FIDO2ENROLL_UP | FIDO2ENROLL_UV)) && arg_headless)

return log_error_errno(SYNTHETIC_ERRNO(ENOPKG),

"Local verification is required to unlock this volume, but the 'headless' parameter was set.");

rp_id = discovered_rp_id;

key_data = discovered_salt;

key_data_size = discovered_salt_size;

cid = discovered_cid;

cid_size = discovered_cid_size;

}

friendly = friendly_disk_name(crypt_get_device_name(cd), name);

if (!friendly)

return log_oom();

for (;;) {

bool processed = false;

r = acquire_fido2_key(

name,

friendly,

arg_fido2_device,

rp_id,

cid, cid_size,

key_file, arg_keyfile_size, arg_keyfile_offset,

key_data, key_data_size,

until,

arg_headless,

required,

&decrypted_key, &decrypted_key_size,

arg_ask_password_flags);

if (r >= 0)

break;

if (r != -EAGAIN) /* EAGAIN means: token not found */

return r;

if (!monitor) {

/* We didn't find the token. In this case, watch for it via udev. Let's

assert(!event);

r = sd_event_default(&event);

if (r < 0)

return log_error_errno(r, "Failed to allocate event loop: %m");

r = make_security_device_monitor(event, &monitor);

if (r < 0)

return r;

log_notice("Security token not present for unlocking volume %s, please plug it in.", friendly);

/* Let's immediately rescan in case the token appeared in the time we needed

continue;

}

for (;;) {

/* Wait for one event, and then eat all subsequent events until there are no

r = sd_event_run(event, processed ? 0 : UINT64_MAX);

if (r < 0)

return log_error_errno(r, "Failed to run event loop: %m");

if (r == 0)

break;

processed = true;

}

log_debug("Got one or more potentially relevant udev events, rescanning FIDO2...");

}

if (pass_volume_key)

r = crypt_activate_by_volume_key(cd, name, decrypted_key, decrypted_key_size, flags);

else {

_cleanup_(erase_and_freep) char *base64_encoded = NULL;

/* Before using this key as passphrase we base64 encode it, for compat with homed */

r = base64mem(decrypted_key, decrypted_key_size, &base64_encoded);

if (r < 0)

return log_oom();

r = crypt_activate_by_passphrase(cd, name, keyslot, base64_encoded, strlen(base64_encoded), flags);

}

if (r == -EPERM) {

log_error_errno(r, "Failed to activate with FIDO2 decrypted key. (Key incorrect?)");

return -EAGAIN; /* log actual error, but return EAGAIN */

}

if (r < 0)

return log_error_errno(r, "Failed to activate with FIDO2 acquired key: %m");

return 0;

}

static int attach_luks_or_plain_or_bitlk_by_pkcs11(

bool pass_volume_key) {

_cleanup_(sd_device_monitor_unrefp) sd_device_monitor *monitor = NULL;

_cleanup_free_ char *friendly = NULL, *discovered_uri = NULL;

size_t decrypted_key_size = 0, discovered_key_size = 0;

_cleanup_(erase_and_freep) void *decrypted_key = NULL;

_cleanup_(sd_event_unrefp) sd_event *event = NULL;

_cleanup_free_ void *discovered_key = NULL;

int keyslot = arg_key_slot, r;

const char *uri;

assert(cd);

assert(name);

assert(arg_pkcs11_uri || arg_pkcs11_uri_auto);

if (arg_pkcs11_uri_auto) {

r = find_pkcs11_auto_data(cd, &discovered_uri, &discovered_key, &discovered_key_size, &keyslot);

if (IN_SET(r, -ENOTUNIQ, -ENXIO))

return log_debug_errno(SYNTHETIC_ERRNO(EAGAIN),

"Automatic PKCS#11 metadata discovery was not possible because missing or not unique, falling back to traditional unlocking.");

if (r < 0)

return r;

uri = discovered_uri;

key_data = discovered_key;

key_data_size = discovered_key_size;

} else {

uri = arg_pkcs11_uri;

if (!key_file && !key_data)

return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "PKCS#11 mode selected but no key file specified, refusing.");

}

friendly = friendly_disk_name(crypt_get_device_name(cd), name);

if (!friendly)

return log_oom();

for (;;) {

bool processed = false;

r = decrypt_pkcs11_key(

name,

friendly,

uri,

key_file, arg_keyfile_size, arg_keyfile_offset,

key_data, key_data_size,

until,

arg_headless,

&decrypted_key, &decrypted_key_size);

if (r >= 0)

break;

if (r != -EAGAIN) /* EAGAIN means: token not found */

return r;

if (!monitor) {

/* We didn't find the token. In this case, watch for it via udev. Let's

assert(!event);

r = sd_event_default(&event);

if (r < 0)

return log_error_errno(r, "Failed to allocate event loop: %m");

r = make_security_device_monitor(event, &monitor);

if (r < 0)

return r;

log_notice("Security token %s not present for unlocking volume %s, please plug it in.",

uri, friendly);

/* Let's immediately rescan in case the token appeared in the time we needed

continue;

}

for (;;) {

/* Wait for one event, and then eat all subsequent events until there are no

r = sd_event_run(event, processed ? 0 : UINT64_MAX);

if (r < 0)

return log_error_errno(r, "Failed to run event loop: %m");

if (r == 0)

break;

processed = true;

}

log_debug("Got one or more potentially relevant udev events, rescanning PKCS#11...");

}

if (pass_volume_key)

r = crypt_activate_by_volume_key(cd, name, decrypted_key, decrypted_key_size, flags);

else {

_cleanup_(erase_and_freep) char *base64_encoded = NULL;

/* Before using this key as passphrase we base64 encode it. Why? For compatibility