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 2001–3000 of 5,877

                        if (!EVENT_LOG_RECORD_IS_PCR(rec))
                                continue;
 
                        if (rec->pcr != pcr)
                                continue;
 
                        if (rec->n_mapped == 0) {
                                log_info("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 ownership 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) {
 
                if (!EVENT_LOG_RECORD_IS_PCR(*rr))
                        continue;
 
                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;
 
                assert(c->n_variants > 0);
 
                FOREACH_ARRAY(ii, c->variants, c->n_variants) {
                        EventLogComponentVariant *i = *ii;
 
                        if (i->n_records == 0) {
                                /* The empty variant always matches */
                                n_empty++;
                                continue;
                        }
 
                        el->has_component_pcrs |= event_log_component_variant_pcrs(*ii);
 
                        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) {
                        bool skip = true;
 
                        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 if (arg_location_end && strcmp(c->id, arg_location_end) > 0) {
                                log_info("Didn't find component '%s' in event log, but irrelevant for location window, ignoring.", c->id);
                        } else {
                                log_info("Couldn't find component '%s' in event log.", c->id);
                                el->n_missing_components++;
                                el->missing_component_pcrs |= event_log_component_pcrs(c);
 
                                skip = false;
                        }
 
                        if (skip) {
                                n_skipped++;
 
                                if (!strextend_with_separator(&skipped_ids, ", ", c->id))
                                        return log_oom();
                        }
 
                } 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_info("Skipped %u components (%s).", n_skipped, skipped_ids);
        if (el->n_missing_components > 0)
                log_debug("Unable to recognize %zu components in event log.", el->n_missing_components);
 
        return event_log_validate_fully_recognized(el);
}
 
#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;
}
 
/* red and green colors usually have good/bad meaning. So exclude color ranges that look too red- or
 * greenish. See https://en.wikipedia.org/wiki/Hue */
static double map_pcr_to_hue(uint32_t pcr) {
        double exclude_red_range = 60.0;
        double exclude_green_range = 60.0;
        double h = (360.0 - exclude_red_range - exclude_green_range) / (TPM2_PCRS_MAX - 1) * pcr;
        h += exclude_red_range / 2;
        if (h > 120 - exclude_green_range / 2)
                h += exclude_green_range;
        return MIN(h, 360 - exclude_red_range / 2);
}
 
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(map_pcr_to_hue(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 (!sd_json_format_enabled(arg_json_format_flags) &&
                    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, sd_json_variant **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();
 
        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 (sd_json_format_enabled(arg_json_format_flags))
                (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;
 
                if (EVENT_LOG_RECORD_IS_PCR(record) &&
                    arg_pcr_mask != 0 && !FLAGS_SET(arg_pcr_mask, UINT32_C(1) << record->pcr))
                        continue;
 
                if (EVENT_LOG_RECORD_IS_PCR(record))
                        r = table_add_many(table,
                                           TABLE_UINT32, record->pcr,
                                           TABLE_STRING, glyph(GLYPH_FULL_BLOCK),
                                           TABLE_SET_COLOR, color_for_pcr(el, record->pcr),
                                           TABLE_STRING, tpm2_pcr_index_to_string(record->pcr));
                else if EVENT_LOG_RECORD_IS_NV_INDEX(record)
                        r = table_add_many(table,
                                           TABLE_UINT32_HEX_0x, record->nv_index,
                                           TABLE_EMPTY,
                                           TABLE_EMPTY);
                else
                        assert_not_reached();
                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();
 
                                if (!sd_json_format_enabled(arg_json_format_flags))
                                        strshorten(hex, arg_abbreviate_hash);
 
                                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 r;
 
        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, sd_json_variant **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();
 
        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 (sd_json_format_enabled(arg_json_format_flags))
                (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++) {
                if (arg_pcr_mask != 0 && !FLAGS_SET(arg_pcr_mask, UINT32_C(1) << pcr))
                        continue;
 
                /* 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;
 
                bool seen = el->registers[pcr].n_measurements > 0;
 
                /* Whether any unmatched components touch this PCR */
                bool missing_components = BIT_SET(el->missing_component_pcrs, pcr);
                bool has_components = BIT_SET(el->has_component_pcrs, pcr);
 
                const char *emoji = "";
                if (seen || has_components) {
                        if (!hash_match)
                                emoji = glyph(GLYPH_DEPRESSED_SMILEY);
                        else if (!fully_recognized)
                                emoji = glyph(GLYPH_UNHAPPY_SMILEY);
                        else if (!missing_components)
                                emoji = glyph(GLYPH_HAPPY_SMILEY);
                        else
                                emoji = glyph(GLYPH_SLIGHTLY_HAPPY_SMILEY);
                }
 
                r = table_add_many(table,
                                   TABLE_UINT32, pcr,
                                   TABLE_STRING, glyph(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);
 
                if (sd_json_format_enabled(arg_json_format_flags))
                        r = table_add_many(table,
                                           TABLE_BOOLEAN_CHECKMARK, hash_match,
                                           TABLE_BOOLEAN_CHECKMARK, fully_recognized,
                                           TABLE_BOOLEAN_CHECKMARK, !missing_components);
                else
                        r = table_add_many(table,
                                           TABLE_STRING, seen ? glyph_check_mark(hash_match) : " ",
                                           TABLE_SET_COLOR, ansi_highlight_green_red(hash_match),
                                           TABLE_STRING, seen ? glyph_check_mark(fully_recognized) : " ",
                                           TABLE_SET_COLOR, ansi_highlight_green_red(fully_recognized),
                                           TABLE_STRING, has_components ? glyph_check_mark(!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();
 
                                if (!sd_json_format_enabled(arg_json_format_flags))
                                        strshorten(hex, arg_abbreviate_hash);
 
                                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();
 
                        if (!sd_json_format_enabled(arg_json_format_flags))
                                strshorten(hex, arg_abbreviate_hash);
 
                        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 r;
 
        if (!sd_json_format_enabled(arg_json_format_flags))
                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 → Component exists and found in event log%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 */
 
                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;
 
        assert(ret);
 
        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;
 
        r = event_determine_primary_algorithm(el);
        if (r < 0)
                return r;
 
        r = event_log_load_components(el);
        if (r < 0)
                return r;
 
        event_log_unload_empty_components(el);
 
        r = event_log_map_components(el);
        if (r < 0)
                return r;
 
        *ret = TAKE_PTR(el);
        return 0;
}
 
VERB_DEFAULT_NOARG(verb_show_log, "log",
     "Show measurement log");
static int verb_show_log(int argc, char *argv[], uintptr_t _data, void *userdata) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *log_table = NULL, *pcr_table = NULL;
        _cleanup_(event_log_freep) EventLog *el = NULL;
        bool want_json = sd_json_format_enabled(arg_json_format_flags);
        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_(sd_json_variant_unrefp) sd_json_variant *object = NULL;
 
                r = sd_json_buildo(
                                &object,
                                SD_JSON_BUILD_PAIR_VARIANT("log", log_table),
                                SD_JSON_BUILD_PAIR_VARIANT("pcrs", pcr_table));
                if (r < 0)
                        return log_error_errno(r, "Failed to generate combined object: %m");
 
                r = sd_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 event_log_record_to_cel(EventLogRecord *record, uint64_t *recnum, sd_json_variant **ret) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *ja = NULL, *fj = NULL;
        sd_json_variant *cd = NULL;
        const char *ct = NULL;
        int r;
 
        assert(record);
        assert(recnum);
        assert(ret);
 
        LIST_FOREACH(banks, bank, record->banks) {
                r = sd_json_variant_append_arraybo(
                                &ja,
                                SD_JSON_BUILD_PAIR_STRING("hashAlg", tpm2_hash_alg_to_string(bank->algorithm)),
                                SD_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 = sd_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 = sd_json_buildo(
                                &fj,
                                SD_JSON_BUILD_PAIR_STRING("event_type", et),
                                SD_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 = sd_json_buildo(
                        ret,
                        SD_JSON_BUILD_PAIR_CONDITION(EVENT_LOG_RECORD_IS_PCR(record), "pcr", SD_JSON_BUILD_UNSIGNED(record->pcr)),
                        SD_JSON_BUILD_PAIR_CONDITION(EVENT_LOG_RECORD_IS_NV_INDEX(record), "nv_index", SD_JSON_BUILD_UNSIGNED(record->nv_index)),
                        SD_JSON_BUILD_PAIR_UNSIGNED("recnum", ++(*recnum)),
                        SD_JSON_BUILD_PAIR_VARIANT("digests", ja),
                        SD_JSON_BUILD_PAIR_CONDITION(!!ct, "content_type", SD_JSON_BUILD_STRING(ct)),
                        SD_JSON_BUILD_PAIR_CONDITION(!!cd, "content", SD_JSON_BUILD_VARIANT(cd)));
        if (r < 0)
                return log_error_errno(r, "Failed to make CEL record: %m");
 
        return 0;
}
 
VERB_NOARG(verb_show_cel, "cel",
           "Show measurement log in TCG CEL-JSON format");
static int verb_show_cel(int argc, char *argv[], uintptr_t _data, void *userdata) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *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, /* keep_fw_no_action= */ true);
        if (r < 0)
                return r;
 
        /* Output the event log in TCG CEL-JSON. */
 
        FOREACH_ARRAY(rr, el->records, el->n_records) {
                _cleanup_(sd_json_variant_unrefp) sd_json_variant *cel = NULL;
 
                r = event_log_record_to_cel(*rr, &recnum, &cel);
                if (r < 0)
                        return r;
 
                r = sd_json_variant_append_array(&array, cel);
                if (r < 0)
                        return log_error_errno(r, "Failed to append CEL record: %m");
        }
 
        if (arg_json_format_flags & (SD_JSON_FORMAT_PRETTY|SD_JSON_FORMAT_PRETTY_AUTO))
                pager_open(arg_pager_flags);
 
        sd_json_variant_dump(array, arg_json_format_flags|SD_JSON_FORMAT_EMPTY_ARRAY, stdout, NULL);
        return 0;
}
 
static int event_log_load_and_process_components(EventLog **ret) {
        _cleanup_(event_log_freep) EventLog *el = NULL;
        int r;
 
        assert(ret);
 
        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;
 
        *ret = TAKE_PTR(el);
        return 0;
}
 
VERB_NOARG(verb_list_components, "list-components",
           "List defined .pcrlock components");
static int verb_list_components(int argc, char *argv[], uintptr_t _data, 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;
 
        r = event_log_load_and_process_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 (arg_pcr_mask != 0 && (arg_pcr_mask & event_log_component_pcrs(*c)) == 0)
                        continue;
 
                if (!sd_json_format_enabled(arg_json_format_flags)) {
                        _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(glyph(GLYPH_ARROW_RIGHT), " location '", arg_location_end, "' ", glyph(GLYPH_ARROW_LEFT));
                                } else if (arg_location_start && strcmp((*c)->id, arg_location_start) >= 0) {
                                        loc = BETWEEN_LOCATION;
                                        marker = strjoin(glyph(GLYPH_TREE_TOP), " start location '", arg_location_start, "' ", glyph(GLYPH_ARROW_DOWN));
                                }
 
                                break;
 
                        case BETWEEN_LOCATION:
                                if (arg_location_end && strcmp((*c)->id, arg_location_end) >= 0) {
                                        loc = AFTER_LOCATION;
                                        marker = strjoin(glyph(GLYPH_TREE_RIGHT), " end location '", arg_location_end, "' ", glyph(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_isempty(table) || sd_json_format_enabled(arg_json_format_flags)) {
                r = table_print_with_pager(table, arg_json_format_flags, arg_pager_flags, /* show_header= */ true);
                if (r < 0)
                        return r;
        }
 
        if (!sd_json_format_enabled(arg_json_format_flags)) {
                if (table_isempty(table))
                        printf("No components defined.\n");
                else
                        printf("\n%zu components listed.\n", table_get_rows(table) - 1);
        }
 
        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 (!BIT_SET(mask, 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,
                sd_json_variant **ret_record) {
 
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *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 = sym_EVP_get_digestbyname(a));
                hash_ssize = sym_EVP_MD_get_size(md);
                assert(hash_ssize > 0);
                hash_usize = hash_ssize;
 
                hash = malloc(hash_usize);
                if (!hash)
                        return log_oom();
 
                if (sym_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 = sd_json_variant_append_arraybo(
                                &digests,
                                SD_JSON_BUILD_PAIR_STRING("hashAlg", a),
                                SD_JSON_BUILD_PAIR("digest", SD_JSON_BUILD_HEX(hash, hash_usize)));
                if (r < 0)
                        return log_error_errno(r, "Failed to build JSON digest object: %m");
        }
 
        r = sd_json_buildo(ret_record,
                           SD_JSON_BUILD_PAIR_UNSIGNED("pcr", pcr),
                           SD_JSON_BUILD_PAIR_VARIANT("digests", digests));
        if (r < 0)
                return log_error_errno(r, "Failed to build record object: %m");
 
        return 0;
}
 
static void evp_md_ctx_free_all(EVP_MD_CTX *(*md)[TPM2_N_HASH_ALGORITHMS]) {
        assert(md);
        FOREACH_ARRAY(alg, *md, TPM2_N_HASH_ALGORITHMS)
                if (*alg)
                        sym_EVP_MD_CTX_free(*alg);
}
 
static int make_pcrlock_record_from_stream(
                uint32_t pcr_mask,
                FILE *f,
                sd_json_variant **ret_records) {
 
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *digests = NULL;
        _cleanup_(evp_md_ctx_free_all) EVP_MD_CTX *mdctx[TPM2_N_HASH_ALGORITHMS] = {};