summaryrefslogtreecommitdiffstats
path: root/src/pcrlock/pcrlock.c
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--src/pcrlock/pcrlock.c5011
1 files changed, 5011 insertions, 0 deletions
diff --git a/src/pcrlock/pcrlock.c b/src/pcrlock/pcrlock.c
new file mode 100644
index 0000000..bdc6bbd
--- /dev/null
+++ b/src/pcrlock/pcrlock.c
@@ -0,0 +1,5011 @@
+/* SPDX-License-Identifier: LGPL-2.1-or-later */
+
+#include <getopt.h>
+#include <math.h>
+#include <openssl/evp.h>
+#include <sys/file.h>
+
+#include "sd-device.h"
+
+#include "ask-password-api.h"
+#include "blockdev-util.h"
+#include "build.h"
+#include "chase.h"
+#include "conf-files.h"
+#include "efi-api.h"
+#include "env-util.h"
+#include "escape.h"
+#include "fd-util.h"
+#include "fileio.h"
+#include "format-table.h"
+#include "format-util.h"
+#include "fs-util.h"
+#include "gpt.h"
+#include "hash-funcs.h"
+#include "hexdecoct.h"
+#include "initrd-util.h"
+#include "main-func.h"
+#include "mkdir-label.h"
+#include "openssl-util.h"
+#include "ordered-set.h"
+#include "parse-argument.h"
+#include "parse-util.h"
+#include "path-util.h"
+#include "pcrextend-util.h"
+#include "pcrlock-firmware.h"
+#include "pehash.h"
+#include "pretty-print.h"
+#include "proc-cmdline.h"
+#include "random-util.h"
+#include "recovery-key.h"
+#include "sort-util.h"
+#include "terminal-util.h"
+#include "tpm2-util.h"
+#include "unaligned.h"
+#include "unit-name.h"
+#include "utf8.h"
+#include "verbs.h"
+
+static PagerFlags arg_pager_flags = 0;
+static JsonFormatFlags arg_json_format_flags = JSON_FORMAT_OFF|JSON_FORMAT_NEWLINE;
+static char **arg_components = NULL;
+static uint32_t arg_pcr_mask = 0;
+static char *arg_pcrlock_path = NULL;
+static bool arg_pcrlock_auto = true;
+static bool arg_raw_description = false;
+static char *arg_location_start = NULL;
+static char *arg_location_end = NULL;
+static TPM2_HANDLE arg_nv_index = 0;
+static bool arg_recovery_pin = false;
+static char *arg_policy_path = NULL;
+static bool arg_force = false;
+
+STATIC_DESTRUCTOR_REGISTER(arg_components, strv_freep);
+STATIC_DESTRUCTOR_REGISTER(arg_pcrlock_path, freep);
+STATIC_DESTRUCTOR_REGISTER(arg_location_start, freep);
+STATIC_DESTRUCTOR_REGISTER(arg_location_end, freep);
+STATIC_DESTRUCTOR_REGISTER(arg_policy_path, freep);
+
+#define PCRLOCK_SECUREBOOT_POLICY_PATH "/var/lib/pcrlock.d/240-secureboot-policy.pcrlock.d/generated.pcrlock"
+#define PCRLOCK_FIRMWARE_CODE_EARLY_PATH "/var/lib/pcrlock.d/250-firmware-code-early.pcrlock.d/generated.pcrlock"
+#define PCRLOCK_FIRMWARE_CONFIG_EARLY_PATH "/var/lib/pcrlock.d/250-firmware-config-early.pcrlock.d/generated.pcrlock"
+#define PCRLOCK_FIRMWARE_CODE_LATE_PATH "/var/lib/pcrlock.d/550-firmware-code-late.pcrlock.d/generated.pcrlock"
+#define PCRLOCK_FIRMWARE_CONFIG_LATE_PATH "/var/lib/pcrlock.d/550-firmware-config-late.pcrlock.d/generated.pcrlock"
+#define PCRLOCK_GPT_PATH "/var/lib/pcrlock.d/600-gpt.pcrlock.d/generated.pcrlock"
+#define PCRLOCK_SECUREBOOT_AUTHORITY_PATH "/var/lib/pcrlock.d/620-secureboot-authority.pcrlock.d/generated.pcrlock"
+#define PCRLOCK_KERNEL_CMDLINE_PATH "/var/lib/pcrlock.d/710-kernel-cmdline.pcrlock.d/generated.pcrlock"
+#define PCRLOCK_KERNEL_INITRD_PATH "/var/lib/pcrlock.d/720-kernel-initrd.pcrlock.d/generated.pcrlock"
+#define PCRLOCK_MACHINE_ID_PATH "/var/lib/pcrlock.d/820-machine-id.pcrlock"
+#define PCRLOCK_ROOT_FILE_SYSTEM_PATH "/var/lib/pcrlock.d/830-root-file-system.pcrlock"
+#define PCRLOCK_FILE_SYSTEM_PATH_PREFIX "/var/lib/pcrlock.d/840-file-system-"
+
+/* The default set of PCRs to lock to */
+#define DEFAULT_PCR_MASK \
+ ((UINT32_C(1) << TPM2_PCR_PLATFORM_CODE) | \
+ (UINT32_C(1) << TPM2_PCR_PLATFORM_CONFIG) | \
+ (UINT32_C(1) << TPM2_PCR_EXTERNAL_CODE) | \
+ (UINT32_C(1) << TPM2_PCR_EXTERNAL_CONFIG) | \
+ (UINT32_C(1) << TPM2_PCR_BOOT_LOADER_CODE) | \
+ (UINT32_C(1) << TPM2_PCR_BOOT_LOADER_CONFIG) | \
+ (UINT32_C(1) << TPM2_PCR_SECURE_BOOT_POLICY) | \
+ (UINT32_C(1) << TPM2_PCR_KERNEL_BOOT) | \
+ (UINT32_C(1) << TPM2_PCR_KERNEL_CONFIG) | \
+ (UINT32_C(1) << TPM2_PCR_SYSEXTS) | \
+ (UINT32_C(1) << TPM2_PCR_SHIM_POLICY) | \
+ (UINT32_C(1) << TPM2_PCR_SYSTEM_IDENTITY))
+
+typedef struct EventLogRecordBank EventLogRecordBank;
+typedef struct EventLogRecord EventLogRecord;
+typedef struct EventLogRegisterBank EventLogRegisterBank;
+typedef struct EventLogRegister EventLogRegister;
+typedef struct EventLogComponentVariant EventLogComponentVariant;
+typedef struct EventLogComponent EventLogComponent;
+typedef struct EventLog EventLog;
+
+struct EventLogRecordBank {
+ uint16_t algorithm;
+ TPM2B_DIGEST hash;
+ LIST_FIELDS(EventLogRecordBank, banks);
+};
+
+typedef enum EventPayloadValid {
+ EVENT_PAYLOAD_VALID_YES,
+ EVENT_PAYLOAD_VALID_NO,
+ EVENT_PAYLOAD_VALID_DONT_KNOW,
+ _EVENT_PAYLOAD_VALID_MAX,
+ _EVENT_PAYLOAD_VALID_INVALID = -EINVAL,
+} EventPayloadValid;
+
+struct EventLogRecord {
+ EventLog *event_log;
+ uint32_t pcr;
+
+ const char *source;
+ char *description;
+
+ /* Data for firmware events (i.e. "TCG PC Client Platform Firmware Profile Specification" events) */
+ uint32_t firmware_event_type;
+ void *firmware_payload;
+ size_t firmware_payload_size;
+
+ /* Data for userspace events (i.e. those generated by systemd in userspace */
+ Tpm2UserspaceEventType userspace_event_type;
+ JsonVariant *userspace_content;
+
+ /* Validation result for the event payload itself, if the record contains enough information to validate the hash */
+ EventPayloadValid event_payload_valid;
+
+ /* If this record matches an variant of one of our defined components */
+ EventLogComponentVariant **mapped;
+ size_t n_mapped;
+
+ /* If this record is part of an EventLogComponentVariant */
+ EventLogComponentVariant *owning_component_variant;
+
+ LIST_HEAD(EventLogRecordBank, banks);
+};
+
+#define EVENT_LOG_RECORD_IS_FIRMWARE(record) ((record)->firmware_event_type != UINT32_MAX)
+#define EVENT_LOG_RECORD_IS_USERSPACE(record) ((record)->userspace_event_type >= 0)
+
+struct EventLogRegisterBank {
+ TPM2B_DIGEST observed;
+ TPM2B_DIGEST calculated;
+};
+
+struct EventLogRegister {
+ char *color;
+ unsigned n_measurements;
+ bool fully_recognized; /* true if all measurements in this register have been recognized to match components */
+ EventLogRegisterBank *banks;
+};
+
+struct EventLogComponentVariant {
+ EventLogComponent *component;
+
+ char *id;
+ char *path;
+
+ EventLogRecord **records;
+ size_t n_records;
+};
+
+struct EventLogComponent {
+ char *id;
+
+ EventLogComponentVariant **variants;
+ size_t n_variants;
+};
+
+struct EventLog {
+ EventLogRecord **records;
+ size_t n_records;
+
+ uint16_t *algorithms;
+ size_t n_algorithms;
+ bool algorithms_locked; /* if algorithms where set explicitly by user, and we should not determine them automatically */
+
+ const EVP_MD **mds;
+
+ /* The hash algorithm which we focus on for matching up components */
+ uint16_t primary_algorithm;
+
+ uint8_t startup_locality;
+ bool startup_locality_found;
+
+ EventLogRegister registers[TPM2_PCRS_MAX];
+
+ EventLogComponent **components;
+ size_t n_components;
+
+ /* Number of components which we couldn't find in the event log */
+ size_t n_missing_components;
+
+ /* PCRs mask indicating all PCRs touched by unrecognized components */
+ uint32_t missing_component_pcrs;
+};
+
+static EventLogRecordBank *event_log_record_bank_free(EventLogRecordBank *bank) {
+ return mfree(bank);
+}
+
+DEFINE_TRIVIAL_CLEANUP_FUNC(EventLogRecordBank*, event_log_record_bank_free);
+
+static EventLogRecord *event_log_record_free(EventLogRecord *record) {
+ EventLogRecordBank *bank;
+
+ if (!record)
+ return NULL;
+
+ free(record->description);
+ free(record->firmware_payload);
+ json_variant_unref(record->userspace_content);
+
+ while ((bank = LIST_POP(banks, record->banks)))
+ event_log_record_bank_free(bank);
+
+ free(record->mapped);
+
+ return mfree(record);
+}
+
+DEFINE_TRIVIAL_CLEANUP_FUNC(EventLogRecord*, event_log_record_free);
+
+static void event_log_register_done(EventLog *el, EventLogRegister *reg) {
+ assert(reg);
+
+ free(reg->color);
+ free(reg->banks);
+}
+
+static EventLogComponentVariant* event_log_component_variant_free(EventLogComponentVariant *variant) {
+ if (!variant)
+ return NULL;
+
+ free(variant->id);
+ free(variant->path);
+
+ FOREACH_ARRAY(record, variant->records, variant->n_records)
+ event_log_record_free(*record);
+
+ free(variant->records);
+
+ return mfree(variant);
+}
+
+DEFINE_TRIVIAL_CLEANUP_FUNC(EventLogComponentVariant*, event_log_component_variant_free);
+
+static EventLogComponent* event_log_component_free(EventLogComponent *component) {
+ if (!component)
+ return NULL;
+
+ FOREACH_ARRAY(variant, component->variants, component->n_variants)
+ event_log_component_variant_free(*variant);
+ free(component->variants);
+
+ free(component->id);
+
+ return mfree(component);
+}
+
+DEFINE_TRIVIAL_CLEANUP_FUNC(EventLogComponent*, event_log_component_free);
+
+static EventLog* event_log_free(EventLog *el) {
+ if (!el)
+ return NULL;
+
+ FOREACH_ARRAY(p, el->registers, TPM2_PCRS_MAX)
+ event_log_register_done(el, p);
+
+ FOREACH_ARRAY(rr, el->records, el->n_records)
+ event_log_record_free(*rr);
+ free(el->records);
+
+ FOREACH_ARRAY(c, el->components, el->n_components)
+ event_log_component_free(*c);
+ free(el->components);
+
+ free(el->algorithms);
+ free(el->mds);
+
+ return mfree(el);
+}
+
+DEFINE_TRIVIAL_CLEANUP_FUNC(EventLog*, event_log_free);
+
+static EventLogRecord* event_log_record_new(EventLog *el) {
+ EventLogRecord *record;
+
+ record = new(EventLogRecord, 1);
+ if (!record)
+ return NULL;
+
+ *record = (EventLogRecord) {
+ .event_log = el,
+ .firmware_event_type = UINT32_MAX,
+ .userspace_event_type = _TPM2_USERSPACE_EVENT_TYPE_INVALID,
+ .event_payload_valid = _EVENT_PAYLOAD_VALID_INVALID,
+ };
+
+ return record;
+}
+
+static int event_log_add_record(
+ EventLog *el,
+ EventLogRecord **ret) {
+
+ _cleanup_(event_log_record_freep) EventLogRecord *record = NULL;
+
+ assert(el);
+
+ if (!GREEDY_REALLOC(el->records, el->n_records+1))
+ return -ENOMEM;
+
+ record = event_log_record_new(el);
+ if (!record)
+ return -ENOMEM;
+
+ el->records[el->n_records++] = record;
+
+ if (ret)
+ *ret = record;
+
+ TAKE_PTR(record);
+
+ return 0;
+}
+
+static int event_log_add_algorithm(EventLog *el, uint16_t alg) {
+ assert(el);
+
+ if (el->algorithms_locked) /* algorithms configured via env var, don't add any further automatically */
+ return 0;
+
+ if (typesafe_bsearch(&alg, el->algorithms, el->n_algorithms, cmp_uint16))
+ return 0;
+
+ if (!GREEDY_REALLOC(el->algorithms, el->n_algorithms+1))
+ return -ENOMEM;
+
+ el->algorithms[el->n_algorithms++] = alg;
+
+ typesafe_qsort(el->algorithms, el->n_algorithms, cmp_uint16);
+
+ return 1;
+}
+
+static int event_log_add_algorithms_from_environment(EventLog *el) {
+ const char *e;
+ int r;
+
+ assert(el);
+
+ e = secure_getenv("SYSTEMD_TPM2_HASH_ALGORITHMS");
+ if (!e)
+ return 0;
+
+ for (;;) {
+ _cleanup_free_ char *word = NULL;
+
+ r = extract_first_word(&e, &word, ":", 0);
+ if (r < 0)
+ return r;
+ if (r == 0)
+ break;
+
+ r = tpm2_hash_alg_from_string(word);
+ if (r < 0)
+ return log_error_errno(r, "Unknown hash algorithm '%s'.", word);
+
+ r = event_log_add_algorithm(el, r);
+ if (r < 0)
+ return log_error_errno(r, "Failed to add hash algorithm '%s'.", word);
+ }
+
+ if (el->n_algorithms > 0)
+ el->algorithms_locked = true;
+
+ return 0;
+}
+
+static EventLogRecordBank *event_log_record_find_bank(
+ const EventLogRecord *record,
+ uint16_t alg) {
+
+ assert(record);
+
+ LIST_FOREACH(banks, i, record->banks)
+ if (i->algorithm == alg)
+ return i;
+
+ return NULL;
+}
+
+static int event_log_record_add_bank(
+ EventLogRecord *record,
+ uint16_t algorithm,
+ const void *hash,
+ size_t hash_size,
+ EventLogRecordBank **ret) {
+
+ _cleanup_(event_log_record_bank_freep) EventLogRecordBank *bank = NULL;
+ _cleanup_free_ void *h = NULL;
+
+ assert(record);
+ assert(hash || hash_size == 0);
+
+ if (event_log_record_find_bank(record, algorithm))
+ return -EEXIST;
+
+ if (hash_size > sizeof_field(TPM2B_DIGEST, buffer))
+ return -E2BIG;
+
+ h = memdup(hash, hash_size);
+ if (!h)
+ return -ENOMEM;
+
+ bank = new(EventLogRecordBank, 1);
+ if (!bank)
+ return -ENOMEM;
+
+ *bank = (EventLogRecordBank) {
+ .algorithm = algorithm,
+ .hash = TPM2B_DIGEST_MAKE(hash, hash_size),
+ };
+
+ LIST_PREPEND(banks, record->banks, bank);
+
+ if (ret)
+ *ret = bank;
+
+ TAKE_PTR(bank);
+
+ return 0;
+}
+
+static bool event_log_record_is_stub(EventLogRecord *rec) {
+ assert(rec);
+
+ /* Recognizes the special EV_IPL events systemd-stub generates. Since EV_IPL can be used by almost
+ * anything, we'll check for the PCR values, to see if it's one of ours. */
+
+ if (rec->firmware_event_type != EV_IPL)
+ return false;
+
+ if (!EVENT_LOG_RECORD_IS_FIRMWARE(rec))
+ return false;
+
+ if (!IN_SET(rec->pcr,
+ TPM2_PCR_KERNEL_BOOT, /* 11 */
+ TPM2_PCR_KERNEL_CONFIG, /* 12 */
+ TPM2_PCR_SYSEXTS)) /* 13 */
+ return false;
+
+ return true;
+}
+
+static int event_log_record_parse_variable_data(
+ EventLogRecord *rec,
+ sd_id128_t *ret_variable_uuid,
+ char **ret_variable_name) {
+
+ _cleanup_free_ char16_t *p16 = NULL;
+ _cleanup_free_ char *p = NULL;
+
+ assert(rec);
+ assert(ret_variable_uuid);
+ assert(ret_variable_name);
+
+ if (rec->firmware_payload_size < sizeof(UEFI_VARIABLE_DATA))
+ return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG), "EFI variable field too short.");
+
+ const UEFI_VARIABLE_DATA *vdata = rec->firmware_payload;
+
+ if (vdata->unicodeNameLength > (SIZE_MAX - offsetof(UEFI_VARIABLE_DATA, unicodeNameLength)) / 2)
+ return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG), "Unicode name length too large.");
+
+ size_t m = offsetof(UEFI_VARIABLE_DATA, unicodeName) + vdata->unicodeNameLength * 2;
+
+ if (vdata->variableDataLength > SIZE_MAX - m)
+ return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG), "Oversize EFI variable data size.");
+
+ if (rec->firmware_payload_size != m + vdata->variableDataLength)
+ return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG), "EFI variable data has wrong size.");
+
+ p16 = memdup(vdata->unicodeName, vdata->unicodeNameLength * 2); /* Copy out, to align properly */
+ if (!p16)
+ return log_oom_debug();
+
+ p = utf16_to_utf8(p16, vdata->unicodeNameLength * 2);
+ if (!p)
+ return log_oom_debug();
+
+ if (!string_is_safe(p))
+ return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG), "Unsafe EFI variable string in record.");
+
+ *ret_variable_uuid = efi_guid_to_id128(vdata->variableName);
+ *ret_variable_name = TAKE_PTR(p);
+
+ return 0;
+}
+
+static int event_log_record_extract_firmware_description(EventLogRecord *rec) {
+ _cleanup_free_ char *fallback = NULL;
+ int r;
+
+ assert(rec);
+
+ if (!EVENT_LOG_RECORD_IS_FIRMWARE(rec))
+ return 0;
+
+ if (arg_raw_description)
+ goto catchall;
+
+ switch (rec->firmware_event_type) {
+
+ case EV_EFI_VARIABLE_DRIVER_CONFIG:
+ case EV_EFI_VARIABLE_BOOT:
+ case EV_EFI_VARIABLE_BOOT2:
+ case EV_EFI_VARIABLE_AUTHORITY: {
+ _cleanup_free_ char *p = NULL;
+ sd_id128_t uuid;
+
+ r = event_log_record_parse_variable_data(rec, &uuid, &p);
+ if (r == -ENOMEM)
+ return log_oom();
+ if (r < 0) {
+ log_warning_errno(r, "EFI variable data invalid, ignoring.");
+ goto invalid;
+ }
+
+ if (asprintf(&rec->description, "%s: %s-" SD_ID128_UUID_FORMAT_STR,
+ rec->firmware_event_type == EV_EFI_VARIABLE_AUTHORITY ? "Authority" : "Variable",
+ p,
+ SD_ID128_FORMAT_VAL(uuid)) < 0)
+ return log_oom();
+
+ return 1;
+ }
+
+ case EV_SEPARATOR: {
+ if (rec->firmware_payload_size != sizeof(uint32_t)) {
+ log_warning_errno(SYNTHETIC_ERRNO(EBADMSG), "EFI separator field has wrong size, ignoring.");
+ goto invalid;
+ }
+
+ uint32_t val = unaligned_read_ne32(rec->firmware_payload);
+
+ switch (val) {
+
+ case 0:
+ case UINT32_C(0xffffffff):
+ (void) asprintf(&rec->description, "Separator: Success (0x%02" PRIx32 ")", val);
+ break;
+
+ case 1:
+ rec->description = strdup("Separator: Error (0x01)");
+ break;
+
+ default:
+ log_warning_errno(SYNTHETIC_ERRNO(EBADMSG), "Unexpected separator payload %" PRIu32 ".", val);
+ goto invalid;
+ }
+
+ if (!rec->description)
+ return log_oom();
+
+ return 1;
+ }
+
+ case EV_EFI_ACTION: {
+ _cleanup_free_ char *d = NULL;
+
+ r = make_cstring(rec->firmware_payload, rec->firmware_payload_size, MAKE_CSTRING_ALLOW_TRAILING_NUL, &d);
+ if (r < 0)
+ return log_error_errno(r, "Failed to make C string from EFI action string: %m");
+
+ if (!string_is_safe(d)) {
+ log_warning_errno(SYNTHETIC_ERRNO(EBADMSG), "Unsafe EFI action string in record, ignoring.");
+ goto invalid;
+ }
+
+ rec->description = strjoin("Action: ", d);
+ if (!rec->description)
+ return log_oom();
+ return 1;
+ }
+
+ case EV_EFI_GPT_EVENT: {
+ if (rec->firmware_payload_size < sizeof(GptHeader)) {
+ log_warning_errno(SYNTHETIC_ERRNO(EBADMSG), "GPT measurement too short, ignoring.");
+ goto invalid;
+ }
+
+ const GptHeader *h = rec->firmware_payload;
+
+ if (!gpt_header_has_signature(h)) {
+ log_warning_errno(SYNTHETIC_ERRNO(EBADMSG), "GPT measurement does not cover a GPT partition table header, ignoring.");
+ goto invalid;
+ }
+
+ if (asprintf(&rec->description, "GPT: disk " SD_ID128_UUID_FORMAT_STR, SD_ID128_FORMAT_VAL(efi_guid_to_id128(h->disk_guid))) < 0)
+ return log_oom();
+
+ return 1;
+ }
+
+ case EV_IPL: {
+ _cleanup_free_ char *d = NULL;
+
+ /* EV_IPL can be anything, only try to parse the description on PCRs we "own" */
+ if (!event_log_record_is_stub(rec))
+ break;
+
+ /* sd-stub always sets a description string as text for these */
+
+ d = utf16_to_utf8(rec->firmware_payload, rec->firmware_payload_size);
+ if (!d)
+ return log_oom();
+
+ if (string_has_cc(d, NULL)) {
+ log_warning_errno(SYNTHETIC_ERRNO(EBADMSG), "Unsafe EFI action string in record, ignoring.");
+ goto invalid;
+ }
+
+ rec->description = strjoin("String: ", d);
+ if (!rec->description)
+ return log_oom();
+
+ return 1;
+ }
+
+ case EV_EVENT_TAG: {
+ TCG_PCClientTaggedEvent *tag = rec->firmware_payload;
+ size_t left = rec->firmware_payload_size;
+
+ if (left == 0) {
+ log_warning_errno(SYNTHETIC_ERRNO(EBADMSG), "Empty tagged PC client event, ignoring.");
+ goto invalid;
+ }
+
+ for (;;) {
+ uint64_t m;
+
+ if (left < offsetof(TCG_PCClientTaggedEvent, taggedEventData)) {
+ log_warning_errno(SYNTHETIC_ERRNO(EBADMSG), "Tagged PC client event too short, ignoring.");
+ goto invalid;
+ }
+
+ m = offsetof(TCG_PCClientTaggedEvent, taggedEventData) + (uint64_t) tag->taggedEventDataSize;
+ if (left < m) {
+ log_warning_errno(SYNTHETIC_ERRNO(EBADMSG), "Tagged PC client event data too short, ignoring.");
+ goto invalid;
+ }
+
+ switch (tag->taggedEventID) {
+
+ /* Linux kernel's own measurements: */
+ case INITRD_EVENT_TAG_ID:
+ /* The tagged event payload is just a constant string, hence don't show it */
+ if (!strextend_with_separator(&rec->description, ", ", "Linux: initrd"))
+ return log_oom();
+ break;
+
+ case LOAD_OPTIONS_EVENT_TAG_ID:
+ /* As above. */
+ if (!strextend_with_separator(&rec->description, ", ", "Linux: kernel command line"))
+ return log_oom();
+ break;
+
+ /* systemd's measurements: */
+ case LOADER_CONF_EVENT_TAG_ID:
+ /* As above. */
+ if (!strextend_with_separator(&rec->description, ", ", "systemd-boot: loader.conf"))
+ return log_oom();
+ break;
+
+ case DEVICETREE_ADDON_EVENT_TAG_ID: {
+ _cleanup_free_ char *raw = NULL, *s = NULL;
+
+ raw = utf16_to_utf8((const char16_t*) tag->taggedEventData, tag->taggedEventDataSize);
+ if (!raw)
+ return log_oom();
+
+ s = cescape(raw);
+ if (!s)
+ return log_oom();
+
+ r = strextendf_with_separator(&rec->description, ", ", "systemd-stub: devicetree addon %s", s);
+ if (r < 0)
+ return log_error_errno(r, "Failed to format EV_EVENT_TAG description string: %m");
+ break;
+ }
+
+ default: {
+ _cleanup_free_ char *s = NULL;
+
+ s = cescape_length((char*) tag->taggedEventData, tag->taggedEventDataSize);
+ if (!s)
+ return log_oom();
+
+ r = strextendf_with_separator(&rec->description, ", ", "Tag 0x%" PRIx32 ": %s", tag->taggedEventID, s);
+ if (r < 0)
+ return log_error_errno(r, "Failed to format EV_EVENT_TAG description string: %m");
+
+ break;
+ }}
+
+ tag = (TCG_PCClientTaggedEvent*) ((uint8_t*) tag + m);
+ left -= m;
+
+ if (left == 0)
+ break;
+ }
+
+ return 1;
+ }
+
+ case EV_EFI_PLATFORM_FIRMWARE_BLOB: {
+ const UEFI_PLATFORM_FIRMWARE_BLOB *blob;
+ if (rec->firmware_payload_size != sizeof(UEFI_PLATFORM_FIRMWARE_BLOB)) {
+ log_warning_errno(SYNTHETIC_ERRNO(EBADMSG), "EV_EFI_PLATFORM_FIRMWARE_BLOB of wrong size, ignoring.");
+ goto invalid;
+ }
+
+ blob = rec->firmware_payload;
+ if (asprintf(&rec->description, "Blob: %s @ 0x%" PRIx64, FORMAT_BYTES(blob->blobLength), blob->blobBase) < 0)
+ return log_oom();
+
+ return 1;
+ }
+
+ case EV_EFI_BOOT_SERVICES_APPLICATION:
+ case EV_EFI_BOOT_SERVICES_DRIVER:
+ case EV_EFI_RUNTIME_SERVICES_DRIVER: {
+ const UEFI_IMAGE_LOAD_EVENT *load;
+ _cleanup_free_ char *fn = NULL;
+ bool end = false;
+
+ if (rec->firmware_payload_size < offsetof(UEFI_IMAGE_LOAD_EVENT, devicePath)) {
+ log_warning_errno(SYNTHETIC_ERRNO(EBADMSG), "Device path too short, ignoring.");
+ goto invalid;
+ }
+
+ load = rec->firmware_payload;
+ if (load->lengthOfDevicePath !=
+ rec->firmware_payload_size - offsetof(UEFI_IMAGE_LOAD_EVENT, devicePath)) {
+ log_warning_errno(SYNTHETIC_ERRNO(EBADMSG), "Device path size does not match, ignoring.");
+ goto invalid;
+ }
+
+ const packed_EFI_DEVICE_PATH *dp = (const packed_EFI_DEVICE_PATH*) load->devicePath;
+ size_t left = load->lengthOfDevicePath;
+
+ for (;;) {
+ if (left == 0) {
+ if (!end) {
+ log_warning_errno(SYNTHETIC_ERRNO(EBADMSG), "Garbage after device path end, ignoring.");
+ goto invalid;
+ }
+
+ break;
+ }
+
+ if (end) {
+ log_warning_errno(SYNTHETIC_ERRNO(EBADMSG), "Garbage after device path end, ignoring.");
+ goto invalid;
+ }
+
+ if (left < offsetof(packed_EFI_DEVICE_PATH, path) || left < dp->length) {
+ log_warning_errno(SYNTHETIC_ERRNO(EBADMSG), "Device path element too short, ignoring.");
+ goto invalid;
+ }
+
+ if (dp->type == 4 && dp->subType == 4) {
+ /* Filename, store the last node of this type as description, it should contain the file name */
+
+ free(fn);
+ fn = utf16_to_utf8((void*) dp->path, dp->length - offsetof(packed_EFI_DEVICE_PATH, path));
+ if (!fn)
+ return log_oom();
+
+ } else if (dp->type == 0x7F && dp->subType == 0xFF)
+ /* End of Hardware Device Path */
+ end = true;
+ else
+ log_debug("Ignoring device path element type=0x%02x subtype=0x%02x", dp->type, dp->subType);
+
+ left -= dp->length;
+ dp = (packed_EFI_DEVICE_PATH*) ((uint8_t*) dp + dp->length);
+ }
+
+ if (fn) {
+ rec->description = strjoin("File: ", fn);
+ if (!rec->description)
+ return log_oom();
+
+ return 1;
+ }
+
+ break;
+ }}
+
+catchall:
+ /* Catchall: show binary data */
+ fallback = cescape_length(rec->firmware_payload, rec->firmware_payload_size);
+ if (!fallback)
+ return log_oom();
+
+ rec->description = strjoin("Raw: ", fallback);
+ if (!rec->description)
+ return log_oom();
+ return 1;
+
+
+invalid:
+ /* Mark the payload as invalid, so that we do not bother parsing/validating it any further */
+ rec->event_payload_valid = EVENT_PAYLOAD_VALID_NO;
+ return 0;
+}
+
+static int event_log_add_algorithms_from_record(EventLog *el, EventLogRecord *record) {
+ int r;
+
+ assert(el);
+ assert(record);
+
+ if (el->algorithms_locked)
+ return 0;
+
+ LIST_FOREACH(banks, i, record->banks) {
+ r = event_log_add_algorithm(el, i->algorithm);
+ if (r < 0)
+ return r;
+ }
+
+ return 0;
+}
+
+static int event_log_load_firmware(EventLog *el) {
+ const TCG_EfiSpecIdEventAlgorithmSize *algorithms;
+ size_t bufsize = 0, n_algorithms = 0, left = 0;
+ _cleanup_free_ void *buf = NULL;
+ const TCG_PCR_EVENT2 *event;
+ const char *path;
+ int r;
+
+ assert(el);
+
+ path = tpm2_firmware_log_path();
+
+ r = read_full_file(path, (char**) &buf, &bufsize);
+ if (r < 0)
+ return log_error_errno(r, "Failed to open TPM2 event log '%s': %m", path);
+
+ if (bufsize == 0) {
+ /* Sometimes it's useful to invoke things with SYSTEMD_MEASURE_LOG_FIRMWARE=/dev/null, let's allow that, and proceed */
+ log_warning("Empty firmware event log file, not loading.");
+ return 0;
+ }
+
+ r = validate_firmware_header(buf, bufsize, &algorithms, &n_algorithms, &event, &left);
+ if (r < 0)
+ return r;
+
+ for (const TCG_PCR_EVENT2 *next_event = NULL;; event = next_event) {
+ EventLogRecord *record = NULL;
+ const void *payload;
+ size_t payload_size;
+
+ r = validate_firmware_event(
+ event,
+ left,
+ algorithms,
+ n_algorithms,
+ &next_event,
+ &left,
+ &payload,
+ &payload_size);
+ if (r < 0)
+ return r;
+ if (r == 0)
+ break;
+
+ if (event->eventType == EV_NO_ACTION &&
+ event->pcrIndex == 0 &&
+ payload_size == 17 &&
+ memcmp(payload, "StartupLocality", sizeof("StartupLocality")) == 0) {
+ if (el->startup_locality_found)
+ return log_error_errno(SYNTHETIC_ERRNO(EBADMSG), "StartupLocality event found twice!");
+
+ el->startup_locality = ((const uint8_t*) payload)[sizeof("StartupLocality")];
+ el->startup_locality_found = true;
+ log_debug("Found StartupLocality event: %u", el->startup_locality);
+ continue;
+ }
+
+ if (event->eventType == EV_NO_ACTION) { /* Ignore pseudo events, that don't result in a measurement */
+ log_debug("Skipping NO_ACTION event.");
+ continue;
+ }
+
+ r = event_log_add_record(el, &record);
+ if (r < 0)
+ return log_error_errno(r, "Failed to add record to event log: %m");
+
+ record->pcr = event->pcrIndex;
+ record->source = path;
+ record->firmware_event_type = event->eventType;
+ record->firmware_payload = memdup(payload, payload_size);
+ if (!record->firmware_payload)
+ return log_oom();
+ record->firmware_payload_size = payload_size;
+
+ const void *ha, *ha_next = NULL;
+ ha = (const uint8_t*) event + offsetof(TCG_PCR_EVENT2, digests.digests);
+ assert(event->digests.count == n_algorithms);
+
+ for (size_t i = 0; i < n_algorithms; i++, ha = ha_next) {
+ ha_next = (const uint8_t*) ha + offsetof(TPMT_HA, digest) + algorithms[i].digestSize;
+
+ /* The TPMT_HA is not aligned in the record, hence read the hashAlg field via an unaligned read */
+ assert_cc(__builtin_types_compatible_p(uint16_t, typeof(TPMI_ALG_HASH)));
+ uint16_t hash_alg = unaligned_read_ne16((const uint8_t*) ha + offsetof(TPMT_HA, hashAlg));
+
+ if (hash_alg != algorithms[i].algorithmId)
+ return log_error_errno(SYNTHETIC_ERRNO(EBADMSG), "Hash algorithms in event log record don't match log.");
+
+ if (!tpm2_hash_alg_to_string(algorithms[i].algorithmId))
+ continue;
+
+ r = event_log_record_add_bank(
+ record,
+ algorithms[i].algorithmId,
+ (const uint8_t*) ha + offsetof(TPMT_HA, digest),
+ algorithms[i].digestSize,
+ /* ret= */ NULL);
+ if (r < 0)
+ return log_error_errno(r, "Failed to add bank to event log record: %m");
+ }
+
+ /* Try to extract a descriptive text */
+ r = event_log_record_extract_firmware_description(record);
+ if (r < 0)
+ return r;
+
+ r = event_log_add_algorithms_from_record(el, record);
+ if (r < 0)
+ return r;
+ }
+
+ return 0;
+}
+
+static int event_log_record_parse_json(EventLogRecord *record, JsonVariant *j) {
+ const char *rectype = NULL;
+ JsonVariant *x, *k;
+ uint64_t u;
+ int r;
+
+ assert(record);
+ assert(j);
+
+ if (!json_variant_is_object(j))
+ return log_error_errno(SYNTHETIC_ERRNO(EBADMSG), "record object is not an object.");
+
+ x = json_variant_by_key(j, "pcr");
+ if (!x)
+ return log_error_errno(SYNTHETIC_ERRNO(EBADMSG), "'pcr' field missing from TPM measurement log file entry.");
+ if (!json_variant_is_unsigned(x))
+ return log_error_errno(SYNTHETIC_ERRNO(EBADMSG), "'pcr' field is not an integer.");
+
+ u = json_variant_unsigned(x);
+ if (u >= TPM2_PCRS_MAX)
+ return log_error_errno(SYNTHETIC_ERRNO(EBADMSG), "'pcr' field is out of range.");
+ record->pcr = json_variant_unsigned(x);
+
+ x = json_variant_by_key(j, "digests");
+ if (!x)
+ return log_error_errno(SYNTHETIC_ERRNO(EBADMSG), "'digests' field missing from TPM measurement log file entry.");
+ if (!json_variant_is_array(x))
+ return log_error_errno(SYNTHETIC_ERRNO(EBADMSG), "'digests' field is not an array.");
+
+ JSON_VARIANT_ARRAY_FOREACH(k, x) {
+ _cleanup_free_ void *hash = NULL;
+ size_t hash_size;
+ JsonVariant *a, *h;
+ int na;
+
+ a = json_variant_by_key(k, "hashAlg");
+ if (!a)
+ return log_error_errno(SYNTHETIC_ERRNO(EBADMSG), "'digests' field element lacks 'hashAlg' field.");
+ if (!json_variant_is_string(a))
+ return log_error_errno(SYNTHETIC_ERRNO(EBADMSG), "'hashAlg' field is not a string.");
+
+ na = tpm2_hash_alg_from_string(json_variant_string(a));
+ if (na < 0) {
+ log_debug_errno(na, "Unsupported hash '%s' in userspace event log, ignoring: %m", json_variant_string(a));
+ continue;
+ }
+
+ h = json_variant_by_key(k, "digest");
+ if (!h)
+ return log_error_errno(SYNTHETIC_ERRNO(EBADMSG), "'digests' field lacks 'digest' field");
+
+ r = json_variant_unhex(h, &hash, &hash_size);
+ if (r < 0)
+ return log_error_errno(r, "Failed to decode digest: %m");
+
+ r = event_log_record_add_bank(
+ record,
+ na,
+ hash,
+ hash_size,
+ /* ret= */ NULL);
+ if (r < 0)
+ return log_error_errno(r, "Failed to add bank to event log record: %m");
+ }
+
+ x = json_variant_by_key(j, "content_type");
+ if (!x)
+ log_debug("'content_type' missing from TPM measurement log file entry, ignoring.");
+ else {
+ if (!json_variant_is_string(x))
+ return log_error_errno(SYNTHETIC_ERRNO(EBADMSG), "'content_type' field is not a string.");
+
+ rectype = json_variant_string(x);
+ }
+
+ if (streq_ptr(rectype, "systemd")) {
+ JsonVariant *y;
+
+ x = json_variant_by_key(j, "content");
+ if (!x)
+ return log_error_errno(SYNTHETIC_ERRNO(EBADMSG), "'content' field missing from TPM measurement log file entry.");
+ if (!json_variant_is_object(x))
+ return log_error_errno(SYNTHETIC_ERRNO(EBADMSG), "'content' sub-object is not an object.");
+
+ y = json_variant_by_key(x, "string");
+ if (y) {
+ if (!json_variant_is_string(y))
+ return log_error_errno(SYNTHETIC_ERRNO(EBADMSG), "'string' field is not a string.");
+
+ r = free_and_strdup_warn(&record->description, json_variant_string(y));
+ if (r < 0)
+ return r;
+ }
+
+ y = json_variant_by_key(x, "eventType");
+ if (y) {
+ if (!json_variant_is_string(y))
+ return log_error_errno(SYNTHETIC_ERRNO(EBADMSG), "'eventType' field is not a string.");
+
+ record->userspace_event_type = tpm2_userspace_event_type_from_string(json_variant_string(y));
+ if (record->userspace_event_type < 0)
+ log_debug_errno(record->userspace_event_type, "Unknown userspace event type '%s', ignoring.", json_variant_string(y));
+ }
+
+ json_variant_unref(record->userspace_content);
+ record->userspace_content = json_variant_ref(x);
+ }
+
+ return 0;
+}
+
+static int event_log_load_userspace(EventLog *el) {
+ _cleanup_fclose_ FILE *f = NULL;
+ _cleanup_free_ char *b = NULL;
+ bool beginning = true;
+ const char *path;
+ size_t bn = 0;
+ int r;
+
+ assert(el);
+
+ path = tpm2_userspace_log_path();
+
+ f = fopen(path, "re");
+ if (!f) {
+ if (errno != ENOENT)
+ return log_error_errno(errno, "Failed to open userspace TPM measurement log file: %m");
+
+ return 0;
+ }
+
+ if (flock(fileno(f), LOCK_SH) < 0)
+ return log_error_errno(errno, "Failed to lock userspace TPM measurement log file: %m");
+
+ for (;;) {
+ _cleanup_(json_variant_unrefp) JsonVariant *j = NULL;
+ EventLogRecord *record;
+ int ch;
+
+ ch = fgetc(f);
+ if (ch == EOF) {
+ if (ferror(f))
+ return log_error_errno(errno, "Failed to read local TPM measurement log file: %m");
+
+ if (beginning)
+ break;
+ } else if (ch != 0x1EU) {
+ if (!GREEDY_REALLOC(b, bn + 2))
+ return log_oom();
+
+ b[bn++] = (char) ch;
+ continue;
+ }
+
+ if (beginning) {
+ beginning = false;
+ continue;
+ }
+
+ if (!GREEDY_REALLOC(b, bn + 1))
+ return log_oom();
+
+ b[bn] = 0; /* Turn it into a string */
+
+ if (memchr(b, 0, bn)) {
+ log_warning("Found record with embedded NUL byte, skipping.");
+ continue;
+ }
+
+ r = json_parse(b, 0, &j, NULL, NULL);
+ if (r < 0)
+ return log_error_errno(r, "Failed to parse local TPM measurement log file: %m");
+
+ r = event_log_add_record(el, &record);
+ if (r < 0)
+ return log_error_errno(r, "Failed to add record to event log: %m");
+
+ record->source = path;
+
+ r = event_log_record_parse_json(record, j);
+ if (r < 0)
+ return r;
+
+ r = event_log_add_algorithms_from_record(el, record);
+ if (r < 0)
+ return r;
+
+ if (ch == EOF)
+ break;
+
+ b = mfree(b);
+ bn = 0;
+ }
+
+ return 0;
+}
+
+static EventLog *event_log_new(void) {
+ _cleanup_(event_log_freep) EventLog *el = NULL;
+
+ el = new(EventLog, 1);
+ if (!el)
+ return NULL;
+
+ *el = (EventLog) {
+ .primary_algorithm = UINT16_MAX,
+ };
+
+ return TAKE_PTR(el);
+}
+
+static int event_log_load(EventLog *el) {
+ int r;
+
+ assert(el);
+
+ r = event_log_load_firmware(el);
+ if (r < 0)
+ return r;
+
+ r = event_log_load_userspace(el);
+ if (r < 0)
+ return r;
+
+ return 0;
+}
+
+static int event_log_read_pcrs(EventLog *el) {
+ _cleanup_(tpm2_context_unrefp) Tpm2Context *tc = NULL;
+ int r;
+
+ assert(el);
+
+ r = tpm2_context_new(NULL, &tc);
+ if (r < 0)
+ return r;
+
+ FOREACH_ARRAY(rr, el->registers, TPM2_PCRS_MAX) {
+ if (rr->banks)
+ continue;
+
+ rr->banks = new0(EventLogRegisterBank, el->n_algorithms);
+ if (!rr->banks)
+ return log_oom();
+ }
+
+ for (size_t a = 0; a < el->n_algorithms; a++) {
+ _cleanup_free_ Tpm2PCRValue *pcr_values = NULL;
+ size_t n_pcr_values;
+ TPML_PCR_SELECTION selection;
+
+ tpm2_tpml_pcr_selection_from_mask(TPM2_PCRS_MASK, el->algorithms[a], &selection);
+ r = tpm2_pcr_read(tc, &selection, &pcr_values, &n_pcr_values);
+ if (r < 0)
+ return r;
+
+ FOREACH_ARRAY(v, pcr_values, n_pcr_values) {
+ assert(v->hash == el->algorithms[a]);
+ el->registers[v->index].banks[a].observed = v->value;
+ }
+ }
+
+ return 0;
+}
+
+static void event_log_initial_pcr_state(EventLog *el, uint32_t pcr, size_t size, TPM2B_DIGEST *ret) {
+ assert(el);
+ assert(pcr < TPM2_PCRS_MAX);
+ assert(size > 0);
+ assert(size <= sizeof_field(TPM2B_DIGEST, buffer));
+ assert(ret);
+
+ ret->size = size;
+
+ switch (pcr) {
+
+ case 0:
+ memzero(ret->buffer, ret->size-1);
+ ((uint8_t*) ret->buffer)[ret->size-1] = el->startup_locality_found ? el->startup_locality : 0;
+ break;
+
+ case 1 ... 16:
+ case 23:
+ memzero(ret->buffer, ret->size);
+ break;
+
+ case 17 ... 22:
+ memset(ret->buffer, 0xffu, ret->size);
+ break;
+
+ default:
+ assert_not_reached();
+ }
+}
+
+static int event_log_calculate_pcrs(EventLog *el) {
+ assert(el);
+
+ /* Iterates through the event log an calculates the expected hash values based on all listed records */
+
+ assert(!el->mds);
+ el->mds = new(const EVP_MD*, el->n_algorithms);
+ if (!el->mds)
+ return log_oom();
+
+ for (size_t i = 0; i < el->n_algorithms; i++) {
+ const EVP_MD *md;
+ const char *a;
+
+ assert_se(a = tpm2_hash_alg_to_string(el->algorithms[i]));
+ assert_se(md = EVP_get_digestbyname(a));
+
+ el->mds[i] = md;
+ }
+
+ for (uint32_t pcr = 0; pcr < TPM2_PCRS_MAX; pcr++)
+ for (size_t i = 0; i < el->n_algorithms; i++) {
+ EventLogRegisterBank *b = el->registers[pcr].banks + i;
+ event_log_initial_pcr_state(el, pcr, EVP_MD_size(el->mds[i]), &b->calculated);
+ }
+
+ FOREACH_ARRAY(rr, el->records, el->n_records) {
+ EventLogRegister *reg = el->registers + (*rr)->pcr;
+
+ for (size_t i = 0; i < el->n_algorithms; i++) {
+ const char *n = tpm2_hash_alg_to_string(el->algorithms[i]);
+ _cleanup_(EVP_MD_CTX_freep) EVP_MD_CTX *mc = NULL;
+ EventLogRegisterBank *reg_b;
+ EventLogRecordBank *rec_b;
+ unsigned sz;
+
+ rec_b = event_log_record_find_bank(*rr, el->algorithms[i]);
+ if (!rec_b) {
+ log_warning_errno(SYNTHETIC_ERRNO(ENXIO), "Record with missing bank '%s', ignoring.", n);
+ continue;
+ }
+
+ reg_b = reg->banks + i;
+
+ mc = EVP_MD_CTX_new();
+ if (!mc)
+ return log_oom();
+
+ if (EVP_DigestInit_ex(mc, el->mds[i], NULL) != 1)
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Failed to initialize %s message digest context.", n);
+
+ if (EVP_DigestUpdate(mc, reg_b->calculated.buffer, reg_b->calculated.size) != 1)
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Failed to run digest.");
+
+ if (EVP_DigestUpdate(mc, rec_b->hash.buffer, rec_b->hash.size) != 1)
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Failed to run digest.");
+
+ if (EVP_DigestFinal_ex(mc, reg_b->calculated.buffer, &sz) != 1)
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Failed to finalize hash context.");
+
+ assert(sz == reg_b->calculated.size);
+ }
+
+ reg->n_measurements++;
+ }
+
+ return 0;
+}
+
+static int event_log_record_validate_hash_firmware(
+ EventLogRecord *record,
+ EventLogRecordBank *bank,
+ const EVP_MD *md) {
+
+ _cleanup_free_ void *hdata_alternative = NULL;
+ size_t hsz, hsz_alternative = 0;
+ bool strict = false;
+ const void *hdata;
+
+ assert(record);
+ assert(bank);
+ assert(md);
+
+ if (!EVENT_LOG_RECORD_IS_FIRMWARE(record))
+ return 0;
+
+ switch (record->firmware_event_type) {
+
+ case EV_EFI_ACTION:
+ case EV_EFI_GPT_EVENT:
+ case EV_EFI_VARIABLE_BOOT2:
+ case EV_EFI_VARIABLE_DRIVER_CONFIG:
+ case EV_EFI_VARIABLE_AUTHORITY:
+ case EV_SEPARATOR:
+ case EV_S_CRTM_VERSION:
+ /* Here the extended hash value is the hash value of the event payload. Note that
+ * EV_PLATFORM_CONFIG_FLAGS (according to the TCG PC Client Platform Firmware Profile
+ * Specification) is also supposed to be like this. But ovmf doesn't follow this requirement,
+ * hence be lenient on that one, and don't include it here. */
+ hdata = record->firmware_payload;
+ hsz = record->firmware_payload_size;
+ strict = true;
+ break;
+
+ case EV_EFI_VARIABLE_BOOT: {
+ const UEFI_VARIABLE_DATA *vdata = record->firmware_payload;
+ size_t skip;
+
+ /* Here the extended hash value is the hash value of the variable data (i.e. excluding the
+ * name).
+ *
+ * Note: we already checked the general validity of the UEFI_VARIABLE_DATA structure, hence
+ * no need to do so again. */
+
+ assert(record->firmware_payload_size >= offsetof(UEFI_VARIABLE_DATA, unicodeName));
+ skip = offsetof(UEFI_VARIABLE_DATA, unicodeName) + vdata->unicodeNameLength * 2;
+
+ assert(record->firmware_payload_size >= skip);
+ hdata = (const uint8_t*) record->firmware_payload + skip;
+ hsz = record->firmware_payload_size - skip;
+ strict = true;
+ break;
+ }
+
+ case EV_IPL:
+ if (event_log_record_is_stub(record)) {
+ /* The PE section names have a descriptive string in UTF-16 in the payload, but the
+ * hash is over the UTF-8 version (with suffixing 0), hence let's convert the payload
+ * into that format here, and see if it checks out. */
+ hdata_alternative = utf16_to_utf8(record->firmware_payload, record->firmware_payload_size);
+ if (!hdata_alternative)
+ return log_oom();
+
+ hsz_alternative = strlen(hdata_alternative) + 1; /* with NUL byte */
+ }
+
+ _fallthrough_;
+
+ default:
+ /* For the others check the data too, just in case. But usually this will not match, hence
+ * only report if the checksum matches, but don't complain if it does not. */
+ hdata = record->firmware_payload;
+ hsz = record->firmware_payload_size;
+ strict = false;
+ break;
+ }
+
+ int mdsz = EVP_MD_size(md);
+ assert(mdsz > 0);
+ assert((size_t) mdsz <= sizeof_field(TPM2B_DIGEST, buffer));
+
+ TPM2B_DIGEST payload_hash = {
+ .size = mdsz,
+ };
+
+ unsigned dsz = mdsz;
+
+ if (EVP_Digest(hdata, hsz, payload_hash.buffer, &dsz, md, NULL) != 1)
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Failed to calculate event payload hash.");
+ assert(dsz == (unsigned) mdsz);
+
+ /* If this didn't match then let's try the alternative format here, if we have one, and check things then. */
+ if (memcmp_nn(bank->hash.buffer, bank->hash.size, payload_hash.buffer, payload_hash.size) != 0 && hdata_alternative) {
+ if (EVP_Digest(hdata_alternative, hsz_alternative, payload_hash.buffer, &dsz, md, NULL) != 1)
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Failed to calculate event payload hash.");
+ assert(dsz == (unsigned) mdsz);
+ }
+
+ if (memcmp_nn(bank->hash.buffer, bank->hash.size, payload_hash.buffer, payload_hash.size) != 0) {
+ if (strict)
+ record->event_payload_valid = EVENT_PAYLOAD_VALID_NO;
+ else if (record->event_payload_valid != EVENT_PAYLOAD_VALID_NO)
+ record->event_payload_valid = EVENT_PAYLOAD_VALID_DONT_KNOW;
+ } else if (record->event_payload_valid < 0)
+ record->event_payload_valid = EVENT_PAYLOAD_VALID_YES;
+
+ return 1;
+}
+
+static int event_log_record_validate_hash_userspace(
+ EventLogRecord *record,
+ EventLogRecordBank *bank,
+ const EVP_MD *md) {
+
+ _cleanup_free_ unsigned char *payload_hash = NULL;
+ unsigned payload_hash_size;
+ JsonVariant *js;
+ const char *s;
+ int mdsz;
+
+ assert(record);
+ assert(bank);
+ assert(md);
+
+ if (!EVENT_LOG_RECORD_IS_USERSPACE(record))
+ return 0;
+
+ if (!record->userspace_content)
+ return 0;
+
+ js = json_variant_by_key(record->userspace_content, "string");
+ if (!js)
+ return 0;
+
+ assert(json_variant_is_string(js));
+ s = json_variant_string(js);
+
+ mdsz = EVP_MD_size(md);
+ assert(mdsz > 0);
+
+ payload_hash_size = mdsz;
+ payload_hash = malloc(payload_hash_size);
+ if (!payload_hash)
+ return log_oom();
+
+ if (EVP_Digest(s, strlen(s), payload_hash, &payload_hash_size, md, NULL) != 1)
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Failed to calculate event payload hash.");
+
+ assert((int) payload_hash_size == mdsz);
+ if (memcmp_nn(bank->hash.buffer, bank->hash.size, payload_hash, payload_hash_size) != 0)
+ record->event_payload_valid = EVENT_PAYLOAD_VALID_NO;
+ else if (record->event_payload_valid < 0)
+ record->event_payload_valid = EVENT_PAYLOAD_VALID_YES;
+
+ return 0;
+}
+
+static int event_log_validate_record_hashes(EventLog *el) {
+ int r;
+
+ assert(el);
+
+ /* For records which contain the full data to validate the hashes, do so. */
+
+ FOREACH_ARRAY(rr, el->records, el->n_records) {
+
+ LIST_FOREACH(banks, bank, (*rr)->banks) {
+ const EVP_MD *md;
+ const char *a;
+
+ assert_se(a = tpm2_hash_alg_to_string(bank->algorithm));
+ assert_se(md = EVP_get_digestbyname(a));
+
+ r = event_log_record_validate_hash_firmware(*rr, bank, md);
+ if (r < 0)
+ return r;
+
+ r = event_log_record_validate_hash_userspace(*rr, bank, md);
+ if (r < 0)
+ return r;
+ }
+ }
+
+ return 0;
+}
+
+static int event_log_component_cmp(EventLogComponent *const*a, EventLogComponent *const*b) {
+ const EventLogComponent *x = ASSERT_PTR(*ASSERT_PTR(a)), *y = ASSERT_PTR(*ASSERT_PTR(b));
+
+ return strcmp(x->id, y->id);
+}
+
+static EventLogComponent *event_log_find_component(EventLog *el, const char *id) {
+ EventLogComponent k = {
+ .id = (char*) id,
+ };
+ EventLogComponent *kk = &k, **found;
+
+ assert(el);
+ assert(id);
+
+ found = typesafe_bsearch(
+ &kk,
+ el->components,
+ el->n_components,
+ event_log_component_cmp);
+ if (!found)
+ return NULL;
+
+ return *found;
+}
+
+static int event_log_add_component(EventLog *el, const char *id, EventLogComponent **ret) {
+ _cleanup_(event_log_component_freep) EventLogComponent *component = NULL;
+ _cleanup_free_ char *id_copy = NULL;
+ EventLogComponent *found;
+
+ assert(el);
+ assert(ret);
+
+ found = event_log_find_component(el, id);
+ if (found) {
+ *ret = found;
+ return 0;
+ }
+
+ if (!GREEDY_REALLOC(el->components, el->n_components+1))
+ return log_oom();
+
+ id_copy = strdup(id);
+ if (!id_copy)
+ return log_oom();
+
+ component = new(EventLogComponent, 1);
+ if (!component)
+ return log_oom();
+
+ *component = (EventLogComponent) {
+ .id = TAKE_PTR(id_copy),
+ };
+
+ if (ret)
+ *ret = component;
+
+ el->components[el->n_components++] = TAKE_PTR(component);
+ return 1;
+}
+
+static int event_log_record_equal(const EventLogRecord *a, const EventLogRecord *b) {
+ EventLogRecordBank *x, *y;
+
+ assert(a);
+ assert(a->event_log);
+ assert(b);
+ assert(b->event_log);
+ assert(a->event_log == b->event_log);
+
+ if (a->pcr != b->pcr)
+ return false;
+
+ x = event_log_record_find_bank(a, a->event_log->primary_algorithm);
+ y = event_log_record_find_bank(b, b->event_log->primary_algorithm);
+ if (!x || !y)
+ return false;
+
+ assert(x->algorithm == a->event_log->primary_algorithm);
+ assert(y->algorithm == b->event_log->primary_algorithm);
+
+ return memcmp_nn(x->hash.buffer, x->hash.size, y->hash.buffer, y->hash.size) == 0;
+}
+
+static int event_log_add_component_file(EventLog *el, EventLogComponent *component, const char *path) {
+ _cleanup_(event_log_component_variant_freep) EventLogComponentVariant *variant = NULL;
+ _cleanup_free_ char *fname = NULL, *id = NULL, *path_copy = NULL;
+ _cleanup_(json_variant_unrefp) JsonVariant *j = NULL;
+ JsonVariant *records;
+ const char *e;
+ int r;
+
+ assert(el);
+
+ r = path_extract_filename(path, &fname);
+ if (r < 0)
+ return log_error_errno(r, "Failed to extract basename from path %s: %m", path);
+
+ e = endswith(fname, ".pcrlock");
+ if (!e)
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Bad suffix: %s", fname);
+
+ id = strndup(fname, e - fname);
+ if (!id)
+ return log_oom();
+
+ if (!component) {
+ r = event_log_add_component(el, id, &component);
+ if (r < 0)
+ return r;
+ }
+
+ if (!GREEDY_REALLOC(component->variants, component->n_variants+1))
+ return log_oom();
+
+ r = json_parse_file(
+ /* f= */ NULL,
+ path,
+ /* flags= */ 0,
+ &j,
+ /* ret_line= */ NULL,
+ /* ret_column= */ NULL);
+ if (r < 0) {
+ log_warning_errno(r, "Failed to parse component file %s, ignoring: %m", path);
+ return 0;
+ }
+
+ if (!json_variant_is_object(j)) {
+ log_warning_errno(r, "Component file %s does not contain JSON object, ignoring.", path);
+ return 0;
+ }
+
+ path_copy = strdup(path);
+ if (!path_copy)
+ return log_oom();
+
+ variant = new(EventLogComponentVariant, 1);
+ if (!variant)
+ return log_oom();
+
+ *variant = (EventLogComponentVariant) {
+ .component = component,
+ .path = TAKE_PTR(path_copy),
+ .id = TAKE_PTR(id),
+ };
+
+ records = json_variant_by_key(j, "records");
+ if (records) {
+ JsonVariant *rj;
+
+ if (!json_variant_is_array(records)) {
+ log_warning_errno(r, "Component records field of file %s is not an array, ignoring.", path);
+ return 0;
+ }
+
+ JSON_VARIANT_ARRAY_FOREACH(rj, records) {
+ _cleanup_(event_log_record_freep) EventLogRecord *record = NULL;
+
+ if (!GREEDY_REALLOC(variant->records, variant->n_records+1))
+ return log_oom();
+
+ record = event_log_record_new(el);
+ if (!record)
+ return log_oom();
+
+ r = event_log_record_parse_json(record, rj);
+ if (r < 0)
+ return r;
+
+ record->owning_component_variant = variant;
+ variant->records[variant->n_records++] = TAKE_PTR(record);
+ }
+ }
+
+ component->variants[component->n_variants++] = TAKE_PTR(variant);
+ return 1;
+}
+
+static int event_log_add_component_dir(EventLog *el, const char *path, char **base_search) {
+ _cleanup_free_ char *fname = NULL, *id = NULL;
+ _cleanup_strv_free_ char **files = NULL;
+ EventLogComponent *component;
+ const char *e;
+ int r;
+
+ assert(el);
+
+ r = path_extract_filename(path, &fname);
+ if (r < 0)
+ return log_error_errno(r, "Failed to extract basename from path %s: %m", path);
+
+ e = endswith(fname, ".pcrlock.d");
+ if (!e)
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Bad suffix: %s", fname);
+
+ id = strndup(fname, e - fname);
+ if (!id)
+ return log_oom();
+
+ r = event_log_add_component(el, id, &component);
+ if (r < 0)
+ return r;
+
+ _cleanup_strv_free_ char **search = NULL;
+
+ STRV_FOREACH(b, base_search) {
+ _cleanup_free_ char *q = NULL;
+
+ q = path_join(*b, fname);
+ if (!q)
+ return log_oom();
+
+ r = strv_consume(&search, TAKE_PTR(q));
+ if (r < 0)
+ return log_oom();
+ }
+
+ r = conf_files_list_strv(&files, ".pcrlock", /* root= */ NULL, CONF_FILES_REGULAR, (const char*const*) search);
+ if (r < 0)
+ return log_error_errno(r, "Failed to enumerate .pcrlock files for component '%s': %m", id);
+
+ STRV_FOREACH(f, files) {
+ r = event_log_add_component_file(el, component, *f);
+ if (r < 0)
+ return r;
+ }
+
+ return 0;
+}
+
+static int event_log_load_components(EventLog *el) {
+ _cleanup_strv_free_ char **files = NULL;
+ char **dirs;
+ int r;
+
+ assert(el);
+
+ dirs = arg_components ?:
+ STRV_MAKE("/etc/pcrlock.d",
+ "/run/pcrlock.d",
+ "/var/lib/pcrlock.d",
+ "/usr/local/lib/pcrlock.d",
+ "/usr/lib/pcrlock.d");
+
+ r = conf_files_list_strv(&files, NULL, NULL, CONF_FILES_REGULAR|CONF_FILES_DIRECTORY|CONF_FILES_FILTER_MASKED, (const char*const*) dirs);
+ if (r < 0)
+ return log_error_errno(r, "Failed to enumerate .pcrlock files: %m");
+
+ STRV_FOREACH(f, files) {
+ if (endswith(*f, ".pcrlock.d"))
+ r = event_log_add_component_dir(el, *f, dirs);
+ else if (endswith(*f, ".pcrlock"))
+ r = event_log_add_component_file(el, NULL, *f);
+ else
+ continue;
+ if (r < 0)
+ return r;
+ }
+
+ return 0;
+}
+
+static int event_log_validate_fully_recognized(EventLog *el) {
+
+ for (uint32_t pcr = 0; pcr < ELEMENTSOF(el->registers); pcr++) {
+ bool fully_recognized = true;
+
+ FOREACH_ARRAY(rr, el->records, el->n_records) {
+ EventLogRecord *rec = *rr;
+
+ if (rec->pcr != pcr)
+ continue;
+
+ if (rec->n_mapped == 0) {
+ log_notice("Event log record %zu (PCR %" PRIu32 ", \"%s\") not matching any component.",
+ (size_t) (rr - el->records), rec->pcr, strna(rec->description));
+ fully_recognized = false;
+ break;
+ }
+ }
+
+ el->registers[pcr].fully_recognized = fully_recognized;
+ }
+
+ return 0;
+}
+
+static int event_log_match_component_variant(
+ EventLog *el,
+ size_t i,
+ EventLogComponentVariant *variant,
+ size_t j,
+ bool assign) {
+
+ int r;
+
+ assert(el);
+ assert(variant);
+
+ /* It's OK to point immediately after the last record, but not further */
+ assert(i <= el->n_records);
+ assert(j <= variant->n_records);
+
+ /* All entries in the variant checked out? Yippieh! */
+ if (j == variant->n_records)
+ return true;
+
+ /* If the remainder of the variant is longer than the remainder of the event log, it cannot possibly fit. */
+ if (el->n_records - i < variant->n_records - j)
+ return false;
+
+ /* Does this record match? If not, let's try at the next place in the logs. */
+ if (!event_log_record_equal(el->records[i], variant->records[j]))
+ return event_log_match_component_variant(el, i + 1, variant, j, assign); /* Recursion! */
+
+ /* This one matches. Good. Let's see if the rest also matches. (Recursion!) */
+ r = event_log_match_component_variant(el, i + 1, variant, j + 1, assign);
+ if (r <= 0)
+ return r;
+
+ if (assign) {
+ /* Take ownership (Note we allow multiple components and variants to take owneship of the same record!) */
+ if (!GREEDY_REALLOC(el->records[i]->mapped, el->records[i]->n_mapped+1))
+ return log_oom();
+
+ el->records[i]->mapped[el->records[i]->n_mapped++] = variant;
+ }
+
+ return true;
+}
+
+static uint32_t event_log_component_variant_pcrs(EventLogComponentVariant *i) {
+ uint32_t mask = 0;
+
+ assert(i);
+
+ /* returns mask of PCRs touched by this variant */
+
+ FOREACH_ARRAY(rr, i->records, i->n_records)
+ mask |= UINT32_C(1) << (*rr)->pcr;
+
+ return mask;
+}
+
+static uint32_t event_log_component_pcrs(EventLogComponent *c) {
+ uint32_t mask = 0;
+
+ assert(c);
+
+ /* Returns mask of PCRs touched by this component */
+
+ FOREACH_ARRAY(ii, c->variants, c->n_variants)
+ mask |= event_log_component_variant_pcrs(*ii);
+
+ return mask;
+}
+
+static int event_log_map_components(EventLog *el) {
+ _cleanup_free_ char *skipped_ids = NULL;
+ unsigned n_skipped = 0;
+ int r;
+
+ assert(el);
+
+ FOREACH_ARRAY(cc, el->components, el->n_components) {
+ _cleanup_free_ char *matching_ids = NULL;
+ unsigned n_matching = 0, n_empty = 0;
+ EventLogComponent *c = *cc;
+
+ if (arg_location_end && strcmp(c->id, arg_location_end) > 0) {
+ n_skipped++;
+
+ if (!strextend_with_separator(&skipped_ids, ", ", c->id))
+ return log_oom();
+
+ continue;
+ }
+
+ FOREACH_ARRAY(ii, c->variants, c->n_variants) {
+ EventLogComponentVariant *i = *ii;
+
+ if (i->n_records == 0) {
+ /* The empty variant always matches */
+ n_empty++;
+ continue;
+ }
+
+ r = event_log_match_component_variant(el, 0, i, 0, n_matching + n_empty == 0);
+ if (r < 0)
+ return r;
+ if (r > 0) {
+ n_matching++;
+
+ if (!strextend_with_separator(&matching_ids, ", ", i->id))
+ return log_oom();
+ }
+ }
+
+ if (n_matching + n_empty == 0) {
+
+ if (arg_location_start && strcmp(c->id, arg_location_start) >= 0)
+ log_info("Didn't find component '%s' in event log, assuming system hasn't reached it yet.", c->id);
+ else {
+ log_notice("Couldn't find component '%s' in event log.", c->id);
+ el->n_missing_components++;
+ el->missing_component_pcrs |= event_log_component_pcrs(c);
+ }
+ } else if (n_matching > 1)
+ log_debug("Found %u possible variants of component '%s' in event log (%s). Proceeding.", n_matching, c->id, matching_ids);
+ }
+
+ if (n_skipped > 0)
+ log_notice("Skipped %u components after location '%s' (%s).", n_skipped, arg_location_end, skipped_ids);
+ if (el->n_missing_components > 0)
+ log_notice("Unable to recognize %zu components in event log.", el->n_missing_components);
+
+ return event_log_validate_fully_recognized(el);
+}
+
+static void hsv_to_rgb(
+ double h, double s, double v,
+ uint8_t* ret_r, uint8_t *ret_g, uint8_t *ret_b) {
+
+ double c, x, m, r, g, b;
+
+ assert(s >= 0 && s <= 100);
+ assert(v >= 0 && v <= 100);
+ assert(ret_r);
+ assert(ret_g);
+ assert(ret_b);
+
+ c = (s / 100.0) * (v / 100.0);
+ x = c * (1 - fabs(fmod(h / 60.0, 2) - 1));
+ m = (v / 100) - c;
+
+ if (h >= 0 && h < 60)
+ r = c, g = x, b = 0.0;
+ else if (h >= 60 && h < 120)
+ r = x, g = c, b = 0.0;
+ else if (h >= 120 && h < 180)
+ r = 0.0, g = c, b = x;
+ else if (h >= 180 && h < 240)
+ r = 0.0, g = x, b = c;
+ else if (h >= 240 && h < 300)
+ r = x, g = 0.0, b = c;
+ else
+ r = c, g = 0.0, b = x;
+
+ *ret_r = (uint8_t) ((r + m) * 255);
+ *ret_g = (uint8_t) ((g + m) * 255);
+ *ret_b = (uint8_t) ((b + m) * 255);
+}
+
+#define ANSI_TRUE_COLOR_MAX (7U + 3U + 1U + 3U + 1U + 3U + 2U)
+
+static const char *ansi_true_color(uint8_t r, uint8_t g, uint8_t b, char ret[static ANSI_TRUE_COLOR_MAX]) {
+ snprintf(ret, ANSI_TRUE_COLOR_MAX, "\x1B[38;2;%u;%u;%um", r, g, b);
+ return ret;
+}
+
+static char *color_for_pcr(EventLog *el, uint32_t pcr) {
+ char color[ANSI_TRUE_COLOR_MAX];
+ uint8_t r, g, b;
+
+ assert(el);
+ assert(pcr < TPM2_PCRS_MAX);
+
+ if (el->registers[pcr].color)
+ return el->registers[pcr].color;
+
+ hsv_to_rgb(360.0 / (TPM2_PCRS_MAX - 1) * pcr, 100, 90, &r, &g, &b);
+ ansi_true_color(r, g, b, color);
+
+ el->registers[pcr].color = strdup(color);
+ return el->registers[pcr].color;
+}
+
+static int add_algorithm_columns(
+ EventLog *el,
+ Table *table,
+ const char *prefix,
+ const char *json_field_prefix) {
+
+ int r;
+
+ assert(el);
+ assert(table);
+
+ FOREACH_ARRAY(alg, el->algorithms, el->n_algorithms) {
+ const char *n = tpm2_hash_alg_to_string(*alg);
+ _cleanup_free_ char *v = NULL;
+
+ if (prefix) {
+ v = strjoin(prefix, " ", n);
+ if (!v)
+ return log_oom();
+ }
+
+ size_t c = table_get_current_column(table);
+
+ r = table_add_cell(table, NULL, TABLE_HEADER, v ?: n);
+ if (r < 0)
+ return table_log_add_error(r);
+
+ if (FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF) &&
+ el->primary_algorithm != UINT16_MAX &&
+ *alg != el->primary_algorithm)
+ (void) table_hide_column_from_display(table, c);
+
+ _cleanup_free_ char *j = NULL;
+ if (json_field_prefix) {
+ _cleanup_free_ char *m = strdup(n);
+ if (!m)
+ return log_oom();
+
+ j = strjoin(json_field_prefix, ascii_strupper(m));
+ if (!j)
+ return log_oom();
+ }
+
+ (void) table_set_json_field_name(table, c, j ?: n);
+ }
+
+ return 0;
+}
+
+static int show_log_table(EventLog *el, JsonVariant **ret_variant) {
+ _cleanup_(table_unrefp) Table *table = NULL;
+ int r;
+
+ assert(el);
+
+ table = table_new_raw(5 + el->n_algorithms + 4);
+ if (!table)
+ return log_oom();
+
+ (void) table_set_ersatz_string(table, TABLE_ERSATZ_DASH);
+
+ r = table_add_many(table,
+ TABLE_HEADER, "pcr",
+ TABLE_SET_ALIGN_PERCENT, 100,
+ TABLE_HEADER, "",
+ TABLE_HEADER, "pcrname",
+ TABLE_HEADER, "event",
+ TABLE_HEADER, "match",
+ TABLE_SET_ALIGN_PERCENT, 100);
+ if (r < 0)
+ return table_log_add_error(r);
+
+ r = add_algorithm_columns(el, table, NULL, NULL);
+ if (r < 0)
+ return r;
+
+ size_t phase_column = table_get_current_column(table);
+
+ r = table_add_many(table,
+ TABLE_HEADER, "F/U",
+ TABLE_HEADER, "source",
+ TABLE_HEADER, "component",
+ TABLE_HEADER, "description");
+ if (r < 0)
+ return table_log_add_error(r);
+
+ (void) table_hide_column_from_display(table, table_get_columns(table) - 3); /* hide source */
+
+ if (!FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF))
+ (void) table_hide_column_from_display(table, (size_t) 1); /* hide color block column */
+
+ (void) table_set_json_field_name(table, phase_column, "phase");
+
+ FOREACH_ARRAY(rr, el->records, el->n_records) {
+ EventLogRecord *record = *rr;
+
+ r = table_add_many(table,
+ TABLE_UINT32, record->pcr,
+ TABLE_STRING, special_glyph(SPECIAL_GLYPH_FULL_BLOCK),
+ TABLE_SET_COLOR, color_for_pcr(el, record->pcr),
+ TABLE_STRING, tpm2_pcr_index_to_string(record->pcr));
+ if (r < 0)
+ return table_log_add_error(r);
+
+ if (EVENT_LOG_RECORD_IS_FIRMWARE(record)) {
+ const char *et;
+
+ et = tpm2_log_event_type_to_string(record->firmware_event_type);
+ if (et)
+ r = table_add_cell(table, NULL, TABLE_STRING, et);
+ else
+ r = table_add_cell(table, NULL, TABLE_UINT32_HEX, &record->firmware_event_type);
+ } else if (EVENT_LOG_RECORD_IS_USERSPACE(record))
+ r = table_add_cell(table, NULL, TABLE_STRING, tpm2_userspace_event_type_to_string(record->userspace_event_type));
+ else
+ r = table_add_cell(table, NULL, TABLE_EMPTY, NULL);
+ if (r < 0)
+ return table_log_add_error(r);
+
+ if (record->event_payload_valid < 0 || record->event_payload_valid == EVENT_PAYLOAD_VALID_DONT_KNOW)
+ r = table_add_cell(table, NULL, TABLE_EMPTY, NULL);
+ else
+ r = table_add_many(table,
+ TABLE_BOOLEAN_CHECKMARK, record->event_payload_valid == EVENT_PAYLOAD_VALID_YES,
+ TABLE_SET_COLOR, ansi_highlight_green_red(record->event_payload_valid == EVENT_PAYLOAD_VALID_YES));
+ if (r < 0)
+ return table_log_add_error(r);
+
+ FOREACH_ARRAY(alg, el->algorithms, el->n_algorithms) {
+ EventLogRecordBank *bank;
+
+ bank = event_log_record_find_bank(record, *alg);
+ if (bank) {
+ _cleanup_free_ char *hex = NULL;
+
+ hex = hexmem(bank->hash.buffer, bank->hash.size);
+ if (!hex)
+ return log_oom();
+
+ r = table_add_cell(table, NULL, TABLE_STRING, hex);
+ } else
+ r = table_add_cell(table, NULL, TABLE_EMPTY, NULL);
+ if (r < 0)
+ return table_log_add_error(r);
+ }
+
+ r = table_add_many(table,
+ TABLE_STRING, EVENT_LOG_RECORD_IS_FIRMWARE(record) ? "F" :
+ EVENT_LOG_RECORD_IS_USERSPACE(record) ? "U" : NULL,
+ TABLE_PATH_BASENAME, record->source,
+ TABLE_PATH_BASENAME, record->n_mapped > 0 ? record->mapped[0]->component->id : NULL,
+ TABLE_STRING, record->description);
+ if (r < 0)
+ return table_log_add_error(r);
+ }
+
+ if (ret_variant) {
+ r = table_to_json(table, ret_variant);
+ if (r < 0)
+ return log_error_errno(r, "Failed to format table to JSON: %m");
+
+ return 0;
+ }
+
+ r = table_print_with_pager(table, arg_json_format_flags, arg_pager_flags, /* show_header= */true);
+ if (r < 0)
+ return log_error_errno(r, "Failed to output table: %m");
+
+ return 0;
+}
+
+static bool is_unset_pcr(const void *value, size_t size) {
+ return memeqzero(value, size) || memeqbyte(0xffu, value, size);
+}
+
+static bool event_log_pcr_checks_out(const EventLog *el, const EventLogRegister *reg) {
+ assert(el);
+ assert(reg);
+
+ for (size_t i = 0; i < el->n_algorithms; i++)
+ if (memcmp_nn(reg->banks[i].calculated.buffer, reg->banks[i].calculated.size,
+ reg->banks[i].observed.buffer, reg->banks[i].observed.size) != 0)
+ return false;
+
+ return true;
+}
+
+static int show_pcr_table(EventLog *el, JsonVariant **ret_variant) {
+ _cleanup_(table_unrefp) Table *table = NULL;
+ int r;
+
+ assert(el);
+
+ table = table_new_raw(8 + el->n_algorithms*2);
+ if (!table)
+ return log_oom();
+
+ (void) table_set_ersatz_string(table, TABLE_ERSATZ_DASH);
+
+ r = table_add_many(table,
+ TABLE_HEADER, "pcr",
+ TABLE_SET_ALIGN_PERCENT, 100,
+ TABLE_HEADER, "", /* color block column */
+ TABLE_HEADER, "", /* emoji column */
+ TABLE_HEADER, "pcrname",
+ TABLE_HEADER, "count",
+ TABLE_SET_ALIGN_PERCENT, 100,
+ TABLE_HEADER, "h",
+ TABLE_SET_ALIGN_PERCENT, 100,
+ TABLE_HEADER, "r",
+ TABLE_SET_ALIGN_PERCENT, 100,
+ TABLE_HEADER, "c",
+ TABLE_SET_ALIGN_PERCENT, 100);
+ if (r < 0)
+ return table_log_add_error(r);
+
+ r = add_algorithm_columns(el, table, "Calculated", "calculated");
+ if (r < 0)
+ return r;
+
+ r = add_algorithm_columns(el, table, "Observed", "observed");
+ if (r < 0)
+ return r;
+
+ if (!FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF))
+ (void) table_hide_column_from_display(table, (size_t) 1, (size_t) 2); /* hide color block and emoji column */
+ else if (!emoji_enabled())
+ (void) table_hide_column_from_display(table, (size_t) 2);
+
+ (void) table_set_json_field_name(table, 5, "hashMatchesEventLog");
+ (void) table_set_json_field_name(table, 6, "allEventsMatched");
+ (void) table_set_json_field_name(table, 7, "noMissingComponents");
+
+ for (uint32_t pcr = 0; pcr < TPM2_PCRS_MAX; pcr++) {
+ /* Check if the PCR hash value matches the event log data */
+ bool hash_match = event_log_pcr_checks_out(el, el->registers + pcr);
+
+ /* Whether all records in this PCR have a matching component */
+ bool fully_recognized = el->registers[pcr].fully_recognized;
+
+ /* Whether any unmatched components touch this PCR */
+ bool missing_components = FLAGS_SET(el->missing_component_pcrs, UINT32_C(1) << pcr);
+
+ const char *emoji = special_glyph(
+ !hash_match ? SPECIAL_GLYPH_DEPRESSED_SMILEY :
+ !fully_recognized ? SPECIAL_GLYPH_UNHAPPY_SMILEY :
+ missing_components ? SPECIAL_GLYPH_SLIGHTLY_HAPPY_SMILEY :
+ SPECIAL_GLYPH_HAPPY_SMILEY);
+
+ r = table_add_many(table,
+ TABLE_UINT32, pcr,
+ TABLE_STRING, special_glyph(SPECIAL_GLYPH_FULL_BLOCK),
+ TABLE_SET_COLOR, color_for_pcr(el, pcr),
+ TABLE_STRING, emoji,
+ TABLE_STRING, tpm2_pcr_index_to_string(pcr));
+ if (r < 0)
+ return table_log_add_error(r);
+
+ if (el->registers[pcr].n_measurements > 0)
+ r = table_add_cell(table, NULL, TABLE_UINT, &el->registers[pcr].n_measurements);
+ else
+ r = table_add_cell(table, NULL, TABLE_EMPTY, NULL);
+ if (r < 0)
+ return table_log_add_error(r);
+
+ r = table_add_many(table,
+ TABLE_BOOLEAN_CHECKMARK, hash_match,
+ TABLE_SET_COLOR, ansi_highlight_green_red(hash_match),
+ TABLE_BOOLEAN_CHECKMARK, fully_recognized,
+ TABLE_SET_COLOR, ansi_highlight_green_red(fully_recognized),
+ TABLE_BOOLEAN_CHECKMARK, !missing_components,
+ TABLE_SET_COLOR, ansi_highlight_green_red(!missing_components));
+ if (r < 0)
+ return table_log_add_error(r);
+
+ for (size_t i = 0; i < el->n_algorithms; i++) {
+ const char *color;
+
+ color = is_unset_pcr(el->registers[pcr].banks[i].calculated.buffer, el->registers[pcr].banks[i].calculated.size) ? ANSI_GREY : NULL;
+
+ if (el->registers[pcr].banks[i].calculated.size > 0) {
+ _cleanup_free_ char *hex = NULL;
+
+ hex = hexmem(el->registers[pcr].banks[i].calculated.buffer, el->registers[pcr].banks[i].calculated.size);
+ if (!hex)
+ return log_oom();
+
+ r = table_add_many(table,
+ TABLE_STRING, hex,
+ TABLE_SET_COLOR, color);
+ } else
+ r = table_add_many(table,
+ TABLE_EMPTY,
+ TABLE_SET_COLOR, color);
+ if (r < 0)
+ return table_log_add_error(r);
+ }
+
+ for (size_t i = 0; i < el->n_algorithms; i++) {
+ _cleanup_free_ char *hex = NULL;
+ const char *color;
+
+ hex = hexmem(el->registers[pcr].banks[i].observed.buffer, el->registers[pcr].banks[i].observed.size);
+ if (!hex)
+ return log_oom();
+
+ color = !hash_match ? ANSI_HIGHLIGHT_RED :
+ is_unset_pcr(el->registers[pcr].banks[i].observed.buffer, el->registers[pcr].banks[i].observed.size) ? ANSI_GREY : NULL;
+
+ r = table_add_many(table,
+ TABLE_STRING, hex,
+ TABLE_SET_COLOR, color);
+ if (r < 0)
+ return table_log_add_error(r);
+ }
+ }
+
+ if (ret_variant) {
+ r = table_to_json(table, ret_variant);
+ if (r < 0)
+ return log_error_errno(r, "Failed to format table to JSON: %m");
+
+ return 0;
+ }
+
+ r = table_print_with_pager(table, arg_json_format_flags, arg_pager_flags, /* show_header= */ true);
+ if (r < 0)
+ return log_error_errno(r, "Failed to output table: %m");
+
+ if (FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF))
+ printf("\n"
+ "%sLegend: H → PCR hash value matches event log%s\n"
+ "%s R → All event log records for this PCR have a matching component%s\n"
+ "%s C → No components that couldn't be matched with log records affect this PCR%s\n",
+ ansi_grey(), ansi_normal(), /* less on small screens automatically resets the color after long lines, hence we set it anew for each line */
+ ansi_grey(), ansi_normal(),
+ ansi_grey(), ansi_normal());
+
+ return 0;
+}
+
+static int event_determine_primary_algorithm(EventLog *el) {
+ assert(el);
+
+ if (el->n_algorithms == 0) {
+ /* Nothing loaded to make the decision on? Then pick SHA256 */
+ el->primary_algorithm = TPM2_ALG_SHA256;
+ return 0;
+ }
+
+ FOREACH_ARRAY(alg, el->algorithms, el->n_algorithms) {
+ /* If we have SHA256, focus on that that */
+
+ if (*alg == TPM2_ALG_SHA256) {
+ el->primary_algorithm = *alg;
+ return 0;
+ }
+ }
+
+ /* Otherwise show the "best" (i.e. the one with the highest id value) */
+ el->primary_algorithm = el->algorithms[el->n_algorithms-1];
+ return 0;
+}
+
+static int event_log_load_and_process(EventLog **ret) {
+ _cleanup_(event_log_freep) EventLog *el = NULL;
+ int r;
+
+ 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);
+ 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;
+
+ r = event_determine_primary_algorithm(el);
+ if (r < 0)
+ return r;
+
+ r = event_log_load_components(el);
+ if (r < 0)
+ return r;
+
+ r = event_log_map_components(el);
+ if (r < 0)
+ return r;
+
+ *ret = TAKE_PTR(el);
+ return 0;
+}
+
+static int verb_show_log(int argc, char *argv[], void *userdata) {
+ _cleanup_(json_variant_unrefp) JsonVariant *log_table = NULL, *pcr_table = NULL;
+ _cleanup_(event_log_freep) EventLog *el = NULL;
+ bool want_json = !FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF);
+ int r;
+
+ r = event_log_load_and_process(&el);
+ if (r < 0)
+ return r;
+
+ if (!want_json)
+ putchar('\n');
+
+ r = show_log_table(el, want_json ? &log_table : NULL);
+ if (r < 0)
+ return r;
+
+ if (!want_json)
+ putchar('\n');
+
+ r = show_pcr_table(el, want_json ? &pcr_table : NULL);
+ if (r < 0)
+ return r;
+
+ if (want_json) {
+ _cleanup_(json_variant_unrefp) JsonVariant *object = NULL;
+
+ r = json_build(&object, JSON_BUILD_OBJECT(
+ JSON_BUILD_PAIR_VARIANT("log", log_table),
+ JSON_BUILD_PAIR_VARIANT("pcrs", pcr_table)));
+ if (r < 0)
+ return log_error_errno(r, "Failed to generate combined object: %m");
+
+ r = json_variant_dump(object, arg_json_format_flags, stdout, /* prefix= */ NULL);
+ if (r < 0)
+ return log_error_errno(r, "Failed to dump JSON object: %m");
+ }
+
+ return 0;
+}
+
+static int verb_show_cel(int argc, char *argv[], void *userdata) {
+ _cleanup_(json_variant_unrefp) JsonVariant *array = NULL;
+ _cleanup_(event_log_freep) EventLog *el = NULL;
+ uint64_t recnum = 0;
+ int r;
+
+ el = event_log_new();
+ if (!el)
+ return log_oom();
+
+ r = event_log_load(el);
+ if (r < 0)
+ return r;
+
+ /* Output the event log in TCG CEL-JSON. */
+
+ FOREACH_ARRAY(rr, el->records, el->n_records) {
+ _cleanup_(json_variant_unrefp) JsonVariant *ja = NULL, *fj = NULL;
+ EventLogRecord *record = *rr;
+ JsonVariant *cd = NULL;
+ const char *ct = NULL;
+
+ LIST_FOREACH(banks, bank, record->banks) {
+ r = json_variant_append_arrayb(
+ &ja, JSON_BUILD_OBJECT(
+ JSON_BUILD_PAIR_STRING("hashAlg", tpm2_hash_alg_to_string(bank->algorithm)),
+ JSON_BUILD_PAIR_HEX("digest", bank->hash.buffer, bank->hash.size)));
+ if (r < 0)
+ return log_error_errno(r, "Failed to append CEL digest entry: %m");
+ }
+
+ if (!ja) {
+ r = json_variant_new_array(&ja, NULL, 0);
+ if (r < 0)
+ return log_error_errno(r, "Failed to allocate JSON array: %m");
+ }
+
+ if (EVENT_LOG_RECORD_IS_FIRMWARE(record)) {
+ _cleanup_free_ char *et = NULL;
+ const char *z;
+
+ z = tpm2_log_event_type_to_string(record->firmware_event_type);
+ if (z) {
+ _cleanup_free_ char *b = NULL;
+
+ b = strreplace(z, "-", "_");
+ if (!b)
+ return log_oom();
+
+ et = strjoin("EV_", ascii_strupper(b));
+ if (!et)
+ return log_oom();
+ } else if (asprintf(&et, "%" PRIu32, record->firmware_event_type) < 0)
+ return log_oom();
+
+ r = json_build(&fj, JSON_BUILD_OBJECT(
+ JSON_BUILD_PAIR_STRING("event_type", et),
+ JSON_BUILD_PAIR_HEX("event_data", record->firmware_payload, record->firmware_payload_size)));
+ if (r < 0)
+ return log_error_errno(r, "Failed to build firmware event data: %m");
+
+ cd = fj;
+ ct = "pcclient_std";
+ } else if (EVENT_LOG_RECORD_IS_USERSPACE(record)) {
+ cd = record->userspace_content;
+ ct = "systemd";
+ }
+
+ r = json_variant_append_arrayb(&array,
+ JSON_BUILD_OBJECT(
+ JSON_BUILD_PAIR_UNSIGNED("pcr", record->pcr),
+ JSON_BUILD_PAIR_UNSIGNED("recnum", ++recnum),
+ JSON_BUILD_PAIR_VARIANT("digests", ja),
+ JSON_BUILD_PAIR_CONDITION(ct, "content_type", JSON_BUILD_STRING(ct)),
+ JSON_BUILD_PAIR_CONDITION(cd, "content", JSON_BUILD_VARIANT(cd))));
+ if (r < 0)
+ return log_error_errno(r, "Failed to append CEL record: %m");
+ }
+
+ if (arg_json_format_flags & (JSON_FORMAT_PRETTY|JSON_FORMAT_PRETTY_AUTO))
+ pager_open(arg_pager_flags);
+
+ json_variant_dump(array, arg_json_format_flags|JSON_FORMAT_EMPTY_ARRAY, stdout, NULL);
+ return 0;
+}
+
+static int verb_list_components(int argc, char *argv[], void *userdata) {
+ _cleanup_(event_log_freep) EventLog *el = NULL;
+ _cleanup_(table_unrefp) Table *table = NULL;
+ enum {
+ BEFORE_LOCATION,
+ BETWEEN_LOCATION,
+ AFTER_LOCATION,
+ } loc = BEFORE_LOCATION;
+ int r;
+
+ el = event_log_new();
+ if (!el)
+ return log_oom();
+
+ r = event_log_add_algorithms_from_environment(el);
+ if (r < 0)
+ return r;
+
+ r = event_determine_primary_algorithm(el);
+ if (r < 0)
+ return r;
+
+ r = event_log_load_components(el);
+ if (r < 0)
+ return r;
+
+ table = table_new("id", "variants");
+ if (!table)
+ return log_oom();
+
+ FOREACH_ARRAY(c, el->components, el->n_components) {
+
+ if (FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF)) {
+ _cleanup_free_ char *marker = NULL;
+
+ switch (loc) {
+
+ case BEFORE_LOCATION:
+ if (arg_location_end && strcmp((*c)->id, arg_location_end) >= 0) {
+ loc = AFTER_LOCATION;
+ marker = strjoin(special_glyph(SPECIAL_GLYPH_ARROW_RIGHT), " location '", arg_location_end, "' ", special_glyph(SPECIAL_GLYPH_ARROW_LEFT));
+ } else if (arg_location_start && strcmp((*c)->id, arg_location_start) >= 0) {
+ loc = BETWEEN_LOCATION;
+ marker = strjoin(special_glyph(SPECIAL_GLYPH_TREE_TOP), " start location '", arg_location_start, "' ", special_glyph(SPECIAL_GLYPH_ARROW_DOWN));
+ }
+
+ break;
+
+ case BETWEEN_LOCATION:
+ if (arg_location_end && strcmp((*c)->id, arg_location_end) >= 0) {
+ loc = AFTER_LOCATION;
+ marker = strjoin(special_glyph(SPECIAL_GLYPH_TREE_RIGHT), " end location '", arg_location_end, "' ", special_glyph(SPECIAL_GLYPH_ARROW_UP));
+ }
+ break;
+
+ case AFTER_LOCATION:
+ break;
+ }
+
+ if (marker) {
+ r = table_add_many(table,
+ TABLE_STRING, marker,
+ TABLE_SET_COLOR, ANSI_GREY,
+ TABLE_EMPTY);
+ if (r < 0)
+ return table_log_add_error(r);
+ }
+ }
+
+ FOREACH_ARRAY(variant, (*c)->variants, (*c)->n_variants) {
+ r = table_add_many(table,
+ TABLE_STRING, (*c)->id,
+ TABLE_PATH, (*variant)->path);
+ if (r < 0)
+ return table_log_add_error(r);
+ }
+ }
+
+ if (table_get_rows(table) > 1 || !FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF)) {
+ r = table_print_with_pager(table, arg_json_format_flags, arg_pager_flags, /* show_header= */ true);
+ if (r < 0)
+ return log_error_errno(r, "Failed to output table: %m");
+ }
+
+ if (FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF)) {
+ if (table_get_rows(table) > 1)
+ printf("\n%zu components listed.\n", table_get_rows(table) - 1);
+ else
+ printf("No components defined.\n");
+ }
+
+ return 0;
+}
+
+static int event_log_pcr_mask_checks_out(EventLog *el, uint32_t mask) {
+ assert(el);
+
+ for (uint32_t pcr = 0; pcr < TPM2_PCRS_MAX; pcr++) {
+
+ if (!FLAGS_SET(mask, UINT32_C(1) << pcr))
+ continue;
+
+ if (!event_log_pcr_checks_out(el, el->registers + pcr))
+ return log_error_errno(SYNTHETIC_ERRNO(EBADMSG), "Event log for PCR %" PRIu32 " does not match PCR state, refusing.", pcr);
+ }
+
+ return 0;
+}
+
+static int make_pcrlock_record(
+ uint32_t pcr,
+ const void *data,
+ size_t data_size,
+ JsonVariant **ret_record) {
+
+ _cleanup_(json_variant_unrefp) JsonVariant *digests = NULL;
+ int r;
+
+ assert(data || data_size == 0);
+ assert(ret_record);
+
+ if (data_size == SIZE_MAX)
+ data_size = strlen(data);
+
+ /* Generates a .pcrlock record for the given PCR and data/data size. This is a subset of TCG CEL. */
+
+ FOREACH_ARRAY(pa, tpm2_hash_algorithms, TPM2_N_HASH_ALGORITHMS) {
+ _cleanup_free_ unsigned char *hash = NULL;
+ int hash_ssize;
+ unsigned hash_usize;
+ const EVP_MD *md;
+ const char *a;
+
+ assert_se(a = tpm2_hash_alg_to_string(*pa));
+ assert_se(md = EVP_get_digestbyname(a));
+ hash_ssize = EVP_MD_size(md);
+ assert_se(hash_ssize > 0);
+ hash_usize = hash_ssize;
+
+ hash = malloc(hash_usize);
+ if (!hash)
+ return log_oom();
+
+ if (EVP_Digest(data, data_size, hash, &hash_usize, md, NULL) != 1)
+ return log_error_errno(SYNTHETIC_ERRNO(ENOTRECOVERABLE), "Failed to hash data with algorithm '%s'.", a);
+
+ r = json_variant_append_arrayb(
+ &digests,
+ JSON_BUILD_OBJECT(
+ JSON_BUILD_PAIR("hashAlg", JSON_BUILD_STRING(a)),
+ JSON_BUILD_PAIR("digest", JSON_BUILD_HEX(hash, hash_usize))));
+ if (r < 0)
+ return log_error_errno(r, "Failed to build JSON digest object: %m");
+ }
+
+ r = json_build(ret_record,
+ JSON_BUILD_OBJECT(
+ JSON_BUILD_PAIR("pcr", JSON_BUILD_UNSIGNED(pcr)),
+ JSON_BUILD_PAIR("digests", JSON_BUILD_VARIANT(digests))));
+ if (r < 0)
+ return log_error_errno(r, "Failed to build record object: %m");
+
+ return 0;
+}
+
+static const char *pcrlock_path(const char *default_pcrlock_path) {
+ return arg_pcrlock_path ?: arg_pcrlock_auto ? default_pcrlock_path : NULL;
+}
+
+static int write_pcrlock(JsonVariant *array, const char *default_pcrlock_path) {
+ _cleanup_(json_variant_unrefp) JsonVariant *v = NULL, *a = NULL;
+ _cleanup_fclose_ FILE *f = NULL;
+ const char *p;
+ int r;
+
+ if (!array) {
+ r = json_variant_new_array(&a, NULL, 0);
+ if (r < 0)
+ return log_error_errno(r, "Failed to allocate empty array: %m");
+
+ array = a;
+ }
+
+ r = json_build(&v, JSON_BUILD_OBJECT(
+ JSON_BUILD_PAIR("records", JSON_BUILD_VARIANT(array))));
+ if (r < 0)
+ return log_error_errno(r, "Failed to build JSON object: %m");
+
+ p = pcrlock_path(default_pcrlock_path);
+ if (p) {
+ (void) mkdir_parents_label(p, 0755);
+
+ f = fopen(p, "we");
+ if (!f)
+ return log_error_errno(errno, "Failed to open %s for writing: %m", p);
+ }
+
+ r = json_variant_dump(v, arg_json_format_flags, f ?: stdout, /* prefix= */ NULL);
+ if (r < 0)
+ return log_error_errno(r, "Failed to output JSON object: %m");
+
+ if (p)
+ log_info("%s written.", p);
+
+ return 0;
+}
+
+static int unlink_pcrlock(const char *default_pcrlock_path) {
+ const char *p;
+
+ p = pcrlock_path(default_pcrlock_path);
+ if (!p)
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "No .pcrlock path specified, refusing.");
+
+ if (unlink(p) < 0) {
+ if (errno != ENOENT)
+ return log_error_errno(errno, "Failed to delete %s: %m", p);
+
+ log_info("%s already deleted.", p);
+ } else
+ log_info("%s deleted.", p);
+
+ (void) rmdir_parents(p, "/var/lib");
+
+ return 0;
+}
+
+static int verb_lock_raw(int argc, char *argv[], void *userdata) {
+ _cleanup_(json_variant_unrefp) JsonVariant *array = NULL;
+ _cleanup_free_ char *data = NULL;
+ _cleanup_fclose_ FILE *f = NULL;
+ size_t size;
+ 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 = read_full_stream(f ?: stdin, &data, &size);
+ if (r < 0)
+ return log_error_errno(r, "Failed to read data from stdin: %m");
+
+ for (uint32_t i = 0; i < TPM2_PCRS_MAX; i++) {
+ _cleanup_(json_variant_unrefp) JsonVariant *record = NULL;
+
+ if (!FLAGS_SET(arg_pcr_mask, UINT32_C(1) << i))
+ continue;
+
+ r = make_pcrlock_record(i, data, size, &record);
+ if (r < 0)
+ return r;
+
+ r = 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, NULL);
+}
+
+static int verb_unlock_simple(int argc, char *argv[], void *userdata) {
+ return unlink_pcrlock(NULL);
+}
+
+static int verb_lock_secureboot_policy(int argc, char *argv[], void *userdata) {
+ 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_(json_variant_unrefp) JsonVariant *array = NULL;
+ int r;
+
+ /* Generates expected records from the current SecureBoot state, as readable in the EFI variables
+ * right now. */
+
+ FOREACH_ARRAY(vv, variables, ELEMENTSOF(variables)) {
+ _cleanup_(json_variant_unrefp) JsonVariant *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 = 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);
+}
+
+static int verb_unlock_secureboot_policy(int argc, char *argv[], 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 verb_lock_secureboot_authority(int argc, char *argv[], void *userdata) {
+ _cleanup_(json_variant_unrefp) JsonVariant *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);
+ 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_(json_variant_unrefp) JsonVariant *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 = json_variant_append_arrayb(
+ &digests,
+ JSON_BUILD_OBJECT(
+ JSON_BUILD_PAIR("hashAlg", JSON_BUILD_STRING(tpm2_hash_alg_to_string(bank->algorithm))),
+ JSON_BUILD_PAIR("digest", JSON_BUILD_HEX(bank->hash.buffer, bank->hash.size))));
+ if (r < 0)
+ return log_error_errno(r, "Failed to build digests array: %m");
+ }
+
+ r = json_variant_append_arrayb(
+ &array,
+ JSON_BUILD_OBJECT(
+ JSON_BUILD_PAIR("pcr", JSON_BUILD_UNSIGNED(rec->pcr)),
+ JSON_BUILD_PAIR("digests", JSON_BUILD_VARIANT(digests))));
+ if (r < 0)
+ return log_error_errno(r, "Failed to build record array: %m");
+ }
+
+ return write_pcrlock(array, PCRLOCK_SECUREBOOT_AUTHORITY_PATH);
+}
+
+static int verb_unlock_secureboot_authority(int argc, char *argv[], void *userdata) {
+ return unlink_pcrlock(PCRLOCK_SECUREBOOT_AUTHORITY_PATH);
+}
+
+static int verb_lock_gpt(int argc, char *argv[], void *userdata) {
+ _cleanup_(json_variant_unrefp) JsonVariant *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: %m");
+
+ /* 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: %m");
+
+ 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 = 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);
+}
+
+static int verb_unlock_gpt(int argc, char *argv[], void *userdata) {
+ return unlink_pcrlock(PCRLOCK_GPT_PATH);
+}
+
+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 */
+}
+
+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, JSON_FORMAT_SSE))
+ return;
+
+ log_notice("Enabling JSON_SEQ mode, since writing two .pcrlock files to single output.");
+ arg_json_format_flags |= JSON_FORMAT_SSE;
+}
+
+static int verb_lock_firmware(int argc, char *argv[], void *userdata) {
+ _cleanup_(json_variant_unrefp) JsonVariant *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 (endswith(argv[0], "firmware-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 {
+ assert(endswith(argv[0], "firmware-config"));
+ 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);
+ 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_(json_variant_unrefp) JsonVariant *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 = json_variant_append_arrayb(
+ &digests,
+ JSON_BUILD_OBJECT(
+ JSON_BUILD_PAIR("hashAlg", JSON_BUILD_STRING(tpm2_hash_alg_to_string(bank->algorithm))),
+ JSON_BUILD_PAIR("digest", JSON_BUILD_HEX(bank->hash.buffer, bank->hash.size))));
+ if (r < 0)
+ return log_error_errno(r, "Failed to build digests array: %m");
+ }
+
+ r = json_variant_append_arrayb(
+ FLAGS_SET(separator_seen_mask, bit) ? &array_late : &array_early,
+ JSON_BUILD_OBJECT(
+ JSON_BUILD_PAIR("pcr", JSON_BUILD_UNSIGNED(rec->pcr)),
+ JSON_BUILD_PAIR("digests", JSON_BUILD_VARIANT(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);
+}
+
+static int verb_unlock_firmware(int argc, char *argv[], void *userdata) {
+ const char *default_pcrlock_early_path, *default_pcrlock_late_path;
+ int r;
+
+ if (endswith(argv[0], "firmware-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;
+}
+
+static int verb_lock_machine_id(int argc, char *argv[], void *userdata) {
+ _cleanup_(json_variant_unrefp) JsonVariant *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 = 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);
+}
+
+static int verb_unlock_machine_id(int argc, char *argv[], 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);
+
+ 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;
+}
+
+static int verb_lock_file_system(int argc, char *argv[], 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_(json_variant_unrefp) JsonVariant *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 = 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;
+}
+
+static int verb_unlock_file_system(int argc, char *argv[], 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;
+}
+
+static int verb_lock_pe(int argc, char *argv[], void *userdata) {
+ _cleanup_(json_variant_unrefp) JsonVariant *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
+
+ if (argc >= 2) {
+ fd = open(argv[1], O_RDONLY|O_CLOEXEC);
+ if (fd < 0)
+ return log_error_errno(errno, "Failed to open '%s': %m", argv[1]);
+ }
+
+ 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_(json_variant_unrefp) JsonVariant *digests = NULL;
+
+ if (!FLAGS_SET(arg_pcr_mask, UINT32_C(1) << 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;
+ const char *a;
+
+ assert_se(a = tpm2_hash_alg_to_string(*pa));
+ assert_se(md = EVP_get_digestbyname(a));
+
+ r = pe_hash(fd < 0 ? STDIN_FILENO : fd, md, &hash, &hash_size);
+ if (r < 0)
+ return log_error_errno(r, "Failed to hash PE binary: %m");
+
+ r = json_variant_append_arrayb(&digests,
+ JSON_BUILD_OBJECT(
+ JSON_BUILD_PAIR("hashAlg", JSON_BUILD_STRING(a)),
+ JSON_BUILD_PAIR("digest", JSON_BUILD_HEX(hash, hash_size))));
+ if (r < 0)
+ return log_error_errno(r, "Failed to build JSON digest object: %m");
+ }
+
+ r = json_variant_append_arrayb(
+ &array,
+ JSON_BUILD_OBJECT(
+ JSON_BUILD_PAIR("pcr", JSON_BUILD_UNSIGNED(i)),
+ JSON_BUILD_PAIR("digests", JSON_BUILD_VARIANT(digests))));
+ if (r < 0)
+ return log_error_errno(r, "Failed to append record object: %m");
+ }
+
+ return write_pcrlock(array, 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]);
+}
+
+static int verb_lock_uki(int argc, char *argv[], void *userdata) {
+ _cleanup_(json_variant_unrefp) JsonVariant *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.");
+
+ if (argc >= 2) {
+ fd = open(argv[1], O_RDONLY|O_CLOEXEC);
+ if (fd < 0)
+ return log_error_errno(errno, "Failed to open '%s': %m", argv[1]);
+ }
+
+ 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 = EVP_get_digestbyname(a));
+
+ r = pe_hash(fd < 0 ? STDIN_FILENO : fd, md, &peh, hash_sizes + i);
+ if (r < 0)
+ return log_error_errno(r, "Failed to hash PE binary: %m");
+
+ r = json_variant_append_arrayb(
+ &pe_digests,
+ JSON_BUILD_OBJECT(
+ JSON_BUILD_PAIR("hashAlg", JSON_BUILD_STRING(a)),
+ JSON_BUILD_PAIR("digest", 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 < 0 ? STDIN_FILENO : 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 = json_variant_append_arrayb(
+ &array,
+ JSON_BUILD_OBJECT(
+ JSON_BUILD_PAIR("pcr", JSON_BUILD_UNSIGNED(TPM2_PCR_BOOT_LOADER_CODE)),
+ JSON_BUILD_PAIR("digests", JSON_BUILD_VARIANT(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_(json_variant_unrefp) JsonVariant *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 = json_variant_append_arrayb(
+ &section_digests,
+ JSON_BUILD_OBJECT(
+ JSON_BUILD_PAIR("hashAlg", JSON_BUILD_STRING(a)),
+ JSON_BUILD_PAIR("digest", 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 = 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 = json_variant_append_arrayb(
+ &array,
+ JSON_BUILD_OBJECT(
+ JSON_BUILD_PAIR("pcr", JSON_BUILD_UNSIGNED(TPM2_PCR_KERNEL_BOOT /* =11 */)),
+ JSON_BUILD_PAIR("digests", JSON_BUILD_VARIANT(section_digests))));
+ if (r < 0)
+ return log_error_errno(r, "Failed to append record object: %m");
+ }
+
+ return write_pcrlock(array, NULL);
+}
+
+static int event_log_reduce_to_safe_pcrs(EventLog *el, uint32_t *pcrs) {
+ _cleanup_free_ char *dropped = NULL, *kept = NULL;
+
+ assert(el);
+ assert(pcrs);
+
+ /* When we compile a new PCR policy we don't want to bind to PCRs which are fishy for one of three
+ * reasons:
+ *
+ * 1. The PCR value doesn't match the event log
+ * 2. The event log for the PCR contains measurements we don't know responsible components for
+ * 3. The event log for the PCR does not contain measurements for components we know
+ *
+ * This function checks for the three conditions and drops the PCR from the mask.
+ */
+
+ for (uint32_t pcr = 0; pcr < TPM2_PCRS_MAX; pcr++) {
+
+ if (!FLAGS_SET(*pcrs, UINT32_C(1) << pcr))
+ continue;
+
+ if (!event_log_pcr_checks_out(el, el->registers + pcr)) {
+ log_notice("PCR %" PRIu32 " (%s) value does not match event log. Removing from set of PCRs.", pcr, strna(tpm2_pcr_index_to_string(pcr)));
+ goto drop;
+ }
+
+ if (!el->registers[pcr].fully_recognized) {
+ log_notice("PCR %" PRIu32 " (%s) event log contains unrecognized measurements. Removing from set of PCRs.", pcr, strna(tpm2_pcr_index_to_string(pcr)));
+ goto drop;
+ }
+
+ if (FLAGS_SET(el->missing_component_pcrs, UINT32_C(1) << pcr)) {
+ log_notice("PCR %" PRIu32 " (%s) is touched by component we can't find in event log. Removing from set of PCRs.", pcr, strna(tpm2_pcr_index_to_string(pcr)));
+ goto drop;
+ }
+
+ log_info("PCR %" PRIu32 " (%s) matches event log and fully consists of recognized measurements. Including in set of PCRs.", pcr, strna(tpm2_pcr_index_to_string(pcr)));
+
+ if (strextendf_with_separator(&kept, ", ", "%" PRIu32 " (%s)", pcr, tpm2_pcr_index_to_string(pcr)) < 0)
+ return log_oom();
+
+ continue;
+
+ drop:
+ *pcrs &= ~(UINT32_C(1) << pcr);
+
+ if (strextendf_with_separator(&dropped, ", ", "%" PRIu32 " (%s)", pcr, tpm2_pcr_index_to_string(pcr)) < 0)
+ return log_oom();
+ }
+
+ if (dropped)
+ log_notice("PCRs dropped from protection mask: %s", dropped);
+ else
+ log_debug("No PCRs dropped from protection mask.");
+
+ if (kept)
+ log_notice("PCRs in protection mask: %s", kept);
+ else
+ log_notice("No PCRs kept in protection mask.");
+
+ return 0;
+}
+
+static int verb_lock_kernel_cmdline(int argc, char *argv[], void *userdata) {
+ _cleanup_(json_variant_unrefp) JsonVariant *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 = 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;
+}
+
+static int verb_unlock_kernel_cmdline(int argc, char *argv[], void *userdata) {
+ return unlink_pcrlock(PCRLOCK_KERNEL_CMDLINE_PATH);
+}
+
+static int verb_lock_kernel_initrd(int argc, char *argv[], void *userdata) {
+ _cleanup_(json_variant_unrefp) JsonVariant *record = NULL, *array = NULL;
+ _cleanup_free_ void *data = NULL;
+ _cleanup_fclose_ FILE *f = NULL;
+ size_t size;
+ 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 = read_full_stream(f ?: stdin, (char**) &data, &size);
+ if (r < 0)
+ return log_error_errno(r, "Failed to read data from stdin: %m");
+
+ r = make_pcrlock_record(TPM2_PCR_KERNEL_INITRD /* = 9 */, data, size, &record);
+ if (r < 0)
+ return r;
+
+ r = 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_INITRD_PATH);
+ if (r < 0)
+ return r;
+
+ return 0;
+}
+
+static int verb_unlock_kernel_initrd(int argc, char *argv[], void *userdata) {
+ return unlink_pcrlock(PCRLOCK_KERNEL_INITRD_PATH);
+}
+
+static int pcr_prediction_add_result(
+ Tpm2PCRPrediction *context,
+ Tpm2PCRPredictionResult *result,
+ uint32_t pcr,
+ const char *path,
+ size_t offset) {
+
+ _cleanup_free_ Tpm2PCRPredictionResult *copy = NULL;
+ int r;
+
+ assert(context);
+ assert(result);
+
+ copy = newdup(Tpm2PCRPredictionResult, result, 1);
+ if (!copy)
+ return log_oom();
+
+ r = ordered_set_ensure_put(context->results + pcr, &tpm2_pcr_prediction_result_hash_ops, copy);
+ if (r == -EEXIST) /* Multiple identical results for the same PCR are totally expected */
+ return 0;
+ if (r < 0)
+ return log_error_errno(r, "Failed to insert result into set: %m");
+
+ log_debug("Added prediction result %u for PCR %" PRIu32 " (path: %s)", ordered_set_size(context->results[pcr]), pcr, strempty(path));
+
+ TAKE_PTR(copy);
+ return 0;
+}
+
+static const EVP_MD* evp_from_tpm2_alg(uint16_t alg) {
+ const char *name;
+
+ name = tpm2_hash_alg_to_string(alg);
+ if (!name)
+ return NULL;
+
+ return EVP_get_digestbyname(name);
+}
+
+static int event_log_component_variant_calculate(
+ Tpm2PCRPrediction *context,
+ Tpm2PCRPredictionResult *result,
+ EventLogComponent *component,
+ EventLogComponentVariant *variant,
+ uint32_t pcr,
+ const char *path) {
+
+ int r;
+
+ assert(context);
+ assert(result);
+ assert(component);
+ assert(variant);
+
+ FOREACH_ARRAY(rr, variant->records, variant->n_records) {
+ EventLogRecord *rec = *rr;
+
+ if (rec->pcr != pcr)
+ continue;
+
+ for (size_t i = 0; i < TPM2_N_HASH_ALGORITHMS; i++) {
+ _cleanup_(EVP_MD_CTX_freep) EVP_MD_CTX *md_ctx = NULL;
+ EventLogRecordBank *b;
+
+ if (result->hash[i].size <= 0) /* already invalidated */
+ continue;
+
+ b = event_log_record_find_bank(rec, tpm2_hash_algorithms[i]);
+ if (!b) {
+ /* Can't calculate, hence invalidate */
+ result->hash[i] = (TPM2B_DIGEST) {};
+ continue;
+ }
+
+ md_ctx = EVP_MD_CTX_new();
+ if (!md_ctx)
+ return log_oom();
+
+ const EVP_MD *md = ASSERT_PTR(evp_from_tpm2_alg(tpm2_hash_algorithms[i]));
+
+ int sz = EVP_MD_size(md);
+ assert(sz > 0);
+ assert((size_t) sz <= sizeof_field(TPM2B_DIGEST, buffer));
+
+ assert(sz == tpm2_hash_alg_to_size(tpm2_hash_algorithms[i]));
+
+ assert(result->hash[i].size == (size_t) sz);
+ assert(b->hash.size == (size_t) sz);
+
+ if (EVP_DigestInit_ex(md_ctx, md, NULL) != 1)
+ return log_error_errno(SYNTHETIC_ERRNO(ENOTRECOVERABLE), "Failed to initialize message digest.");
+
+ if (EVP_DigestUpdate(md_ctx, result->hash[i].buffer, sz) != 1)
+ return log_error_errno(SYNTHETIC_ERRNO(ENOTRECOVERABLE), "Failed to hash bank value.");
+
+ if (EVP_DigestUpdate(md_ctx, b->hash.buffer, sz) != 1)
+ return log_error_errno(SYNTHETIC_ERRNO(ENOTRECOVERABLE), "Failed to hash data value.");
+
+ unsigned l = (unsigned) sz;
+ if (EVP_DigestFinal_ex(md_ctx, result->hash[i].buffer, &l) != 1)
+ return log_error_errno(SYNTHETIC_ERRNO(ENOTRECOVERABLE), "Failed to finalize message digest.");
+
+ assert(l == (unsigned) sz);
+ }
+
+ /* This is a valid result once we hit the start location */
+ if (arg_location_start && strcmp(component->id, arg_location_start) >= 0) {
+ r = pcr_prediction_add_result(context, result, pcr, path, rr - variant->records);
+ if (r < 0)
+ return r;
+ }
+ }
+
+ return 0;
+}
+
+static int event_log_predict_pcrs(
+ EventLog *el,
+ Tpm2PCRPrediction *context,
+ Tpm2PCRPredictionResult *parent_result,
+ size_t component_index,
+ uint32_t pcr,
+ const char *path) {
+
+ EventLogComponent *component;
+ int count = 0, r;
+
+ assert(el);
+ assert(context);
+ assert(parent_result);
+
+ /* Check if we reached the end of the components, generate a result, and backtrack */
+ if (component_index >= el->n_components ||
+ (arg_location_end && strcmp(el->components[component_index]->id, arg_location_end) > 0)) {
+ r = pcr_prediction_add_result(context, parent_result, pcr, path, /* offset= */ 0);
+ if (r < 0)
+ return r;
+
+ return 1;
+ }
+
+ component = ASSERT_PTR(el->components[component_index]);
+
+ FOREACH_ARRAY(ii, component->variants, component->n_variants) {
+ _cleanup_free_ Tpm2PCRPredictionResult *result = NULL;
+ EventLogComponentVariant *variant = *ii;
+ _cleanup_free_ char *subpath = NULL;
+
+ /* Operate on a copy of the result */
+
+ if (path)
+ subpath = strjoin(path, ":", component->id);
+ else
+ subpath = strdup(component->id);
+ if (!subpath)
+ return log_oom();
+
+ if (!streq(component->id, variant->id))
+ if (!strextend(&subpath, "@", variant->id))
+ return log_oom();
+
+ result = newdup(Tpm2PCRPredictionResult, parent_result, 1);
+ if (!result)
+ return log_oom();
+
+ r = event_log_component_variant_calculate(
+ context,
+ result,
+ component,
+ variant,
+ pcr,
+ subpath);
+ if (r < 0)
+ return r;
+
+ r = event_log_predict_pcrs(
+ el,
+ context,
+ result,
+ component_index + 1, /* Next component */
+ pcr,
+ subpath);
+ if (r < 0)
+ return r;
+
+ count += r;
+ }
+
+ return count;
+}
+
+static ssize_t event_log_calculate_component_combinations(EventLog *el) {
+ ssize_t count = 1;
+ assert(el);
+
+ FOREACH_ARRAY(cc, el->components, el->n_components) {
+ EventLogComponent *c = *cc;
+
+ /* Overflow check */
+ if (c->n_variants > (size_t) (SSIZE_MAX/count))
+ return log_error_errno(SYNTHETIC_ERRNO(E2BIG), "Too many component combinations.");
+
+ count *= c->n_variants;
+ }
+
+ return count;
+}
+
+static int event_log_show_predictions(Tpm2PCRPrediction *context, uint16_t alg) {
+ int r;
+
+ assert(context);
+
+ pager_open(arg_pager_flags);
+
+ if (!FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF)) {
+ _cleanup_(json_variant_unrefp) JsonVariant *j = NULL;
+
+ for (size_t i = 0; i < TPM2_N_HASH_ALGORITHMS; i++) {
+ _cleanup_(json_variant_unrefp) JsonVariant *aj = NULL;
+
+ r = tpm2_pcr_prediction_to_json(
+ context,
+ tpm2_hash_algorithms[i],
+ &aj);
+ if (r < 0)
+ return r;
+
+ if (json_variant_elements(aj) == 0)
+ continue;
+
+ r = json_variant_set_field(
+ &j,
+ tpm2_hash_alg_to_string(tpm2_hash_algorithms[i]),
+ aj);
+ if (r < 0)
+ return log_error_errno(r, "Failed to add prediction bank to object: %m");
+ }
+
+ if (!j) {
+ r = json_variant_new_object(&j, NULL, 0);
+ if (r < 0)
+ return log_error_errno(r, "Failed to allocated empty object: %m");
+ }
+
+ json_variant_dump(j, arg_json_format_flags, /* f= */ NULL, /* prefix= */ NULL);
+ return 0;
+ }
+
+ for (uint32_t pcr = 0; pcr < TPM2_PCRS_MAX; pcr++) {
+ Tpm2PCRPredictionResult *result;
+ if (!FLAGS_SET(context->pcrs, UINT32_C(1) << pcr))
+ continue;
+
+ if (ordered_set_isempty(context->results[pcr])) {
+ printf("No results for PCR %u (%s).\n", pcr, tpm2_pcr_index_to_string(pcr));
+ continue;
+ }
+
+ printf("%sResults for PCR %u (%s):%s\n", ansi_underline(), pcr, tpm2_pcr_index_to_string(pcr), ansi_normal());
+
+ ORDERED_SET_FOREACH(result, context->results[pcr]) {
+
+ _cleanup_free_ char *aa = NULL, *h = NULL;
+ const char *a;
+
+ TPM2B_DIGEST *hash = tpm2_pcr_prediction_result_get_hash(result, alg);
+ if (!hash)
+ continue;
+
+ a = ASSERT_PTR(tpm2_hash_alg_to_string(alg));
+ aa = strdup(a);
+ if (!aa)
+ return log_oom();
+
+ ascii_strlower(aa);
+
+ h = hexmem(hash->buffer, hash->size);
+ if (!h)
+ return log_oom();
+
+ printf(" %s%-6s:%s %s\n", ansi_grey(), aa, ansi_normal(), h);
+ }
+ }
+
+ return 0;
+}
+
+static int tpm2_pcr_prediction_run(
+ EventLog *el,
+ Tpm2PCRPrediction *context) {
+
+ int r;
+
+ assert(el);
+ assert(context);
+
+ for (uint32_t pcr = 0; pcr < TPM2_PCRS_MAX; pcr++) {
+ _cleanup_free_ Tpm2PCRPredictionResult *result = NULL;
+
+ if (!FLAGS_SET(context->pcrs, UINT32_C(1) << pcr))
+ continue;
+
+ result = new0(Tpm2PCRPredictionResult, 1);
+ if (!result)
+ return log_oom();
+
+ for (size_t i = 0; i < TPM2_N_HASH_ALGORITHMS; i++)
+ event_log_initial_pcr_state(el, pcr, tpm2_hash_alg_to_size(tpm2_hash_algorithms[i]), result->hash + i);
+
+ r = event_log_predict_pcrs(
+ el,
+ context,
+ result,
+ /* component_index= */ 0,
+ pcr,
+ /* path= */ NULL);
+ if (r < 0)
+ return r;
+ }
+
+ return 0;
+}
+
+static int verb_predict(int argc, char *argv[], void *userdata) {
+ _cleanup_(tpm2_pcr_prediction_done) Tpm2PCRPrediction context = {
+ arg_pcr_mask != 0 ? arg_pcr_mask : DEFAULT_PCR_MASK,
+ };
+ _cleanup_(event_log_freep) EventLog *el = NULL;
+ ssize_t count;
+ int r;
+
+ r = event_log_load_and_process(&el);
+ if (r < 0)
+ return r;
+
+ count = event_log_calculate_component_combinations(el);
+ if (count < 0)
+ return count;
+
+ log_info("%zi combinations of components.", count);
+
+ r = event_log_reduce_to_safe_pcrs(el, &context.pcrs);
+ if (r < 0)
+ return r;
+
+ r = tpm2_pcr_prediction_run(el, &context);
+ if (r < 0)
+ return r;
+
+ return event_log_show_predictions(&context, el->primary_algorithm);
+}
+
+static int remove_policy_file(const char *path) {
+ assert(path);
+
+ if (unlink(path) < 0) {
+ if (errno == ENOENT)
+ return 0;
+
+ return log_error_errno(errno, "Failed to remove policy file '%s': %m", path);
+ }
+
+ log_info("Removed policy file '%s'.", path);
+ return 1;
+}
+
+static int verb_make_policy(int argc, char *argv[], void *userdata) {
+ int r;
+
+ /* Here's how this all works: after predicting all possible PCR values for next boot (with
+ * alternatives) we'll calculate a policy from it as a combination of PolicyPCR + PolicyOR
+ * expressions. This is then stored in an NV index. When a component of the boot process is changed a
+ * new prediction is made and the NV index updated (which automatically invalidates any older
+ * policies).
+ *
+ * Whenever we want to lock an encrypted object (for example FDE) against this policy, we'll use a
+ * PolicyAuthorizeNV epxression that pins the NV index in the policy, and permits access to any
+ * policies matching the current NV index contents.
+ *
+ * We grant world-readable read access to the NV index. Write access is controlled by a PIN (which we
+ * either generate locally or which the user can provide us with) which can also be used for
+ * recovery. This PIN is sealed to the TPM and is locked via PolicyAuthorizeNV to the NV index it
+ * protects (i.e. we dogfood 🌭 🐶 hard here). This means in order to update such a policy we need
+ * the policy to pass.
+ *
+ * Information about the used NV Index, the SRK of the TPM, the sealed PIN and the current PCR
+ * prediction data are stored in a JSON file in /var/lib/. In order to be able to unlock root disks
+ * this data must be also copied to the ESP so that it is available to the initrd. The data is not
+ * sensitive, as SRK and NV index are pinned by it, and the prediction data must match the NV index
+ * to be useful. */
+
+ usec_t start_usec = now(CLOCK_MONOTONIC);
+
+ _cleanup_(event_log_freep) EventLog *el = NULL;
+ r = event_log_load_and_process(&el);
+ if (r < 0)
+ return r;
+
+ _cleanup_(tpm2_pcr_prediction_done) Tpm2PCRPrediction new_prediction = {
+ arg_pcr_mask != 0 ? arg_pcr_mask : DEFAULT_PCR_MASK,
+ };
+ r = event_log_reduce_to_safe_pcrs(el, &new_prediction.pcrs);
+ if (r < 0)
+ return r;
+
+ usec_t predict_start_usec = now(CLOCK_MONOTONIC);
+
+ r = tpm2_pcr_prediction_run(el, &new_prediction);
+ if (r < 0)
+ return r;
+
+ log_info("Predicted future PCRs in %s.", FORMAT_TIMESPAN(usec_sub_unsigned(now(CLOCK_MONOTONIC), predict_start_usec), 1));
+
+ _cleanup_(json_variant_unrefp) JsonVariant *new_prediction_json = NULL;
+ r = tpm2_pcr_prediction_to_json(&new_prediction, el->primary_algorithm, &new_prediction_json);
+ if (r < 0)
+ return r;
+
+ if (DEBUG_LOGGING)
+ (void) json_variant_dump(new_prediction_json, JSON_FORMAT_PRETTY_AUTO|JSON_FORMAT_COLOR_AUTO, stderr, NULL);
+
+ _cleanup_(tpm2_pcrlock_policy_done) Tpm2PCRLockPolicy old_policy = {};
+
+ r = tpm2_pcrlock_policy_load(arg_pcrlock_path, &old_policy);
+ if (r < 0)
+ return r;
+
+ bool have_old_policy = r > 0;
+
+ /* When we update the policy the old serializations for NV, SRK, PIN remain the same */
+ _cleanup_(iovec_done) struct iovec
+ nv_blob = TAKE_STRUCT(old_policy.nv_handle),
+ nv_public_blob = TAKE_STRUCT(old_policy.nv_public),
+ srk_blob = TAKE_STRUCT(old_policy.srk_handle),
+ pin_public = TAKE_STRUCT(old_policy.pin_public),
+ pin_private = TAKE_STRUCT(old_policy.pin_private);
+
+ if (have_old_policy) {
+ if (arg_nv_index != 0 && old_policy.nv_index != arg_nv_index)
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Stored policy references different NV index (0x%x) than specified (0x%x), refusing.", old_policy.nv_index, arg_nv_index);
+
+ if (!arg_force &&
+ old_policy.algorithm == el->primary_algorithm &&
+ tpm2_pcr_prediction_equal(&old_policy.prediction, &new_prediction, el->primary_algorithm)) {
+ log_info("Prediction is identical to current policy, skipping update.");
+ return EXIT_SUCCESS;
+ }
+ }
+
+ _cleanup_(tpm2_context_unrefp) Tpm2Context *tc = NULL;
+ r = tpm2_context_new(NULL, &tc);
+ if (r < 0)
+ return log_error_errno(r, "Failed to allocate TPM2 context: %m");
+
+ if (!tpm2_supports_command(tc, TPM2_CC_PolicyAuthorizeNV))
+ return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "TPM2 does not support PolicyAuthorizeNV command, refusing.");
+
+ _cleanup_(tpm2_handle_freep) Tpm2Handle *srk_handle = NULL;
+
+ if (iovec_is_set(&srk_blob)) {
+ r = tpm2_deserialize(
+ tc,
+ srk_blob.iov_base,
+ srk_blob.iov_len,
+ &srk_handle);
+ if (r < 0)
+ return log_error_errno(r, "Failed to deserialize SRK TR: %m");
+ } else {
+ r = tpm2_get_or_create_srk(
+ tc,
+ /* session= */ NULL,
+ /* ret_public= */ NULL,
+ /* ret_name= */ NULL,
+ /* ret_qname= */ NULL,
+ &srk_handle);
+ if (r < 0)
+ return log_error_errno(r, "Failed to install SRK: %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 log_error_errno(r, "Failed to allocate encryption session: %m");
+
+ /* Acquire a recovery PIN, either from the user, or create a randomized one */
+ _cleanup_(erase_and_freep) char *pin = NULL;
+ if (arg_recovery_pin) {
+ r = getenv_steal_erase("PIN", &pin);
+ if (r < 0)
+ return log_error_errno(r, "Failed to acquire PIN from environment: %m");
+ if (r == 0) {
+ _cleanup_(strv_free_erasep) char **l = NULL;
+
+ r = ask_password_auto(
+ "Recovery PIN",
+ /* icon= */ NULL,
+ /* id= */ "pcrlock-recovery-pin",
+ /* key_name= */ NULL,
+ /* credential_name= */ "systemd-pcrlock.recovery-pin",
+ /* until= */ 0,
+ /* flags= */ 0,
+ &l);
+ if (r < 0)
+ return log_error_errno(r, "Failed to query for recovery PIN: %m");
+
+ if (strv_length(l) != 1)
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Expected a single PIN only.");
+
+ pin = TAKE_PTR(l[0]);
+ l = mfree(l);
+ }
+
+ } else if (!have_old_policy) {
+ char rnd[256];
+
+ r = crypto_random_bytes(rnd, sizeof(rnd));
+ if (r < 0)
+ return log_error_errno(r, "Failed to generate a randomized recovery PIN: %m");
+
+ (void) base64mem(rnd, sizeof(rnd), &pin);
+ explicit_bzero_safe(rnd, sizeof(rnd));
+ if (!pin)
+ return log_oom();
+ }
+
+ _cleanup_(tpm2_handle_freep) Tpm2Handle *nv_handle = NULL;
+ TPM2_HANDLE nv_index = 0;
+
+ if (iovec_is_set(&nv_blob)) {
+ r = tpm2_deserialize(tc, nv_blob.iov_base, nv_blob.iov_len, &nv_handle);
+ if (r < 0)
+ return log_error_errno(r, "Failed to deserialize NV index TR: %m");
+
+ nv_index = old_policy.nv_index;
+ }
+
+ TPM2B_AUTH auth = {};
+ CLEANUP_ERASE(auth);
+
+ if (pin) {
+ r = tpm2_get_pin_auth(TPM2_ALG_SHA256, pin, &auth);
+ if (r < 0)
+ return log_error_errno(r, "Failed to hash PIN: %m");
+ } else {
+ assert(iovec_is_set(&pin_public));
+ assert(iovec_is_set(&pin_private));
+
+ log_debug("Retrieving PIN from sealed data.");
+
+ usec_t pin_start_usec = now(CLOCK_MONOTONIC);
+
+ _cleanup_(iovec_done_erase) struct iovec secret = {};
+ for (unsigned attempt = 0;; attempt++) {
+ _cleanup_(tpm2_handle_freep) Tpm2Handle *policy_session = NULL;
+
+ r = tpm2_make_policy_session(
+ tc,
+ srk_handle,
+ encryption_session,
+ &policy_session);
+ if (r < 0)
+ return log_error_errno(r, "Failed to allocate policy session: %m");
+
+ r = tpm2_policy_super_pcr(
+ tc,
+ policy_session,
+ &old_policy.prediction,
+ old_policy.algorithm);
+ if (r < 0)
+ return log_error_errno(r, "Failed to submit super PCR policy: %m");
+
+ r = tpm2_policy_authorize_nv(
+ tc,
+ policy_session,
+ nv_handle,
+ NULL);
+ if (r < 0)
+ return log_error_errno(r, "Failed to submit AuthorizeNV policy: %m");
+
+ r = tpm2_unseal_data(
+ tc,
+ &pin_public,
+ &pin_private,
+ srk_handle,
+ policy_session,
+ encryption_session,
+ &secret);
+ if (r < 0 && (r != -ESTALE || attempt >= 16))
+ return log_error_errno(r, "Failed to unseal PIN: %m");
+ if (r == 0)
+ break;
+
+ log_debug("Trying again (attempt %u), as PCR values changed during unlock attempt.", attempt+1);
+ }
+
+ if (secret.iov_len > sizeof_field(TPM2B_AUTH, buffer))
+ return log_error_errno(SYNTHETIC_ERRNO(E2BIG), "Decrypted PIN too large.");
+
+ auth = (TPM2B_AUTH) {
+ .size = secret.iov_len,
+ };
+
+ memcpy_safe(auth.buffer, secret.iov_base, secret.iov_len);
+
+ log_info("Retrieved PIN from TPM2 in %s.", FORMAT_TIMESPAN(usec_sub_unsigned(now(CLOCK_MONOTONIC), pin_start_usec), 1));
+ }
+
+ TPM2B_NV_PUBLIC nv_public = {};
+
+ usec_t nv_index_start_usec = now(CLOCK_MONOTONIC);
+
+ if (!iovec_is_set(&nv_blob)) {
+ TPM2B_DIGEST recovery_policy_digest = TPM2B_DIGEST_MAKE(NULL, TPM2_SHA256_DIGEST_SIZE);
+ r = tpm2_calculate_policy_auth_value(&recovery_policy_digest);
+ if (r < 0)
+ return log_error_errno(r, "Failed to calculate authentication value policy: %m");
+
+ log_debug("Allocating NV index to write PCR policy to...");
+ r = tpm2_define_policy_nv_index(
+ tc,
+ encryption_session,
+ arg_nv_index,
+ &recovery_policy_digest,
+ pin,
+ &auth,
+ &nv_index,
+ &nv_handle,
+ &nv_public);
+ if (r == -EEXIST)
+ return log_error_errno(r, "NV index 0x%" PRIx32 " already allocated.", arg_nv_index);
+ if (r < 0)
+ return log_error_errno(r, "Failed to allocate NV index: %m");
+ }
+
+ r = tpm2_set_auth_binary(tc, nv_handle, &auth);
+ if (r < 0)
+ return log_error_errno(r, "Failed to set authentication value on NV index: %m");
+
+ _cleanup_(tpm2_handle_freep) Tpm2Handle *policy_session = NULL;
+ r = tpm2_make_policy_session(
+ tc,
+ srk_handle,
+ encryption_session,
+ &policy_session);
+ if (r < 0)
+ return log_error_errno(r, "Failed to allocate policy session: %m");
+
+ r = tpm2_policy_auth_value(
+ tc,
+ policy_session,
+ /* 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.iov_base, &nv_blob.iov_len);
+ 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.iov_base, &srk_blob.iov_len);
+ 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_(json_variant_unrefp) JsonVariant *new_configuration_json = NULL;
+ r = json_build(&new_configuration_json,
+ JSON_BUILD_OBJECT(
+ JSON_BUILD_PAIR_STRING("pcrBank", tpm2_hash_alg_to_string(el->primary_algorithm)),
+ JSON_BUILD_PAIR_VARIANT("pcrValues", new_prediction_json),
+ 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 = 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_pcrlock_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);
+ if (r < 0)
+ return log_error_errno(r, "Failed to write new configuration to '%s': %m", path);
+
+ if (!arg_pcrlock_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);
+
+ log_info("Overall time spent: %s", FORMAT_TIMESPAN(usec_sub_unsigned(now(CLOCK_MONOTONIC), start_usec), 1));
+
+ 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(NULL, &tc);
+ if (r < 0)
+ return r;
+
+ _cleanup_(tpm2_handle_freep) Tpm2Handle *srk_handle = NULL;
+ r = tpm2_deserialize(
+ tc,
+ srk_blob->iov_base,
+ srk_blob->iov_len,
+ &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->iov_base,
+ nv_blob->iov_len,
+ &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_policy_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 verb_remove_policy(int argc, char *argv[], void *userdata) {
+ int 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.");
+ }
+
+ if (arg_policy_path) {
+ r = remove_policy_file(arg_policy_path);
+ if (r < 0)
+ return r;
+
+ return 0;
+ } else {
+ int ret = 0;
+
+ RET_GATHER(ret, remove_policy_file("/var/lib/systemd/pcrlock.json"));
+ RET_GATHER(ret, remove_policy_file("/run/systemd/pcrlock.json"));
+
+ return ret;
+ }
+}
+
+static int help(int argc, char *argv[], void *userdata) {
+ _cleanup_free_ char *link = NULL;
+ int r;
+
+ r = terminal_urlify_man("systemd-pcrlock", "8", &link);
+ if (r < 0)
+ return log_oom();
+
+ printf("%1$s [OPTIONS...] COMMAND ...\n"
+ "\n%5$sManage a TPM2 PCR lock.%6$s\n"
+ "\n%3$sCommands:%4$s\n"
+ " log Show measurement log\n"
+ " cel Show measurement log in TCG CEL-JSON format\n"
+ " list-components List defined .pcrlock components\n"
+ " predict Predict PCR values\n"
+ " make-policy Predict PCR values and generate TPM2 policy from it\n"
+ " remove-policy Remove TPM2 policy\n"
+ "\n%3$sProtections:%4$s\n"
+ " lock-firmware-code Generate a .pcrlock file from current firmware code\n"
+ " unlock-firmware-code Remove .pcrlock file for firmware code\n"
+ " lock-firmware-config Generate a .pcrlock file from current firmware configuration\n"
+ " unlock-firmware-config Remove .pcrlock file for firmware configuration\n"
+ " lock-secureboot-policy Generate a .pcrlock file from current SecureBoot policy\n"
+ " unlock-secureboot-policy Remove .pcrlock file for SecureBoot policy\n"
+ " lock-secureboot-authority Generate a .pcrlock file from current SecureBoot authority\n"
+ " unlock-secureboot-authority Remove .pcrlock file for SecureBoot authority\n"
+ " lock-gpt [DISK] Generate a .pcrlock file from GPT header\n"
+ " unlock-gpt Remove .pcrlock file for GPT header\n"
+ " lock-pe [BINARY] Generate a .pcrlock file from PE binary\n"
+ " unlock-pe Remove .pcrlock file for PE binary\n"
+ " lock-uki [UKI] Generate a .pcrlock file from UKI PE binary\n"
+ " unlock-uki Remove .pcrlock file for UKI PE binary\n"
+ " lock-machine-id Generate a .pcrlock file from current machine ID\n"
+ " unlock-machine-id Remove .pcrlock file for machine ID\n"
+ " lock-file-system [PATH] Generate a .pcrlock file from current root fs + /var/\n"
+ " unlock-file-system [PATH] Remove .pcrlock file for root fs + /var/\n"
+ " lock-kernel-cmdline [FILE] Generate a .pcrlock file from kernel command line\n"
+ " unlock-kernel-cmdline Remove .pcrlock file for kernel command line\n"
+ " lock-kernel-initrd FILE Generate a .pcrlock file from an initrd file\n"
+ " unlock-kernel-initrd Remove .pcrlock file for an initrd file\n"
+ " lock-raw [FILE] Generate a .pcrlock file from raw data\n"
+ " unlock-raw Remove .pcrlock file for raw data\n"
+ "\n%3$sOptions:%4$s\n"
+ " -h --help Show this help\n"
+ " --version Print version\n"
+ " --no-pager Do not pipe output into a pager\n"
+ " --json=pretty|short|off Generate JSON output\n"
+ " --raw-description Show raw firmware record data as description in table\n"
+ " --pcr=NR Generate .pcrlock for specified PCR\n"
+ " --nv-index=NUMBER Use the specified NV index, instead of a random one\n"
+ " --components=PATH Directory to read .pcrlock files from\n"
+ " --location=STRING[:STRING]\n"
+ " Do not process components beyond this component name\n"
+ " --recovery-pin=yes Ask for a recovery PIN\n"
+ " --pcrlock=PATH .pcrlock file to write expected PCR measurement to\n"
+ " --policy=PATH JSON file to write policy output to\n"
+ " --force Write policy even if it matches existing policy\n"
+ "\nSee the %2$s for details.\n",
+ program_invocation_short_name,
+ link,
+ ansi_underline(),
+ ansi_normal(),
+ ansi_highlight(),
+ ansi_normal());
+
+ return 0;
+}
+
+static int parse_argv(int argc, char *argv[]) {
+ enum {
+ ARG_VERSION = 0x100,
+ ARG_NO_PAGER,
+ ARG_JSON,
+ ARG_RAW_DESCRIPTION,
+ ARG_PCR,
+ ARG_NV_INDEX,
+ ARG_COMPONENTS,
+ ARG_LOCATION,
+ ARG_RECOVERY_PIN,
+ ARG_PCRLOCK,
+ ARG_POLICY,
+ ARG_FORCE,
+ };
+
+ static const struct option options[] = {
+ { "help", no_argument, NULL, 'h' },
+ { "version", no_argument, NULL, ARG_VERSION },
+ { "no-pager", no_argument, NULL, ARG_NO_PAGER },
+ { "json", required_argument, NULL, ARG_JSON },
+ { "raw-description", no_argument, NULL, ARG_RAW_DESCRIPTION },
+ { "pcr", required_argument, NULL, ARG_PCR },
+ { "nv-index", required_argument, NULL, ARG_NV_INDEX },
+ { "components", required_argument, NULL, ARG_COMPONENTS },
+ { "location", required_argument, NULL, ARG_LOCATION },
+ { "recovery-pin", required_argument, NULL, ARG_RECOVERY_PIN },
+ { "pcrlock", required_argument, NULL, ARG_PCRLOCK },
+ { "policy", required_argument, NULL, ARG_POLICY },
+ { "force", no_argument, NULL, ARG_FORCE },
+ {}
+ };
+
+ bool auto_location = true;
+ int c, r;
+
+ assert(argc >= 0);
+ assert(argv);
+
+ while ((c = getopt_long(argc, argv, "h", options, NULL)) >= 0)
+ switch (c) {
+
+ case 'h':
+ help(0, NULL, NULL);
+ return 0;
+
+ case ARG_VERSION:
+ return version();
+
+ case ARG_NO_PAGER:
+ arg_pager_flags |= PAGER_DISABLE;
+ break;
+
+ case ARG_JSON:
+ r = parse_json_argument(optarg, &arg_json_format_flags);
+ if (r <= 0)
+ return r;
+ break;
+
+ case ARG_RAW_DESCRIPTION:
+ arg_raw_description = true;
+ break;
+
+ case ARG_PCR: {
+ r = tpm2_parse_pcr_argument_to_mask(optarg, &arg_pcr_mask);
+ if (r < 0)
+ return log_error_errno(r, "Failed to parse PCR specification: %s", optarg);
+
+ break;
+ }
+
+ case ARG_NV_INDEX:
+ if (isempty(optarg))
+ arg_nv_index = 0;
+ else {
+ uint32_t u;
+
+ r = safe_atou32_full(optarg, 16, &u);
+ if (r < 0)
+ return log_error_errno(r, "Failed to parse --nv-index= argument: %s", optarg);
+
+ 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;
+
+ case ARG_COMPONENTS: {
+ _cleanup_free_ char *p = NULL;
+
+ r = parse_path_argument(optarg, /* suppress_root= */ false, &p);
+ if (r < 0)
+ return r;
+
+ r = strv_consume(&arg_components, TAKE_PTR(p));
+ if (r < 0)
+ return log_oom();
+
+ break;
+ }
+
+ case ARG_LOCATION: {
+ _cleanup_free_ char *start = NULL, *end = NULL;
+ const char *e;
+
+ auto_location = false;
+
+ if (isempty(optarg)) {
+ arg_location_start = mfree(arg_location_start);
+ arg_location_end = mfree(arg_location_end);
+ break;
+ }
+
+ e = strchr(optarg, ':');
+ if (e) {
+ start = strndup(optarg, e - optarg);
+ if (!start)
+ return log_oom();
+
+ end = strdup(e + 1);
+ if (!end)
+ return log_oom();
+ } else {
+ start = strdup(optarg);
+ if (!start)
+ return log_oom();
+
+ end = strdup(optarg);
+ 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;
+ }
+
+ case ARG_RECOVERY_PIN:
+ r = parse_boolean_argument("--recovery-pin", optarg, &arg_recovery_pin);
+ if (r < 0)
+ return r;
+ break;
+
+ case ARG_PCRLOCK:
+ if (isempty(optarg) || streq(optarg, "-"))
+ arg_pcrlock_path = mfree(arg_pcrlock_path);
+ else {
+ r = parse_path_argument(optarg, /* suppress_root= */ false, &arg_pcrlock_path);
+ if (r < 0)
+ return r;
+ }
+
+ arg_pcrlock_auto = false;
+ break;
+
+ case ARG_POLICY:
+ if (isempty(optarg) || streq(optarg, "-"))
+ arg_policy_path = mfree(arg_policy_path);
+ else {
+ r = parse_path_argument(optarg, /* suppress_root= */ false, &arg_policy_path);
+ if (r < 0)
+ return r;
+ }
+
+ break;
+
+ case ARG_FORCE:
+ arg_force = true;
+ break;
+
+ case '?':
+ return -EINVAL;
+
+ default:
+ assert_not_reached();
+ }
+
+ 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();
+ }
+
+ return 1;
+}
+
+static int pcrlock_main(int argc, char *argv[]) {
+ static const Verb verbs[] = {
+ { "help", VERB_ANY, VERB_ANY, 0, help },
+ { "log", VERB_ANY, 1, VERB_DEFAULT, verb_show_log },
+ { "cel", VERB_ANY, 1, 0, verb_show_cel },
+ { "list-components", VERB_ANY, 1, 0, verb_list_components },
+ { "predict", VERB_ANY, 1, 0, verb_predict },
+ { "lock-firmware-code", VERB_ANY, 2, 0, verb_lock_firmware },
+ { "unlock-firmware-code", VERB_ANY, 1, 0, verb_unlock_firmware },
+ { "lock-firmware-config", VERB_ANY, 2, 0, verb_lock_firmware },
+ { "unlock-firmware-config", VERB_ANY, 1, 0, verb_unlock_firmware },
+ { "lock-secureboot-policy", VERB_ANY, 1, 0, verb_lock_secureboot_policy },
+ { "unlock-secureboot-policy", VERB_ANY, 1, 0, verb_unlock_secureboot_policy },
+ { "lock-secureboot-authority", VERB_ANY, 1, 0, verb_lock_secureboot_authority },
+ { "unlock-secureboot-authority", VERB_ANY, 1, 0, verb_unlock_secureboot_authority },
+ { "lock-gpt", VERB_ANY, 2, 0, verb_lock_gpt },
+ { "unlock-gpt", VERB_ANY, 1, 0, verb_unlock_gpt },
+ { "lock-pe", VERB_ANY, 2, 0, verb_lock_pe },
+ { "unlock-pe", VERB_ANY, 1, 0, verb_unlock_simple },
+ { "lock-uki", VERB_ANY, 2, 0, verb_lock_uki },
+ { "unlock-uki", VERB_ANY, 1, 0, verb_unlock_simple },
+ { "lock-machine-id", VERB_ANY, 1, 0, verb_lock_machine_id },
+ { "unlock-machine-id", VERB_ANY, 1, 0, verb_unlock_machine_id },
+ { "lock-file-system", VERB_ANY, 2, 0, verb_lock_file_system },
+ { "unlock-file-system", VERB_ANY, 2, 0, verb_unlock_file_system },
+ { "lock-kernel-cmdline", VERB_ANY, 2, 0, verb_lock_kernel_cmdline },
+ { "unlock-kernel-cmdline", VERB_ANY, 1, 0, verb_unlock_kernel_cmdline },
+ { "lock-kernel-initrd", VERB_ANY, 2, 0, verb_lock_kernel_initrd },
+ { "unlock-kernel-initrd", VERB_ANY, 1, 0, verb_unlock_kernel_initrd },
+ { "lock-raw", VERB_ANY, 2, 0, verb_lock_raw },
+ { "unlock-raw", VERB_ANY, 1, 0, verb_unlock_simple },
+ { "make-policy", VERB_ANY, 1, 0, verb_make_policy },
+ { "remove-policy", VERB_ANY, 1, 0, verb_remove_policy },
+ {}
+ };
+
+ return dispatch_verb(argc, argv, verbs, NULL);
+}
+
+static int run(int argc, char *argv[]) {
+ int r;
+
+ log_show_color(true);
+ log_parse_environment();
+ log_open();
+
+ r = parse_argv(argc, argv);
+ if (r <= 0)
+ return r;
+
+ return pcrlock_main(argc, argv);
+}
+
+DEFINE_MAIN_FUNCTION(run);
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-26 09:30:41 +0000