HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/pcrlock/pcrlock.c
Git blob: c798c78489257ecc6f87eead6fa509ad2027c886
Lines 5001–5877 of 5,877
const char *a;
assert_se(a = tpm2_hash_alg_to_string(*pa));
assert_se(md = sym_EVP_get_digestbyname(a));
r = pe_hash(fd, md, &hash, &hash_size);
if (r < 0)
return log_error_errno(r, "Failed to hash PE binary: %m");
r = sd_json_variant_append_arraybo(
&digests,
SD_JSON_BUILD_PAIR_STRING("hashAlg", a),
SD_JSON_BUILD_PAIR("digest", SD_JSON_BUILD_HEX(hash, hash_size)));
if (r < 0)
return log_error_errno(r, "Failed to build JSON digest object: %m");
}
r = sd_json_variant_append_arraybo(
&array,
SD_JSON_BUILD_PAIR_UNSIGNED("pcr", i),
SD_JSON_BUILD_PAIR_VARIANT("digests", digests));
if (r < 0)
return log_error_errno(r, "Failed to append record object: %m");
}
return write_pcrlock(array, NULL);
}
VERB_NOARG(verb_unlock_simple, "unlock-pe",
"Remove .pcrlock file for PE binary");
static int verb_unlock_simple(int argc, char *argv[], uintptr_t _data, void *userdata) {
return unlink_pcrlock(NULL);
}
typedef void* SectionHashArray[_UNIFIED_SECTION_MAX * TPM2_N_HASH_ALGORITHMS];
static void section_hashes_array_done(SectionHashArray *array) {
assert(array);
for (size_t i = 0; i < _UNIFIED_SECTION_MAX * TPM2_N_HASH_ALGORITHMS; i++)
free((*array)[i]);
}
VERB(verb_lock_uki, "lock-uki", "[UKI]\0", VERB_ANY, 2, 0,
"Generate a .pcrlock file from UKI PE binary");
static int verb_lock_uki(int argc, char *argv[], uintptr_t _data, void *userdata) {
_cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL, *pe_digests = NULL;
_cleanup_(section_hashes_array_done) SectionHashArray section_hashes = {};
size_t hash_sizes[TPM2_N_HASH_ALGORITHMS];
_cleanup_close_ int fd = -EBADF;
int r;
if (arg_pcr_mask != 0)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "PCR not configurable for UKI lock down.");
fd = acquire_pe_fd(argc >= 2 ? argv[1] : NULL);
if (fd < 0)
return fd;
for (size_t i = 0; i < TPM2_N_HASH_ALGORITHMS; i++) {
_cleanup_free_ void *peh = NULL;
const EVP_MD *md;
const char *a;
assert_se(a = tpm2_hash_alg_to_string(tpm2_hash_algorithms[i]));
assert_se(md = sym_EVP_get_digestbyname(a));
r = pe_hash(fd, md, &peh, hash_sizes + i);
if (r < 0)
return log_error_errno(r, "Failed to hash PE binary: %m");
r = sd_json_variant_append_arraybo(
&pe_digests,
SD_JSON_BUILD_PAIR_STRING("hashAlg", a),
SD_JSON_BUILD_PAIR("digest", SD_JSON_BUILD_HEX(peh, hash_sizes[i])));
if (r < 0)
return log_error_errno(r, "Failed to build JSON digest object: %m");
r = uki_hash(fd, md, section_hashes + (i * _UNIFIED_SECTION_MAX), hash_sizes + i);
if (r < 0)
return log_error_errno(r, "Failed to UKI hash PE binary: %m");
}
r = sd_json_variant_append_arraybo(
&array,
SD_JSON_BUILD_PAIR_UNSIGNED("pcr", TPM2_PCR_BOOT_LOADER_CODE),
SD_JSON_BUILD_PAIR_VARIANT("digests", pe_digests));
if (r < 0)
return log_error_errno(r, "Failed to append record object: %m");
for (UnifiedSection section = 0; section < _UNIFIED_SECTION_MAX; section++) {
_cleanup_(sd_json_variant_unrefp) sd_json_variant *section_digests = NULL, *record = NULL;
if (!unified_section_measure(section))
continue;
for (size_t i = 0; i < TPM2_N_HASH_ALGORITHMS; i++) {
const char *a;
void *hash;
hash = section_hashes[i * _UNIFIED_SECTION_MAX + section];
if (!hash)
continue;
assert_se(a = tpm2_hash_alg_to_string(tpm2_hash_algorithms[i]));
r = sd_json_variant_append_arraybo(
§ion_digests,
SD_JSON_BUILD_PAIR_STRING("hashAlg", a),
SD_JSON_BUILD_PAIR("digest", SD_JSON_BUILD_HEX(hash, hash_sizes[i])));
if (r < 0)
return log_error_errno(r, "Failed to build JSON digest object: %m");
}
if (!section_digests)
continue;
/* So we have digests for this section, hence generate a record for the section name first. */
r = make_pcrlock_record(TPM2_PCR_KERNEL_BOOT /* =11 */, unified_sections[section], strlen(unified_sections[section]) + 1, &record);
if (r < 0)
return r;
r = sd_json_variant_append_array(&array, record);
if (r < 0)
return log_error_errno(r, "Failed to append JSON record array: %m");
/* And then append a record for the section contents digests as well */
r = sd_json_variant_append_arraybo(
&array,
SD_JSON_BUILD_PAIR_UNSIGNED("pcr", TPM2_PCR_KERNEL_BOOT),
SD_JSON_BUILD_PAIR_VARIANT("digests", section_digests));
if (r < 0)
return log_error_errno(r, "Failed to append record object: %m");
}
return write_pcrlock(array, NULL);
}
VERB_NOARG(verb_unlock_simple, "unlock-uki",
"Remove .pcrlock file for UKI PE binary");
VERB_NOARG(verb_lock_machine_id, "lock-machine-id",
"Generate a .pcrlock file from current machine ID");
static int verb_lock_machine_id(int argc, char *argv[], uintptr_t _data, void *userdata) {
_cleanup_(sd_json_variant_unrefp) sd_json_variant *record = NULL, *array = NULL;
_cleanup_free_ char *word = NULL;
int r;
r = pcrextend_machine_id_word(&word);
if (r < 0)
return r;
r = make_pcrlock_record(TPM2_PCR_SYSTEM_IDENTITY /* = 15 */, word, SIZE_MAX, &record);
if (r < 0)
return r;
r = sd_json_variant_new_array(&array, &record, 1);
if (r < 0)
return log_error_errno(r, "Failed to create record array: %m");
return write_pcrlock(array, PCRLOCK_MACHINE_ID_PATH);
}
VERB_NOARG(verb_unlock_machine_id, "unlock-machine-id",
"Remove .pcrlock file for machine ID");
static int verb_unlock_machine_id(int argc, char *argv[], uintptr_t _data, void *userdata) {
return unlink_pcrlock(PCRLOCK_MACHINE_ID_PATH);
}
static int pcrlock_file_system_path(const char *normalized_path, char **ret) {
_cleanup_free_ char *s = NULL;
assert(normalized_path);
assert(ret);
if (path_equal(normalized_path, "/"))
s = strdup(PCRLOCK_ROOT_FILE_SYSTEM_PATH);
else {
/* We reuse the escaping we use for turning paths into unit names */
_cleanup_free_ char *escaped = NULL;
assert(normalized_path[0] == '/');
assert(normalized_path[1] != '/');
escaped = unit_name_escape(normalized_path + 1);
if (!escaped)
return log_oom();
s = strjoin(PCRLOCK_FILE_SYSTEM_PATH_PREFIX, escaped, ".pcrlock");
}
if (!s)
return log_oom();
*ret = TAKE_PTR(s);
return 0;
}
VERB(verb_lock_file_system, "lock-file-system", "[PATH]\0", VERB_ANY, 2, 0,
"Generate a .pcrlock file from current root fs + /var/");
static int verb_lock_file_system(int argc, char *argv[], uintptr_t _data, void *userdata) {
const char* paths[3] = {};
int r;
if (argc > 1)
paths[0] = argv[1];
else {
dev_t a, b;
paths[0] = "/";
r = get_block_device("/", &a);
if (r < 0)
return log_error_errno(r, "Failed to get device of root file system: %m");
r = get_block_device("/var", &b);
if (r < 0)
return log_error_errno(r, "Failed to get device of /var/ file system: %m");
/* if backing device is distinct, then measure /var/ too */
if (a != b)
paths[1] = "/var";
enable_json_sse();
}
STRV_FOREACH(p, paths) {
_cleanup_free_ char *word = NULL, *normalized_path = NULL, *pcrlock_file = NULL;
_cleanup_(sd_json_variant_unrefp) sd_json_variant *record = NULL, *array = NULL;
r = pcrextend_file_system_word(*p, &word, &normalized_path);
if (r < 0)
return r;
r = pcrlock_file_system_path(normalized_path, &pcrlock_file);
if (r < 0)
return r;
r = make_pcrlock_record(TPM2_PCR_SYSTEM_IDENTITY /* = 15 */, word, SIZE_MAX, &record);
if (r < 0)
return r;
r = sd_json_variant_new_array(&array, &record, 1);
if (r < 0)
return log_error_errno(r, "Failed to create record array: %m");
r = write_pcrlock(array, pcrlock_file);
if (r < 0)
return r;
}
return 0;
}
VERB(verb_unlock_file_system, "unlock-file-system", "[PATH]\0", VERB_ANY, 2, 0,
"Remove .pcrlock file for root fs + /var/");
static int verb_unlock_file_system(int argc, char *argv[], uintptr_t _data, void *userdata) {
const char* paths[3] = {};
int r;
if (argc > 1)
paths[0] = argv[1];
else {
paths[0] = "/";
paths[1] = "/var";
}
STRV_FOREACH(p, paths) {
_cleanup_free_ char *normalized_path = NULL, *pcrlock_file = NULL;
r = chase(*p, NULL, 0, &normalized_path, NULL);
if (r < 0)
return log_error_errno(r, "Failed to normal path '%s': %m", argv[1]);
r = pcrlock_file_system_path(normalized_path, &pcrlock_file);
if (r < 0)
return r;
r = unlink_pcrlock(pcrlock_file);
if (r < 0)
return r;
}
return 0;
}
VERB(verb_lock_kernel_cmdline, "lock-kernel-cmdline", "[FILE]\0", VERB_ANY, 2, 0,
"Generate a .pcrlock file from kernel command line");
static int verb_lock_kernel_cmdline(int argc, char *argv[], uintptr_t _data, void *userdata) {
_cleanup_(sd_json_variant_unrefp) sd_json_variant *record = NULL, *array = NULL;
_cleanup_free_ char *cmdline = NULL;
int r;
if (argc > 1) {
if (empty_or_dash(argv[1]))
r = read_full_stream(stdin, &cmdline, NULL);
else
r = read_full_file(argv[1], &cmdline, NULL);
} else
r = proc_cmdline(&cmdline);
if (r < 0)
return log_error_errno(r, "Failed to read cmdline: %m");
delete_trailing_chars(cmdline, "\n");
_cleanup_free_ char16_t *u = NULL;
u = utf8_to_utf16(cmdline, SIZE_MAX);
if (!u)
return log_oom();
r = make_pcrlock_record(TPM2_PCR_KERNEL_INITRD /* = 9 */, u, char16_strlen(u)*2+2, &record);
if (r < 0)
return r;
r = sd_json_variant_new_array(&array, &record, 1);
if (r < 0)
return log_error_errno(r, "Failed to create record array: %m");
r = write_pcrlock(array, PCRLOCK_KERNEL_CMDLINE_PATH);
if (r < 0)
return r;
return 0;
}
VERB_NOARG(verb_unlock_kernel_cmdline, "unlock-kernel-cmdline",
"Remove .pcrlock file for kernel command line");
static int verb_unlock_kernel_cmdline(int argc, char *argv[], uintptr_t _data, void *userdata) {
return unlink_pcrlock(PCRLOCK_KERNEL_CMDLINE_PATH);
}
VERB(verb_lock_kernel_initrd, "lock-kernel-initrd", "FILE\0", VERB_ANY, 2, 0,
"Generate a .pcrlock file from an initrd file");
static int verb_lock_kernel_initrd(int argc, char *argv[], uintptr_t _data, void *userdata) {
_cleanup_(sd_json_variant_unrefp) sd_json_variant *records = NULL;
_cleanup_fclose_ FILE *f = NULL;
uint32_t pcr_mask = UINT32_C(1) << TPM2_PCR_KERNEL_INITRD;
int r;
if (argc >= 2) {
f = fopen(argv[1], "re");
if (!f)
return log_error_errno(errno, "Failed to open '%s': %m", argv[1]);
}
r = make_pcrlock_record_from_stream(pcr_mask, f ?: stdin, &records);
if (r < 0)
return r;
r = write_pcrlock(records, PCRLOCK_KERNEL_INITRD_PATH);
if (r < 0)
return r;
return 0;
}
VERB_NOARG(verb_unlock_kernel_initrd, "unlock-kernel-initrd",
"Remove .pcrlock file for an initrd file");
static int verb_unlock_kernel_initrd(int argc, char *argv[], uintptr_t _data, void *userdata) {
return unlink_pcrlock(PCRLOCK_KERNEL_INITRD_PATH);
}
VERB(verb_lock_raw, "lock-raw", "[FILE]\0", VERB_ANY, 2, 0,
"Generate a .pcrlock file from raw data");
static int verb_lock_raw(int argc, char *argv[], uintptr_t _data, void *userdata) {
_cleanup_(sd_json_variant_unrefp) sd_json_variant *records = NULL;
_cleanup_fclose_ FILE *f = NULL;
int r;
if (arg_pcr_mask == 0)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "No PCR specified, refusing.");
if (argc >= 2) {
f = fopen(argv[1], "re");
if (!f)
return log_error_errno(errno, "Failed to open '%s': %m", argv[1]);
}
r = make_pcrlock_record_from_stream(arg_pcr_mask, f ?: stdin, &records);
if (r < 0)
return r;
return write_pcrlock(records, NULL);
}
VERB_NOARG(verb_unlock_simple, "unlock-raw",
"Remove .pcrlock file for raw data");
VERB_COMMON_HELP_AUTO_HIDDEN();
static int parse_argv(int argc, char *argv[], char ***ret_args) {
assert(argc >= 0);
assert(argv);
assert(ret_args);
OptionParser opts = { argc, argv };
bool auto_location = true;
int r;
FOREACH_OPTION_OR_RETURN(c, &opts)
switch (c) {
OPTION_COMMON_HELP:
return command_print_help();
OPTION_COMMON_VERSION:
return version();
OPTION_COMMON_NO_PAGER:
arg_pager_flags |= PAGER_DISABLE;
break;
OPTION_COMMON_JSON:
r = parse_json_argument(opts.arg, &arg_json_format_flags);
if (r <= 0)
return r;
break;
OPTION_LONG("full", NULL,
"Print full hash in measurement log"):
arg_abbreviate_hash = SIZE_MAX;
break;
OPTION_LONG("raw-description", NULL,
"Show raw firmware record data as description in table"):
arg_raw_description = true;
break;
OPTION_LONG("pcr", "NR",
"Generate .pcrlock for specified PCR"):
r = tpm2_parse_pcr_argument_to_mask(opts.arg, &arg_pcr_mask);
if (r < 0)
return log_error_errno(r, "Failed to parse PCR specification: %s", opts.arg);
break;
OPTION_LONG("nv-index", "NUMBER",
"Use the specified NV index, instead of a random one"):
if (isempty(opts.arg))
arg_nv_index = 0;
else {
uint32_t u;
r = safe_atou32_full(opts.arg, 16, &u);
if (r < 0)
return log_error_errno(r, "Failed to parse --nv-index= argument: %s", opts.arg);
if (u < TPM2_NV_INDEX_FIRST || u > TPM2_NV_INDEX_LAST)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Argument for --nv-index= outside of valid range 0x%" PRIx32 "…0x%" PRIx32 ": 0x%" PRIx32,
TPM2_NV_INDEX_FIRST, TPM2_NV_INDEX_LAST, u);
arg_nv_index = u;
}
break;
OPTION_LONG("components", "PATH",
"Directory to read .pcrlock files from"): {
_cleanup_free_ char *p = NULL;
r = parse_path_argument(opts.arg, /* suppress_root= */ false, &p);
if (r < 0)
return r;
r = strv_consume(&arg_components, TAKE_PTR(p));
if (r < 0)
return log_oom();
break;
}
OPTION_LONG("location", "START[:END]",
"Do not process components beyond this component name"): {
_cleanup_free_ char *start = NULL, *end = NULL;
const char *e;
auto_location = false;
if (isempty(opts.arg)) {
arg_location_start = mfree(arg_location_start);
arg_location_end = mfree(arg_location_end);
break;
}
e = strchr(opts.arg, ':');
if (e) {
start = strndup(opts.arg, e - opts.arg);
if (!start)
return log_oom();
end = strdup(e + 1);
if (!end)
return log_oom();
} else {
start = strdup(opts.arg);
if (!start)
return log_oom();
end = strdup(opts.arg);
if (!end)
return log_oom();
}
if (!filename_is_valid(start))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Location string invalid, refusing: %s", start);
if (!filename_is_valid(end))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Location string invalid, refusing: %s", end);
free_and_replace(arg_location_start, start);
free_and_replace(arg_location_end, end);
break;
}
OPTION_LONG("recovery-pin", "MODE",
"Controls whether to show, hide, or ask for a recovery PIN"):
arg_recovery_pin = recovery_pin_mode_from_string(opts.arg);
if (arg_recovery_pin < 0)
return log_error_errno(arg_recovery_pin, "Failed to parse --recovery-pin= mode: %s", opts.arg);
break;
OPTION_LONG("pcrlock", "PATH",
".pcrlock file to write expected PCR measurement to"):
if (empty_or_dash(opts.arg))
arg_pcrlock_path = mfree(arg_pcrlock_path);
else {
r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_pcrlock_path);
if (r < 0)
return r;
}
arg_pcrlock_auto = false;
break;
OPTION_LONG("policy", "PATH",
"JSON file to write policy output to"):
if (empty_or_dash(opts.arg))
arg_policy_path = mfree(arg_policy_path);
else {
r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_policy_path);
if (r < 0)
return r;
}
break;
OPTION_LONG("force", NULL,
"Write policy even if it matches existing policy"):
arg_force = true;
break;
OPTION_LONG("entry-token", "TOKEN",
"Boot entry token to use for this installation "
"(machine-id, os-id, os-image-id, auto, literal:…)"):
r = parse_boot_entry_token_type(opts.arg, &arg_entry_token_type, &arg_entry_token);
if (r < 0)
return r;
break;
OPTION_LONG("strict", "BOOL",
"Require all PCRs configured via --pcr= included in policy"):
r = parse_boolean_argument("--strict", opts.arg, &arg_strict);
if (r < 0)
return r;
break;
OPTION('q', "quiet", NULL, "Suppress unnecessary output"):
arg_quiet = true;
break;
OPTION_COMMON_INTROSPECT_CLI:
return introspect_cli(arg_json_format_flags);
}
if (auto_location) {
assert(!arg_location_start);
assert(!arg_location_end);
arg_location_start = strdup("760-");
if (!arg_location_start)
return log_oom();
arg_location_end = strdup("940-");
if (!arg_location_end)
return log_oom();
}
r = sd_varlink_invocation(SD_VARLINK_ALLOW_ACCEPT);
if (r < 0)
return log_error_errno(r, "Failed to check if invoked in Varlink mode: %m");
if (r > 0) {
arg_varlink = true;
arg_pager_flags |= PAGER_DISABLE;
}
*ret_args = option_parser_get_args(&opts);
return 1;
}
static int vl_method_read_event_log(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
_cleanup_(event_log_freep) EventLog *el = NULL;
uint64_t recnum = 0;
int r;
assert(link);
assert(FLAGS_SET(flags, SD_VARLINK_METHOD_MORE));
r = sd_varlink_dispatch(link, parameters, /* dispatch_table= */ NULL, /* userdata= */ NULL);
if (r != 0)
return r;
el = event_log_new();
if (!el)
return log_oom();
r = event_log_load(el, /* keep_fw_no_action= */ true);
if (r < 0)
return r;
r = sd_varlink_set_sentinel(link, NULL);
if (r < 0)
return r;
FOREACH_ARRAY(rr, el->records, el->n_records) {
_cleanup_(sd_json_variant_unrefp) sd_json_variant *rec_cel = NULL;
r = event_log_record_to_cel(*rr, &recnum, &rec_cel);
if (r < 0)
return r;
r = sd_varlink_replybo(link, SD_JSON_BUILD_PAIR_VARIANT("record", rec_cel));
if (r < 0)
return r;
}
return 0;
}
static int vl_method_list_components(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
_cleanup_(event_log_freep) EventLog *el = NULL;
int r;
assert(link);
assert(FLAGS_SET(flags, SD_VARLINK_METHOD_MORE));
r = sd_varlink_dispatch(link, parameters, /* dispatch_table= */ NULL, /* userdata= */ NULL);
if (r != 0)
return r;
r = event_log_load_and_process_components(&el);
if (r < 0)
return r;
r = sd_varlink_set_sentinel(link, NULL);
if (r < 0)
return r;
FOREACH_ARRAY(c, el->components, el->n_components) {
_cleanup_(sd_json_variant_unrefp) sd_json_variant *variants = NULL;
FOREACH_ARRAY(variant, (*c)->variants, (*c)->n_variants) {
r = sd_json_variant_append_arraybo(
&variants,
SD_JSON_BUILD_PAIR_STRING("id", (*variant)->id),
SD_JSON_BUILD_PAIR_STRING("path", (*variant)->path));
if (r < 0)
return r;
}
if (!variants) {
r = sd_json_variant_new_array(&variants, NULL, 0);
if (r < 0)
return r;
}
r = sd_varlink_replybo(
link,
SD_JSON_BUILD_PAIR_STRING("id", (*c)->id),
SD_JSON_BUILD_PAIR_VARIANT("variants", variants));
if (r < 0)
return r;
}
return 0;
}
typedef struct MethodMakePolicyParameters {
bool force;
} MethodMakePolicyParameters;
static int vl_method_make_policy(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
static const sd_json_dispatch_field dispatch_table[] = {
{ "force", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_stdbool, offsetof(MethodMakePolicyParameters, force), 0 },
{}
};
MethodMakePolicyParameters p = {};
int r;
assert(link);
r = sd_varlink_dispatch(link, parameters, dispatch_table, &p);
if (r != 0)
return r;
r = make_policy(p.force, /* recovery_pin_mode= */ RECOVERY_PIN_HIDE);
if (r < 0)
return r;
if (r == 0)
return sd_varlink_error(link, "io.systemd.PCRLock.NoChange", NULL);
return sd_varlink_reply(link, NULL);
}
static int vl_method_remove_policy(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
int r;
assert(link);
r = sd_varlink_dispatch(link, parameters, /* dispatch_table= */ NULL, /* userdata= */ NULL);
if (r != 0)
return r;
r = remove_policy();
if (r < 0)
return r;
return sd_varlink_reply(link, NULL);
}
typedef enum LockCategory {
LOCK_CATEGORY_FIRMWARE_CODE,
LOCK_CATEGORY_FIRMWARE_CONFIG,
LOCK_CATEGORY_SECUREBOOT_POLICY,
LOCK_CATEGORY_SECUREBOOT_AUTHORITY,
_LOCK_CATEGORY_MAX,
_LOCK_CATEGORY_INVALID = -EINVAL,
} LockCategory;
static const char* const lock_category_table[_LOCK_CATEGORY_MAX] = {
[LOCK_CATEGORY_FIRMWARE_CODE] = "firmwareCode",
[LOCK_CATEGORY_FIRMWARE_CONFIG] = "firmwareConfig",
[LOCK_CATEGORY_SECUREBOOT_POLICY] = "secureBootPolicy",
[LOCK_CATEGORY_SECUREBOOT_AUTHORITY] = "secureBootAuthority",
};
DEFINE_PRIVATE_STRING_TABLE_LOOKUP_FROM_STRING(lock_category, LockCategory);
static JSON_DISPATCH_ENUM_DEFINE(dispatch_lock_category, LockCategory, lock_category_from_string);
typedef struct MethodLockParameters {
LockCategory category;
bool lock;
} MethodLockParameters;
static int vl_method_lock(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
static const sd_json_dispatch_field dispatch_table[] = {
{ "category", SD_JSON_VARIANT_STRING, dispatch_lock_category, offsetof(MethodLockParameters, category), SD_JSON_MANDATORY },
{ "lock", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_stdbool, offsetof(MethodLockParameters, lock), 0 },
{}
};
MethodLockParameters p = {
.category = _LOCK_CATEGORY_INVALID,
.lock = true,
};
int r;
assert(link);
r = sd_varlink_dispatch(link, parameters, dispatch_table, &p);
if (r != 0)
return r;
switch (p.category) {
case LOCK_CATEGORY_FIRMWARE_CODE:
r = p.lock ? lock_firmware(/* is_code= */ true) : unlock_firmware(/* is_code= */ true);
break;
case LOCK_CATEGORY_FIRMWARE_CONFIG:
r = p.lock ? lock_firmware(/* is_code= */ false) : unlock_firmware(/* is_code= */ false);
break;
case LOCK_CATEGORY_SECUREBOOT_POLICY:
r = p.lock ? lock_secureboot_policy() : unlink_pcrlock(PCRLOCK_SECUREBOOT_POLICY_PATH);
break;
case LOCK_CATEGORY_SECUREBOOT_AUTHORITY:
r = p.lock ? lock_secureboot_authority() : unlink_pcrlock(PCRLOCK_SECUREBOOT_AUTHORITY_PATH);
break;
default:
assert_not_reached();
}
if (r < 0)
return r;
return sd_varlink_reply(link, NULL);
}
static int vl_method_on_completed_update(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
int r;
assert(link);
/* Triggered by systemd-sysupdate after an update completed. We deliberately ignore all parameters
* (we don't even dispatch them) and simply recompute the PCR policy unconditionally, since the set
* of measured components might have changed. */
/* Only honour update notifications if they come from root */
r = varlink_check_privileged_peer(link);
if (r < 0)
return r;
r = make_policy(/* force= */ false, /* recovery_pin_mode= */ RECOVERY_PIN_HIDE);
if (r < 0)
return r;
return sd_varlink_reply(link, NULL);
}
static int run(int argc, char *argv[]) {
int r;
LIBBLKID_NOTE(recommended);
LIBCRYPTO_NOTE(required);
LIBSELINUX_NOTE(recommended);
TPM2_NOTE(suggested);
log_setup();
r = mac_init();
if (r < 0)
return r;
char **args = NULL;
r = parse_argv(argc, argv, &args);
if (r <= 0)
return r;
r = dlopen_libcrypto(LOG_ERR);
if (r < 0)
return r;
if (arg_varlink) {
_cleanup_(sd_varlink_server_unrefp) sd_varlink_server *varlink_server = NULL;
/* Invocation as Varlink service */
r = varlink_server_new(&varlink_server,
SD_VARLINK_SERVER_ROOT_ONLY | SD_VARLINK_SERVER_MYSELF_ONLY,
/* userdata= */ NULL);
if (r < 0)
return log_error_errno(r, "Failed to allocate Varlink server: %m");
r = sd_varlink_server_add_interface_many(
varlink_server,
&vl_interface_io_systemd_PCRLock,
&vl_interface_io_systemd_SysUpdate_Notify);
if (r < 0)
return log_error_errno(r, "Failed to add Varlink interfaces: %m");
r = sd_varlink_server_bind_method_many(
varlink_server,
"io.systemd.PCRLock.ReadEventLog", vl_method_read_event_log,
"io.systemd.PCRLock.ListComponents", vl_method_list_components,
"io.systemd.PCRLock.MakePolicy", vl_method_make_policy,
"io.systemd.PCRLock.RemovePolicy", vl_method_remove_policy,
"io.systemd.PCRLock.Lock", vl_method_lock,
"io.systemd.SysUpdate.Notify.OnCompletedUpdate", vl_method_on_completed_update);
if (r < 0)
return log_error_errno(r, "Failed to bind Varlink methods: %m");
r = sd_varlink_server_loop_auto(varlink_server);
if (r < 0)
return log_error_errno(r, "Failed to run Varlink event loop: %m");
return EXIT_SUCCESS;
}
return dispatch_verb(args, NULL);
}
DEFINE_MAIN_FUNCTION_WITH_POSITIVE_FAILURE(run);