HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/pcrlock/pcrlock.c
Git blob: c798c78489257ecc6f87eead6fa509ad2027c886
Lines 4001–5000 of 5,877
&IOVEC_MAKE(auth.buffer, auth.size),
/* ret_policy_digest= */ NULL);
if (r < 0)
return log_error_errno(r, "Failed to submit authentication value policy: %m");
log_debug("Calculating new PCR policy to write...");
TPM2B_DIGEST new_super_pcr_policy_digest = TPM2B_DIGEST_MAKE(NULL, TPM2_SHA256_DIGEST_SIZE);
usec_t pcr_policy_start_usec = now(CLOCK_MONOTONIC);
r = tpm2_calculate_policy_super_pcr(
&new_prediction,
el->primary_algorithm,
&new_super_pcr_policy_digest);
if (r < 0)
return log_error_errno(r, "Failed to calculate super PCR policy: %m");
log_info("Calculated new PCR policy in %s.", FORMAT_TIMESPAN(usec_sub_unsigned(now(CLOCK_MONOTONIC), pcr_policy_start_usec), 1));
log_debug("Writing new PCR policy to NV index...");
r = tpm2_write_policy_nv_index(
tc,
policy_session,
nv_index,
nv_handle,
&new_super_pcr_policy_digest);
if (r < 0)
return log_error_errno(r, "Failed to write to NV index: %m");
log_info("Updated NV index in %s.", FORMAT_TIMESPAN(usec_sub_unsigned(now(CLOCK_MONOTONIC), nv_index_start_usec), 1));
assert(iovec_is_set(&pin_public) == iovec_is_set(&pin_private));
if (!iovec_is_set(&pin_public)) {
TPM2B_DIGEST authnv_policy_digest = TPM2B_DIGEST_MAKE(NULL, TPM2_SHA256_DIGEST_SIZE);
r = tpm2_calculate_policy_authorize_nv(&nv_public, &authnv_policy_digest);
if (r < 0)
return log_error_errno(r, "Failed to calculate AuthorizeNV policy: %m");
struct iovec data = {
.iov_base = auth.buffer,
.iov_len = auth.size,
};
usec_t pin_seal_start_usec = now(CLOCK_MONOTONIC);
log_debug("Sealing PIN to NV index policy...");
r = tpm2_seal_data(
tc,
&data,
srk_handle,
encryption_session,
&authnv_policy_digest,
&pin_public,
&pin_private);
if (r < 0)
return log_error_errno(r, "Failed to seal PIN to NV auth policy: %m");
log_info("Sealed PIN in %s.", FORMAT_TIMESPAN(usec_sub_unsigned(now(CLOCK_MONOTONIC), pin_seal_start_usec), 1));
}
if (!iovec_is_set(&nv_blob)) {
r = tpm2_serialize(tc, nv_handle, &nv_blob);
if (r < 0)
return log_error_errno(r, "Failed to serialize NV index TR: %m");
}
if (!iovec_is_set(&srk_blob)) {
r = tpm2_serialize(tc, srk_handle, &srk_blob);
if (r < 0)
return log_error_errno(r, "Failed to serialize SRK index TR: %m");
}
if (!iovec_is_set(&nv_public_blob)) {
r = tpm2_marshal_nv_public(&nv_public, &nv_public_blob.iov_base, &nv_public_blob.iov_len);
if (r < 0)
return log_error_errno(r, "Failed to marshal NV public area: %m");
}
_cleanup_(sd_json_variant_unrefp) sd_json_variant *new_configuration_json = NULL;
r = sd_json_buildo(
&new_configuration_json,
SD_JSON_BUILD_PAIR_STRING("pcrBank", tpm2_hash_alg_to_string(el->primary_algorithm)),
SD_JSON_BUILD_PAIR_VARIANT("pcrValues", new_prediction_json),
SD_JSON_BUILD_PAIR_INTEGER("nvIndex", nv_index),
JSON_BUILD_PAIR_IOVEC_BASE64("nvHandle", &nv_blob),
JSON_BUILD_PAIR_IOVEC_BASE64("nvPublic", &nv_public_blob),
JSON_BUILD_PAIR_IOVEC_BASE64("srkHandle", &srk_blob),
JSON_BUILD_PAIR_IOVEC_BASE64("pinPublic", &pin_public),
JSON_BUILD_PAIR_IOVEC_BASE64("pinPrivate", &pin_private));
if (r < 0)
return log_error_errno(r, "Failed to generate JSON: %m");
_cleanup_free_ char *text = NULL;
r = sd_json_variant_format(new_configuration_json, 0, &text);
if (r < 0)
return log_error_errno(r, "Failed to format new configuration to JSON: %m");
const char *path = arg_policy_path ?: (in_initrd() ? "/run/systemd/pcrlock.json" : "/var/lib/systemd/pcrlock.json");
r = write_string_file(path, text, WRITE_STRING_FILE_CREATE|WRITE_STRING_FILE_ATOMIC|WRITE_STRING_FILE_SYNC|WRITE_STRING_FILE_MKDIR_0755|WRITE_STRING_FILE_LABEL);
if (r < 0)
return log_error_errno(r, "Failed to write new configuration to '%s': %m", path);
if (!arg_policy_path && !in_initrd()) {
r = remove_policy_file("/run/systemd/pcrlock.json");
if (r < 0)
return r;
}
log_info("Written new policy to '%s' and digest to TPM2 NV index 0x%x.", path, nv_index);
(void) write_boot_policy_file(text);
log_info("Overall time spent: %s", FORMAT_TIMESPAN(usec_sub_unsigned(now(CLOCK_MONOTONIC), start_usec), 1));
return 1; /* installed new policy */
}
VERB_NOARG(verb_make_policy, "make-policy",
"Predict PCR values and generate TPM2 policy from it");
static int verb_make_policy(int argc, char *argv[], uintptr_t _data, void *userdata) {
int r;
r = make_policy(arg_force, arg_recovery_pin);
if (r < 0)
return r;
return 0;
}
static int undefine_policy_nv_index(
uint32_t nv_index,
const struct iovec *nv_blob,
const struct iovec *srk_blob) {
int r;
assert(nv_blob);
assert(srk_blob);
_cleanup_(tpm2_context_unrefp) Tpm2Context *tc = NULL;
r = tpm2_context_new_or_warn(/* device= */ NULL, &tc);
if (r < 0)
return r;
_cleanup_(tpm2_handle_freep) Tpm2Handle *srk_handle = NULL;
r = tpm2_deserialize(
tc,
srk_blob,
&srk_handle);
if (r < 0)
return log_error_errno(r, "Failed to deserialize SRK TR: %m");
_cleanup_(tpm2_handle_freep) Tpm2Handle *nv_handle = NULL;
r = tpm2_deserialize(
tc,
nv_blob,
&nv_handle);
if (r < 0)
return log_error_errno(r, "Failed to deserialize NV TR: %m");
_cleanup_(tpm2_handle_freep) Tpm2Handle *encryption_session = NULL;
r = tpm2_make_encryption_session(
tc,
srk_handle,
/* bind_key= */ &TPM2_HANDLE_NONE,
&encryption_session);
if (r < 0)
return r;
r = tpm2_undefine_nv_index(
tc,
encryption_session,
nv_index,
nv_handle);
if (r < 0)
return r;
log_info("Removed NV index 0x%x", nv_index);
return 0;
}
static int remove_policy(void) {
int ret = 0, r;
_cleanup_(tpm2_pcrlock_policy_done) Tpm2PCRLockPolicy policy = {};
r = tpm2_pcrlock_policy_load(arg_policy_path, &policy);
if (r == 0) {
log_info("No policy found.");
return 0;
}
if (r < 0)
log_notice("Failed to load old policy file, assuming it is corrupted, removing.");
else {
r = undefine_policy_nv_index(policy.nv_index, &policy.nv_handle, &policy.srk_handle);
if (r < 0)
log_notice("Failed to remove NV index, assuming data out of date, removing policy file.");
RET_GATHER(ret, r);
}
if (arg_policy_path)
RET_GATHER(ret, remove_policy_file(arg_policy_path));
else {
RET_GATHER(ret, remove_policy_file("/var/lib/systemd/pcrlock.json"));
RET_GATHER(ret, remove_policy_file("/run/systemd/pcrlock.json"));
}
_cleanup_free_ char *boot_policy_file = NULL;
r = determine_boot_policy_file(&boot_policy_file, /* ret_credential_name= */ NULL);
if (r == 0)
log_info("Did not find XBOOTLDR/ESP partition, not removing boot policy file.");
else if (r > 0) {
RET_GATHER(ret, remove_policy_file(boot_policy_file));
} else
RET_GATHER(ret, r);
return ret;
}
VERB_NOARG(verb_remove_policy, "remove-policy",
"Remove TPM2 policy");
static int verb_remove_policy(int argc, char *argv[], uintptr_t _data, void *userdata) {
return remove_policy();
}
static int test_tpm2_support_pcrlock(Tpm2Support *ret) {
int r;
assert(ret);
/* First check basic support */
Tpm2Support s = tpm2_support();
/* If basic support is available, let's also check the things we need for systemd-pcrlock */
if (s == TPM2_SUPPORT_FULL) {
_cleanup_(tpm2_context_unrefp) Tpm2Context *tc = NULL;
r = tpm2_context_new_or_warn(/* device= */ NULL, &tc);
if (r < 0)
return r;
/* We strictly need TPM2_CC_PolicyAuthorizeNV for systemd-pcrlock to work */
SET_FLAG(s, TPM2_SUPPORT_AUTHORIZE_NV, tpm2_supports_command(tc, TPM2_CC_PolicyAuthorizeNV));
log_debug("PolicyAuthorizeNV supported: %s", yes_no(FLAGS_SET(s, TPM2_SUPPORT_AUTHORIZE_NV)));
/* We also strictly need SHA-256 to work */
SET_FLAG(s, TPM2_SUPPORT_SHA256, tpm2_supports_alg(tc, TPM2_ALG_SHA256));
log_debug("SHA-256 supported: %s", yes_no(FLAGS_SET(s, TPM2_SUPPORT_SHA256)));
}
*ret = s;
return 0;
}
VERB_NOARG(verb_is_supported, "is-supported",
"Tests if TPM2 supports necessary features");
static int verb_is_supported(int argc, char *argv[], uintptr_t _data, void *userdata) {
int r;
Tpm2Support s;
r = test_tpm2_support_pcrlock(&s);
if (r < 0)
return r;
if (!arg_quiet) {
if (s == (TPM2_SUPPORT_FULL|TPM2_SUPPORT_API_PCRLOCK))
printf("%syes%s\n", ansi_green(), ansi_normal());
else if (FLAGS_SET(s, TPM2_SUPPORT_FULL))
printf("%sobsolete%s\n", ansi_red(), ansi_normal());
else if (s == TPM2_SUPPORT_NONE)
printf("%sno%s\n", ansi_red(), ansi_normal());
else
printf("%spartial%s\n", ansi_yellow(), ansi_normal());
}
assert_cc((TPM2_SUPPORT_API|TPM2_SUPPORT_API_PCRLOCK) <= 255); /* make sure this is safe to use as process exit status */
return ~s & (TPM2_SUPPORT_API|TPM2_SUPPORT_API_PCRLOCK);
}
static int event_log_record_is_action_calling_efi_app(const EventLogRecord *rec) {
_cleanup_free_ char *d = NULL;
int r;
assert(rec);
/* Recognizes the special EV_EFI_ACTION that is issues when the firmware passes control to the boot loader. */
if (!EVENT_LOG_RECORD_IS_FIRMWARE(rec))
return false;
if (rec->pcr != TPM2_PCR_BOOT_LOADER_CODE)
return false;
if (rec->firmware_event_type != EV_EFI_ACTION)
return false;
if (rec->event_payload_valid != EVENT_PAYLOAD_VALID_YES) /* Insist the record is consistent */
return false;
r = make_cstring(rec->firmware_payload, rec->firmware_payload_size, MAKE_CSTRING_ALLOW_TRAILING_NUL, &d);
if (r < 0)
return r;
return streq(d, "Calling EFI Application from Boot Option");
}
static void enable_json_sse(void) {
/* We shall write this to a single output stream? We have to output two files, hence try to be smart
* and enable JSON SSE */
if (!arg_pcrlock_path && arg_pcrlock_auto)
return;
if (FLAGS_SET(arg_json_format_flags, SD_JSON_FORMAT_SSE))
return;
log_notice("Enabling JSON_SEQ mode, since writing two .pcrlock files to single output.");
arg_json_format_flags |= SD_JSON_FORMAT_SSE;
}
static bool event_log_record_is_separator(const EventLogRecord *rec) {
assert(rec);
/* Recognizes EV_SEPARATOR events */
if (!EVENT_LOG_RECORD_IS_FIRMWARE(rec))
return false;
if (rec->firmware_event_type != EV_SEPARATOR)
return false;
return rec->event_payload_valid == EVENT_PAYLOAD_VALID_YES; /* Insist the record is consistent */
}
VERB_GROUP("Protections");
static int lock_firmware(bool is_code) {
_cleanup_(sd_json_variant_unrefp) sd_json_variant *array_early = NULL, *array_late = NULL;
_cleanup_(event_log_freep) EventLog *el = NULL;
uint32_t always_mask, separator_mask, separator_seen_mask = 0, action_seen_mask = 0;
const char *default_pcrlock_early_path, *default_pcrlock_late_path;
int r;
enable_json_sse();
/* The PCRs we intend to cover. Note that we measure firmware, external *and* boot loader code/config
* here – but the latter only until the "separator" events are seen, which tell us where transition
* into OS boot loader happens. This reflects the fact that on some systems the firmware already
* measures some firmware-supplied apps into PCR 4. (e.g. Thinkpad X1 Gen9) */
if (is_code) {
always_mask = (UINT32_C(1) << TPM2_PCR_PLATFORM_CODE) | /* → 0 */
(UINT32_C(1) << TPM2_PCR_EXTERNAL_CODE); /* → 2 */
separator_mask = UINT32_C(1) << TPM2_PCR_BOOT_LOADER_CODE; /* → 4 */
default_pcrlock_early_path = PCRLOCK_FIRMWARE_CODE_EARLY_PATH;
default_pcrlock_late_path = PCRLOCK_FIRMWARE_CODE_LATE_PATH;
} else {
always_mask = (UINT32_C(1) << TPM2_PCR_PLATFORM_CONFIG) | /* → 1 */
(UINT32_C(1) << TPM2_PCR_EXTERNAL_CONFIG); /* → 3 */
separator_mask = UINT32_C(1) << TPM2_PCR_BOOT_LOADER_CONFIG; /* → 5 */
default_pcrlock_early_path = PCRLOCK_FIRMWARE_CONFIG_EARLY_PATH;
default_pcrlock_late_path = PCRLOCK_FIRMWARE_CONFIG_LATE_PATH;
}
el = event_log_new();
if (!el)
return log_oom();
r = event_log_add_algorithms_from_environment(el);
if (r < 0)
return r;
r = event_log_load(el, /* keep_fw_no_action= */ false);
if (r < 0)
return r;
r = event_log_read_pcrs(el);
if (r < 0)
return r;
r = event_log_calculate_pcrs(el);
if (r < 0)
return r;
r = event_log_validate_record_hashes(el);
if (r < 0)
return r;
/* Before we base anything on the event log records for any of the selected PCRs, let's check that
* the event log state checks out for them. */
r = event_log_pcr_mask_checks_out(el, always_mask|separator_mask);
if (r < 0)
return r;
// FIXME: before doing this, validate ahead-of-time that EV_SEPARATOR records exist for all entries,
// and exactly once
FOREACH_ARRAY(rr, el->records, el->n_records) {
_cleanup_(sd_json_variant_unrefp) sd_json_variant *digests = NULL;
EventLogRecord *rec = *rr;
uint32_t bit = UINT32_C(1) << rec->pcr;
if (!EVENT_LOG_RECORD_IS_FIRMWARE(rec))
continue;
if (!FLAGS_SET(always_mask, bit) &&
!(FLAGS_SET(separator_mask, bit) && !FLAGS_SET(separator_seen_mask|action_seen_mask, bit)))
continue;
/* If we hit the separator record, we stop processing the PCRs listed in `separator_mask` */
if (event_log_record_is_separator(rec)) {
separator_seen_mask |= bit;
continue;
}
/* If we hit the special "Calling EFI Application from Boot Option" action we treat this the
* same as a separator here, as that's where firmware passes control to boot loader. Note
* that some EFI implementations forget to generate one of them. */
r = event_log_record_is_action_calling_efi_app(rec);
if (r < 0)
return log_error_errno(r, "Failed to check if event is 'Calling EFI Application from Boot Option' action: %m");
if (r > 0) {
action_seen_mask |= bit;
continue;
}
LIST_FOREACH(banks, bank, rec->banks) {
r = sd_json_variant_append_arraybo(
&digests,
SD_JSON_BUILD_PAIR_STRING("hashAlg", tpm2_hash_alg_to_string(bank->algorithm)),
SD_JSON_BUILD_PAIR("digest", SD_JSON_BUILD_HEX(bank->hash.buffer, bank->hash.size)));
if (r < 0)
return log_error_errno(r, "Failed to build digests array: %m");
}
r = sd_json_variant_append_arraybo(
FLAGS_SET(separator_seen_mask, bit) ? &array_late : &array_early,
SD_JSON_BUILD_PAIR_UNSIGNED("pcr", rec->pcr),
SD_JSON_BUILD_PAIR_VARIANT("digests", digests));
if (r < 0)
return log_error_errno(r, "Failed to build record array: %m");
}
r = write_pcrlock(array_early, default_pcrlock_early_path);
if (r < 0)
return r;
return write_pcrlock(array_late, default_pcrlock_late_path);
}
VERB(verb_lock_firmware, "lock-firmware-code", NULL, VERB_ANY, 2, 0,
"Generate a .pcrlock file from current firmware code");
static int verb_lock_firmware(int argc, char *argv[], uintptr_t _data, void *userdata) {
return lock_firmware(endswith(argv[0], "firmware-code"));
}
static int unlock_firmware(bool is_code) {
const char *default_pcrlock_early_path, *default_pcrlock_late_path;
int r;
if (is_code) {
default_pcrlock_early_path = PCRLOCK_FIRMWARE_CODE_EARLY_PATH;
default_pcrlock_late_path = PCRLOCK_FIRMWARE_CODE_LATE_PATH;
} else {
default_pcrlock_early_path = PCRLOCK_FIRMWARE_CONFIG_EARLY_PATH;
default_pcrlock_late_path = PCRLOCK_FIRMWARE_CONFIG_LATE_PATH;
}
r = unlink_pcrlock(default_pcrlock_early_path);
if (r < 0)
return r;
if (arg_pcrlock_path) /* if the path is specified don't delete the same thing twice */
return 0;
r = unlink_pcrlock(default_pcrlock_late_path);
if (r < 0)
return r;
return 0;
}
VERB_NOARG(verb_unlock_firmware, "unlock-firmware-code",
"Remove .pcrlock file for firmware code");
static int verb_unlock_firmware(int argc, char *argv[], uintptr_t _data, void *userdata) {
return unlock_firmware(endswith(argv[0], "firmware-code"));
}
VERB(verb_lock_firmware, "lock-firmware-config", NULL, VERB_ANY, 2, 0,
"Generate a .pcrlock file from current firmware configuration");
VERB_NOARG(verb_unlock_firmware, "unlock-firmware-config",
"Remove .pcrlock file for firmware configuration");
static int lock_secureboot_policy(void) {
static const struct {
sd_id128_t id;
const char *name;
int synthesize_empty; /* 0 → fail, > 0 → synthesize empty db, < 0 → skip */
} variables[] = {
{ EFI_VENDOR_GLOBAL, "SecureBoot", 0 },
{ EFI_VENDOR_GLOBAL, "PK", 1 },
{ EFI_VENDOR_GLOBAL, "KEK", 1 },
{ EFI_VENDOR_DATABASE, "db", 1 },
{ EFI_VENDOR_DATABASE, "dbx", 1 },
{ EFI_VENDOR_DATABASE, "dbt", -1 },
{ EFI_VENDOR_DATABASE, "dbr", -1 },
};
_cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL;
int r;
/* Generates expected records from the current SecureBoot state, as readable in the EFI variables
* right now. */
FOREACH_ELEMENT(vv, variables) {
_cleanup_(sd_json_variant_unrefp) sd_json_variant *record = NULL;
_cleanup_free_ char *name = NULL;
if (asprintf(&name, "%s-" SD_ID128_UUID_FORMAT_STR, vv->name, SD_ID128_FORMAT_VAL(vv->id)) < 0)
return log_oom();
_cleanup_free_ void *data = NULL;
size_t data_size;
r = efi_get_variable(name, NULL, &data, &data_size);
if (r < 0) {
if (r != -ENOENT || vv->synthesize_empty == 0)
return log_error_errno(r, "Failed to read EFI variable '%s': %m", name);
if (vv->synthesize_empty < 0)
continue;
/* If the main database variables are not set we don't consider this an error, but
* measure an empty database instead. */
log_debug("EFI variable %s is not set, synthesizing empty variable for measurement.", name);
data_size = 0;
}
_cleanup_free_ char16_t* name16 = utf8_to_utf16(vv->name, SIZE_MAX);
if (!name16)
return log_oom();
size_t name16_bytes = char16_strlen(name16) * 2;
size_t vdata_size = offsetof(UEFI_VARIABLE_DATA, unicodeName) + name16_bytes + data_size;
_cleanup_free_ UEFI_VARIABLE_DATA *vdata = malloc(vdata_size);
if (!vdata)
return log_oom();
*vdata = (UEFI_VARIABLE_DATA) {
.unicodeNameLength = name16_bytes / 2,
.variableDataLength = data_size,
};
efi_id128_to_guid(vv->id, vdata->variableName);
memcpy(mempcpy(vdata->unicodeName, name16, name16_bytes), data, data_size);
r = make_pcrlock_record(TPM2_PCR_SECURE_BOOT_POLICY /* =7 */, vdata, vdata_size, &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 to JSON array: %m");
}
return write_pcrlock(array, PCRLOCK_SECUREBOOT_POLICY_PATH);
}
VERB_NOARG(verb_lock_secureboot_policy, "lock-secureboot-policy",
"Generate a .pcrlock file from current SecureBoot policy");
static int verb_lock_secureboot_policy(int argc, char *argv[], uintptr_t _data, void *userdata) {
return lock_secureboot_policy();
}
VERB_NOARG(verb_unlock_secureboot_policy, "unlock-secureboot-policy",
"Remove .pcrlock file for SecureBoot policy");
static int verb_unlock_secureboot_policy(int argc, char *argv[], uintptr_t _data, void *userdata) {
return unlink_pcrlock(PCRLOCK_SECUREBOOT_POLICY_PATH);
}
static int event_log_record_is_secureboot_variable(EventLogRecord *rec, sd_id128_t uuid, const char *name) {
_cleanup_free_ char *found_name = NULL;
sd_id128_t found_uuid;
int r;
assert(rec);
assert(name);
if (!EVENT_LOG_RECORD_IS_FIRMWARE(rec))
return false;
if (rec->pcr != TPM2_PCR_SECURE_BOOT_POLICY)
return false;
if (rec->event_payload_valid != EVENT_PAYLOAD_VALID_YES)
return false;
if (rec->firmware_event_type != EV_EFI_VARIABLE_DRIVER_CONFIG)
return false;
r = event_log_record_parse_variable_data(rec, &found_uuid, &found_name);
if (r == -EBADMSG)
return false;
if (r < 0)
return r;
if (!sd_id128_equal(found_uuid, uuid))
return false;
return streq(found_name, name);
}
static bool event_log_record_is_secureboot_authority(EventLogRecord *rec) {
assert(rec);
if (!EVENT_LOG_RECORD_IS_FIRMWARE(rec))
return false;
if (rec->pcr != TPM2_PCR_SECURE_BOOT_POLICY)
return false;
if (rec->event_payload_valid != EVENT_PAYLOAD_VALID_YES)
return false;
return rec->firmware_event_type == EV_EFI_VARIABLE_AUTHORITY;
}
static int event_log_ensure_secureboot_consistency(EventLog *el) {
static const struct {
sd_id128_t id;
const char *name;
bool required;
} table[] = {
{ EFI_VENDOR_GLOBAL, "SecureBoot", true },
{ EFI_VENDOR_GLOBAL, "PK", true },
{ EFI_VENDOR_GLOBAL, "KEK", true },
{ EFI_VENDOR_DATABASE, "db", true },
{ EFI_VENDOR_DATABASE, "dbx", true },
{ EFI_VENDOR_DATABASE, "dbt", false },
{ EFI_VENDOR_DATABASE, "dbr", false },
// FIXME: ensure we also find the separator here
};
EventLogRecord *records[ELEMENTSOF(table)] = {};
EventLogRecord *first_authority = NULL;
assert(el);
/* Ensures that the PCR 7 records are complete and in order. Before we lock down PCR 7 we want to
* ensure its state is actually consistent. */
FOREACH_ARRAY(rr, el->records, el->n_records) {
EventLogRecord *rec = *rr;
size_t found = SIZE_MAX;
if (event_log_record_is_secureboot_authority(rec)) {
if (first_authority)
continue;
first_authority = rec;
// FIXME: also check that each authority record's data is also listed in 'db'
continue;
}
for (size_t i = 0; i < ELEMENTSOF(table); i++)
if (event_log_record_is_secureboot_variable(rec, table[i].id, table[i].name)) {
found = i;
break;
}
if (found == SIZE_MAX)
continue;
/* Require the authority records always come *after* database measurements */
if (first_authority)
return log_error_errno(SYNTHETIC_ERRNO(EBADMSG), "SecureBoot authority before variable, refusing.");
/* Check for duplicates */
if (records[found])
return log_error_errno(SYNTHETIC_ERRNO(EBADMSG), "Duplicate '%s' record, refusing.", rec->description);
/* Check for order */
for (size_t j = found + 1; j < ELEMENTSOF(table); j++)
if (records[j])
return log_error_errno(SYNTHETIC_ERRNO(EBADMSG), "'%s' record before '%s' record, refusing.", records[j]->description, rec->description);
records[found] = rec;
}
/* Check for existence */
for (size_t i = 0; i < ELEMENTSOF(table); i++)
if (table[i].required && !records[i])
return log_error_errno(SYNTHETIC_ERRNO(EBADMSG), "Required record '%s' not found, refusing.", table[i].name);
/* At this point we know that all required variables have been measured, in the right order. */
return 0;
}
static int lock_secureboot_authority(void) {
_cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL;
_cleanup_(event_log_freep) EventLog *el = NULL;
int r;
/* Lock down the EV_EFI_VARIABLE_AUTHORITY records from the existing log. Note that there's not too
* much value in locking this down too much, since it stores only the result of the primary database
* checks, and that's what we should bind policy to. Moreover it's hard to predict, since extension
* card firmware validation will result in additional records here. */
if (!is_efi_secure_boot()) {
log_info("SecureBoot disabled, not generating authority .pcrlock file.");
return unlink_pcrlock(PCRLOCK_SECUREBOOT_AUTHORITY_PATH);
}
el = event_log_new();
if (!el)
return log_oom();
r = event_log_add_algorithms_from_environment(el);
if (r < 0)
return r;
r = event_log_load(el, /* keep_fw_no_action= */ false);
if (r < 0)
return r;
r = event_log_read_pcrs(el);
if (r < 0)
return r;
r = event_log_calculate_pcrs(el);
if (r < 0)
return r;
/* Before we base anything on the event log records, let's check that the event log state checks
* out. */
r = event_log_pcr_mask_checks_out(el, UINT32_C(1) << TPM2_PCR_SECURE_BOOT_POLICY);
if (r < 0)
return r;
r = event_log_validate_record_hashes(el);
if (r < 0)
return r;
r = event_log_ensure_secureboot_consistency(el);
if (r < 0)
return r;
FOREACH_ARRAY(rr, el->records, el->n_records) {
_cleanup_(sd_json_variant_unrefp) sd_json_variant *digests = NULL;
EventLogRecord *rec = *rr;
if (!event_log_record_is_secureboot_authority(rec))
continue;
log_debug("Locking down authority '%s'.", strna(rec->description));
LIST_FOREACH(banks, bank, rec->banks) {
r = sd_json_variant_append_arraybo(
&digests,
SD_JSON_BUILD_PAIR_STRING("hashAlg", tpm2_hash_alg_to_string(bank->algorithm)),
SD_JSON_BUILD_PAIR("digest", SD_JSON_BUILD_HEX(bank->hash.buffer, bank->hash.size)));
if (r < 0)
return log_error_errno(r, "Failed to build digests array: %m");
}
r = sd_json_variant_append_arraybo(
&array,
SD_JSON_BUILD_PAIR_UNSIGNED("pcr", rec->pcr),
SD_JSON_BUILD_PAIR_VARIANT("digests", digests));
if (r < 0)
return log_error_errno(r, "Failed to build record array: %m");
}
return write_pcrlock(array, PCRLOCK_SECUREBOOT_AUTHORITY_PATH);
}
VERB_NOARG(verb_lock_secureboot_authority, "lock-secureboot-authority",
"Generate a .pcrlock file from current SecureBoot authority");
static int verb_lock_secureboot_authority(int argc, char *argv[], uintptr_t _data, void *userdata) {
return lock_secureboot_authority();
}
VERB_NOARG(verb_unlock_secureboot_authority, "unlock-secureboot-authority",
"Remove .pcrlock file for SecureBoot authority");
static int verb_unlock_secureboot_authority(int argc, char *argv[], uintptr_t _data, void *userdata) {
return unlink_pcrlock(PCRLOCK_SECUREBOOT_AUTHORITY_PATH);
}
VERB(verb_lock_gpt, "lock-gpt", "[DISK]\0", VERB_ANY, 2, 0,
"Generate a .pcrlock file from GPT header");
static int verb_lock_gpt(int argc, char *argv[], uintptr_t _data, void *userdata) {
_cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL, *record = NULL;
_cleanup_(sd_device_unrefp) sd_device *d = NULL;
uint8_t h[2 * 4096]; /* space for at least two 4K sectors. GPT header should definitely be in here */
uint64_t start, n_members, member_size;
_cleanup_close_ int fd = -EBADF;
const GptHeader *p;
size_t found = 0;
ssize_t n;
int r;
r = block_device_new_from_path(
argc >= 2 ? argv[1] : "/",
BLOCK_DEVICE_LOOKUP_WHOLE_DISK|BLOCK_DEVICE_LOOKUP_BACKING|BLOCK_DEVICE_LOOKUP_ORIGINATING,
&d);
if (r < 0)
return log_error_errno(r, "Failed to determine root block device: %m");
fd = sd_device_open(d, O_CLOEXEC|O_RDONLY|O_NOCTTY);
if (fd < 0)
return log_error_errno(fd, "Failed to open root block device: %m");
n = pread(fd, &h, sizeof(h), 0);
if (n < 0)
return log_error_errno(errno, "Failed to read GPT header of block device: %m");
if ((size_t) n != sizeof(h))
return log_error_errno(SYNTHETIC_ERRNO(EIO), "Short read trying to read GPT header.");
/* Try a couple of sector sizes */
for (size_t sz = 512; sz <= 4096; sz <<= 1) {
assert(sizeof(h) >= sz * 2);
p = (const GptHeader*) (h + sz); /* 2nd sector */
if (!gpt_header_has_signature(p))
continue;
if (found != 0)
return log_error_errno(SYNTHETIC_ERRNO(ENOTUNIQ),
"Disk has partition table for multiple sector sizes, refusing.");
found = sz;
}
if (found == 0)
return log_error_errno(SYNTHETIC_ERRNO(EBADMSG),
"Disk does not have GPT partition table, refusing.");
p = (const GptHeader*) (h + found);
if (le32toh(p->header_size) > found)
return log_error_errno(SYNTHETIC_ERRNO(EBADMSG),
"GPT header size over long (%" PRIu32 "), refusing.", le32toh(p->header_size));
start = le64toh(p->partition_entry_lba);
if (start > UINT64_MAX / found)
return log_error_errno(SYNTHETIC_ERRNO(EBADMSG),
"Partition table start offset overflow, refusing.");
member_size = le32toh(p->size_of_partition_entry);
if (member_size < sizeof(GptPartitionEntry))
return log_error_errno(SYNTHETIC_ERRNO(EBADMSG),
"Partition entry size too short, refusing.");
n_members = le32toh(p->number_of_partition_entries);
uint64_t member_bufsz = n_members * member_size;
if (member_bufsz > 1U*1024U*1024U)
return log_error_errno(SYNTHETIC_ERRNO(EBADMSG),
"Partition table size too large, refusing.");
member_bufsz = ROUND_UP(member_bufsz, found);
_cleanup_free_ void *members = malloc(member_bufsz);
if (!members)
return log_oom();
n = pread(fd, members, member_bufsz, start * found);
if (n < 0)
return log_error_errno(errno, "Failed to read GPT partition table entries: %m");
if ((size_t) n != member_bufsz)
return log_error_errno(SYNTHETIC_ERRNO(EIO), "Short read while reading GPT partition table entries.");
size_t vdata_size = le32toh(p->header_size) + sizeof(le64_t) + member_size * n_members;
_cleanup_free_ void *vdata = malloc0(vdata_size);
if (!vdata)
return log_oom();
void *n_measured_entries = mempcpy(vdata, p, sizeof(GptHeader)); /* n_measured_entries is a 64bit value */
void *qq = (uint8_t*) n_measured_entries + sizeof(le64_t);
for (uint64_t i = 0; i < n_members; i++) {
const GptPartitionEntry *entry = (const GptPartitionEntry*) ((const uint8_t*) members + (member_size * i));
if (memeqzero(entry->partition_type_guid, sizeof(entry->partition_type_guid)))
continue;
qq = mempcpy(qq, entry, member_size);
unaligned_write_le64(n_measured_entries, unaligned_read_le64(n_measured_entries) + 1);
}
vdata_size = (uint8_t*) qq - (uint8_t*) vdata;
r = make_pcrlock_record(TPM2_PCR_BOOT_LOADER_CONFIG /* =5 */, vdata, vdata_size, &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 append to JSON array: %m");
return write_pcrlock(array, PCRLOCK_GPT_PATH);
}
VERB_NOARG(verb_unlock_gpt, "unlock-gpt",
"Remove .pcrlock file for GPT header");
static int verb_unlock_gpt(int argc, char *argv[], uintptr_t _data, void *userdata) {
return unlink_pcrlock(PCRLOCK_GPT_PATH);
}
static int pe_stdin_too_large(void) {
return log_error_errno(SYNTHETIC_ERRNO(EFBIG),
"PE/UKI binary from stdin is larger than the maximum supported size of %s.",
FORMAT_BYTES(PCRLOCK_PE_INPUT_MAX));
}
static int acquire_stdin_pe_fd(void) {
_cleanup_close_ int fd = -EBADF;
const char *td;
struct stat st;
int r;
if (fstat(STDIN_FILENO, &st) < 0)
return log_error_errno(errno, "Failed to stat stdin: %m");
if (S_ISREG(st.st_mode)) {
if ((uint64_t) st.st_size > PCRLOCK_PE_INPUT_MAX)
return pe_stdin_too_large();
/* Regular stdin is already seekable. Keep it directly to avoid copying large redirected
* PE/UKI files before hashing them. The size check above is a fast-path guard; a file that
* grows concurrently is still hashed stream-wise with bounded memory use. */
fd = fcntl(STDIN_FILENO, F_DUPFD_CLOEXEC, 3);
if (fd < 0)
return log_error_errno(errno, "Failed to duplicate stdin: %m");
return TAKE_FD(fd);
}
r = var_tmp_dir(&td);
if (r < 0)
return log_error_errno(r, "Failed to determine temporary directory: %m");
fd = open_tmpfile_unlinkable(td, O_RDWR|O_CLOEXEC);
if (fd < 0)
return log_error_errno(fd, "Failed to create temporary file for PE binary: %m");
r = copy_bytes(STDIN_FILENO, fd, PCRLOCK_PE_INPUT_MAX + 1, /* copy_flags= */ 0);
if (r < 0)
return log_error_errno(r, "Failed to copy PE binary from stdin to temporary file: %m");
if (r > 0)
return pe_stdin_too_large();
return TAKE_FD(fd);
}
static int acquire_pe_fd(const char *path) {
if (path) {
int fd = open(path, O_RDONLY|O_CLOEXEC);
if (fd < 0)
return log_error_errno(errno, "Failed to open '%s': %m", path);
return fd;
}
return acquire_stdin_pe_fd();
}
VERB(verb_lock_pe, "lock-pe", "[BINARY]\0", VERB_ANY, 2, 0,
"Generate a .pcrlock file from PE binary");
static int verb_lock_pe(int argc, char *argv[], uintptr_t _data, void *userdata) {
_cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL;
_cleanup_close_ int fd = -EBADF;
int r;
// FIXME: Maybe also generate a matching EV_EFI_VARIABLE_AUTHORITY records here for each signature that
// covers this PE plus its hash, as alternatives under the same component name
fd = acquire_pe_fd(argc >= 2 ? argv[1] : NULL);
if (fd < 0)
return fd;
if (arg_pcr_mask == 0)
arg_pcr_mask = UINT32_C(1) << TPM2_PCR_BOOT_LOADER_CODE;
for (uint32_t i = 0; i < TPM2_PCRS_MAX; i++) {
_cleanup_(sd_json_variant_unrefp) sd_json_variant *digests = NULL;
if (!BIT_SET(arg_pcr_mask, i))
continue;
FOREACH_ARRAY(pa, tpm2_hash_algorithms, TPM2_N_HASH_ALGORITHMS) {
_cleanup_free_ void *hash = NULL;
size_t hash_size;
const EVP_MD *md;