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 5001–5877 of 5,877

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