HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/pcrlock/pcrlock.c
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] = {};