HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/pcrlock/pcrlock.c

228,316 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: c798c78489257ecc6f87eead6fa509ad2027c886

Lines 4001–5000 of 5,877

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