secure-boot: validate booted shim and signature databases

Author: q1sh101

include/efi_boot_parsers.h

@@ -38,16 +38,7 @@ bool bythos_parse_efi_boot_entry(const unsigned char *data, size_t len,
 bool bythos_parse_efi_boot_next(const unsigned char *data, size_t len,
                                     uint16_t *number);
 
-/* Secure Boot signature database (db/dbx) payload classification */
-typedef enum {
-    BYTHOS_EFI_SIGDB_NONEMPTY = 0,
-    BYTHOS_EFI_SIGDB_EMPTY,
-    BYTHOS_EFI_SIGDB_INVALID,
-} bythos_efi_sigdb_status_t;
-
-bythos_efi_sigdb_status_t bythos_classify_efi_sigdb(
-    const unsigned char *data, size_t len);
-
+/* Secure Boot signature database (db/dbx): count of well-formed EFI_SIGNATURE_LISTs */
 size_t bythos_count_efi_sigdb_lists(const unsigned char *data, size_t len);
 
 #endif

src/check_boot_chain.c

@@ -113,34 +113,40 @@ static bool find_efi_binary(const char *const *candidates, size_t candidate_coun
 
 #define EFI_GLOBAL_VAR_GUID "8be4df61-93ca-11d2-aa0d-00e098032b8c"
 
-/* resolve the shim the firmware actually boots via BootCurrent, not a readdir guess */
-static bool find_booted_shim(char *path_out, size_t path_out_size) {
+typedef enum {
+    SHIM_RESOLUTION_FOUND = 0,
+    SHIM_RESOLUTION_FALLBACK_ALLOWED,
+    SHIM_RESOLUTION_BOOTED_NON_SHIM,
+    SHIM_RESOLUTION_BOOTCURRENT_UNRESOLVED,
+} shim_resolution_t;
+
+static shim_resolution_t find_booted_shim(char *path_out, size_t path_out_size) {
     unsigned char cur[8];
     size_t cur_len = 0;
     if (!bythos_read_file_binary(
             "/sys/firmware/efi/efivars/BootCurrent-" EFI_GLOBAL_VAR_GUID,
             cur, sizeof(cur), &cur_len) || cur_len < 6) {
-        return false;
+        return SHIM_RESOLUTION_FALLBACK_ALLOWED;
     }
     unsigned int num = (unsigned int)cur[4] | ((unsigned int)cur[5] << 8);
 
     char var_path[PATH_MAX];
     if (snprintf(var_path, sizeof(var_path),
                  "/sys/firmware/efi/efivars/Boot%04X-" EFI_GLOBAL_VAR_GUID, num)
             >= (int)sizeof(var_path)) {
-        return false;
+        return SHIM_RESOLUTION_BOOTCURRENT_UNRESOLVED;
     }
 
     unsigned char buf[4096];
     size_t buf_len = 0;
     if (!bythos_read_file_binary(var_path, buf, sizeof(buf), &buf_len)) {
-        return false;
+        return SHIM_RESOLUTION_BOOTCURRENT_UNRESOLVED;
     }
 
     bythos_efi_boot_entry_t entry;
     if (!bythos_parse_efi_boot_entry(buf, buf_len, (uint16_t)num, &entry) ||
         entry.filepath[0] == '\0') {
-        return false;
+        return SHIM_RESOLUTION_BOOTCURRENT_UNRESOLVED;
     }
 
     char norm[256];
@@ -155,33 +161,50 @@ static bool find_booted_shim(char *path_out, size_t path_out_size) {
 
     if (strstr(norm_lower, "shimx64.efi") == NULL &&
         strstr(norm_lower, "shimaa64.efi") == NULL) {
-        return false;
+        return SHIM_RESOLUTION_BOOTED_NON_SHIM;
     }
 
     const char *efi = strstr(norm_lower, "/efi/");
     if (efi == NULL) {
-        return false;
+        return SHIM_RESOLUTION_BOOTCURRENT_UNRESOLVED;
     }
     size_t rel_off = (size_t)(efi - norm_lower) + 5;
     if (rel_off >= k) {
-        return false;
+        return SHIM_RESOLUTION_BOOTCURRENT_UNRESOLVED;
     }
 
     if (snprintf(path_out, path_out_size, "%s/%s",
                  bythos_esp_efi_base(), norm + rel_off) >= (int)path_out_size) {
-        return false;
+        return SHIM_RESOLUTION_BOOTCURRENT_UNRESOLVED;
     }
-    return bythos_file_exists(path_out);
+    return bythos_file_exists(path_out) ? SHIM_RESOLUTION_FOUND :
+        SHIM_RESOLUTION_BOOTCURRENT_UNRESOLVED;
 }
 
-static bool find_shim(char *path_out, size_t path_out_size) {
-    if (find_booted_shim(path_out, path_out_size)) {
+static bool find_shim(char *path_out, size_t path_out_size,
+                      shim_resolution_t *resolution_out) {
+    shim_resolution_t resolution = find_booted_shim(path_out, path_out_size);
+    if (resolution == SHIM_RESOLUTION_FOUND) {
+        if (resolution_out != NULL) {
+            *resolution_out = resolution;
+        }
         return true;
     }
+    if (resolution != SHIM_RESOLUTION_FALLBACK_ALLOWED) {
+        if (resolution_out != NULL) {
+            *resolution_out = resolution;
+        }
+        return false;
+    }
     static const char *const candidates[] = {"shimx64.efi", "shimaa64.efi"};
-    return find_efi_binary(candidates,
-                           sizeof(candidates) / sizeof(candidates[0]),
-                           path_out, path_out_size);
+    bool found = find_efi_binary(candidates,
+                                 sizeof(candidates) / sizeof(candidates[0]),
+                                 path_out, path_out_size);
+    if (resolution_out != NULL) {
+        *resolution_out = found ? SHIM_RESOLUTION_FOUND :
+            SHIM_RESOLUTION_FALLBACK_ALLOWED;
+    }
+    return found;
 }
 
 static bool find_grub(char *path_out, size_t path_out_size) {
@@ -198,8 +221,15 @@ static size_t check_shim_signature(check_result_t *results, size_t max_results)
     }
 
     char shim_path[PATH_MAX] = {0};
-    if (!find_shim(shim_path, sizeof(shim_path))) {
-        EMIT_SKIP_SUBJECT("shim signature", "shim");
+    shim_resolution_t shim_resolution = SHIM_RESOLUTION_FALLBACK_ALLOWED;
+    if (!find_shim(shim_path, sizeof(shim_path), &shim_resolution)) {
+        if (shim_resolution == SHIM_RESOLUTION_BOOTED_NON_SHIM) {
+            EMIT_SKIP("shim signature", SKIP_SUBJECT_ABSENT, "booted via non-shim path");
+        } else if (shim_resolution == SHIM_RESOLUTION_BOOTCURRENT_UNRESOLVED) {
+            EMIT_SKIP("shim signature", SKIP_OUTPUT_UNPARSEABLE, "BootCurrent path unresolved");
+        } else {
+            EMIT_SKIP_SUBJECT("shim signature", "shim");
+        }
         return used;
     }
 
@@ -249,7 +279,7 @@ static void scan_initramfs_dir(const char *dir_path, int max_depth,
         }
 
         struct stat st;
-        if (stat(path, &st) != 0) continue;
+        if (lstat(path, &st) != 0) continue;
 
         if (S_ISREG(st.st_mode)) {
             if (strncmp(name, "initrd", 6) != 0 && strncmp(name, "initramfs", 9) != 0) {
@@ -353,7 +383,7 @@ static size_t check_bootloader_sbat(check_result_t *results, size_t max_results)
 
     char shim_path[PATH_MAX] = {0};
     char grub_path[PATH_MAX] = {0};
-    bool have_shim = find_shim(shim_path, sizeof(shim_path));
+    bool have_shim = find_shim(shim_path, sizeof(shim_path), NULL);
     bool have_grub = find_grub(grub_path, sizeof(grub_path));
 
     if (!have_shim && !have_grub) {

src/check_secureboot.c

@@ -46,6 +46,8 @@ static void check_sigdb_variable(const char *path, const char *name,
 
     if (bythos_count_efi_sigdb_lists(buf, len) > 0) {
         results[(*used)++] = make_result(name, CHECK_OK, "visible and non-empty");
+    } else if (len > 4u) {
+        results[(*used)++] = make_result(name, CHECK_WARN, "visible but unparseable");
     } else {
         results[(*used)++] = make_result(name, CHECK_WARN, "visible but empty");
     }
@@ -176,7 +178,11 @@ size_t bythos_check_secureboot(check_result_t *results, size_t max_results) {
         } else {
             size_t lists = bythos_count_efi_sigdb_lists(db_buf, db_len);
             if (lists == 0) {
-                EMIT("Secure Boot db keys", CHECK_WARN, "empty; Secure Boot allowlist missing");
+                if (db_len > 4u) {
+                    EMIT("Secure Boot db keys", CHECK_WARN, "allowlist visible but unparseable");
+                } else {
+                    EMIT("Secure Boot db keys", CHECK_WARN, "empty; Secure Boot allowlist missing");
+                }
             } else {
                 char detail[BYTHOS_DETAIL_MAX];
                 snprintf(detail, sizeof(detail),

src/efi_boot_parsers.c

@@ -279,20 +279,6 @@ bool bythos_parse_efi_boot_next(const unsigned char *data, size_t len,
     return true;
 }
 
-bythos_efi_sigdb_status_t bythos_classify_efi_sigdb(
-    const unsigned char *data, size_t len) {
-    /* db/dbx are EFI attributes followed by the signature-list payload. */
-    if (data == NULL || len < EFI_VAR_ATTR_SIZE) {
-        return BYTHOS_EFI_SIGDB_INVALID;
-    }
-
-    if (len == EFI_VAR_ATTR_SIZE) {
-        return BYTHOS_EFI_SIGDB_EMPTY;
-    }
-
-    return BYTHOS_EFI_SIGDB_NONEMPTY;
-}
-
 size_t bythos_count_efi_sigdb_lists(const unsigned char *data, size_t len) {
     if (data == NULL || len <= EFI_VAR_ATTR_SIZE) {
         return 0;
@@ -302,12 +288,29 @@ size_t bythos_count_efi_sigdb_lists(const unsigned char *data, size_t len) {
     size_t remaining = len - EFI_VAR_ATTR_SIZE;
     size_t count = 0;
 
-    /* Each EFI_SIGNATURE_LIST is at least 28 bytes; advance by SignatureListSize. */
-    while (remaining >= 28) {
-        uint32_t list_size = read_le32(p + 16);
+    while (remaining > 0) {
+        if (remaining < 28) {
+            return 0;
+        }
+
+        size_t list_size = read_le32(p + 16);
+        size_t header_size = read_le32(p + 20);
+        size_t signature_size = read_le32(p + 24);
         if (list_size < 28 || list_size > remaining) {
-            break;
+            return 0;
+        }
+
+        size_t body_size = list_size - 28;
+        if (header_size > body_size) {
+            return 0;
         }
+
+        size_t payload_size = body_size - header_size;
+        if (signature_size <= 16 || payload_size < signature_size ||
+            payload_size % signature_size != 0) {
+            return 0;
+        }
+
         count++;
         p += list_size;
         remaining -= list_size;

tests/efi_boot_parsers.c

@@ -1,3 +1,4 @@
+#include <stdint.h>
 #include <stdio.h>
 #include <string.h>
 
@@ -13,6 +14,13 @@ static void assert_type(const char *name, bythos_efi_boot_type_t got,
     }
 }
 
+static void put_le32(unsigned char *p, uint32_t v) {
+    p[0] = (unsigned char)(v & 0xFF);
+    p[1] = (unsigned char)((v >> 8) & 0xFF);
+    p[2] = (unsigned char)((v >> 16) & 0xFF);
+    p[3] = (unsigned char)((v >> 24) & 0xFF);
+}
+
 /* Minimal Boot#### fixture with a legacy BBS device path. */
 static size_t build_bbs_entry(unsigned char *buf, size_t buf_size,
                               uint32_t load_attrs, const char *desc_ascii,
@@ -359,25 +367,37 @@ int main(void) {
     }
 
     {
-        unsigned char data[] = {
-            0x07, 0x00, 0x00, 0x00,
-            0x30, 0x06,
-            0x00, 0x00, 0x00, 0x00,
-        };
-        assert_true("sigdb_nonempty",
-            bythos_classify_efi_sigdb(data, sizeof(data)) == BYTHOS_EFI_SIGDB_NONEMPTY);
+        unsigned char data[80] = {0x07, 0x00, 0x00, 0x00};
+        size_t off = 4;
+        for (size_t i = 0; i < 16; i++) data[off + i] = (unsigned char)i;
+        put_le32(data + off + 16, 76);
+        put_le32(data + off + 20, 0);
+        put_le32(data + off + 24, 48);
+        assert_eq_sz("sigdb_valid_one_list", bythos_count_efi_sigdb_lists(data, sizeof(data)), 1);
     }
 
     {
-        unsigned char data[] = {0x07, 0x00, 0x00, 0x00};
-        assert_true("sigdb_empty",
-            bythos_classify_efi_sigdb(data, sizeof(data)) == BYTHOS_EFI_SIGDB_EMPTY);
+        unsigned char data[81] = {0x07, 0x00, 0x00, 0x00};
+        size_t off = 4;
+        for (size_t i = 0; i < 16; i++) data[off + i] = (unsigned char)i;
+        put_le32(data + off + 16, 76);
+        put_le32(data + off + 20, 0);
+        put_le32(data + off + 24, 48);
+        assert_eq_sz("sigdb_trailing_junk", bythos_count_efi_sigdb_lists(data, sizeof(data)), 0);
     }
 
     {
-        unsigned char data[] = {0x07, 0x00, 0x00};
-        assert_true("sigdb_short",
-            bythos_classify_efi_sigdb(data, sizeof(data)) == BYTHOS_EFI_SIGDB_INVALID);
+        unsigned char data[32] = {0x07, 0x00, 0x00, 0x00};
+        size_t off = 4;
+        put_le32(data + off + 16, 28);
+        put_le32(data + off + 20, 0);
+        put_le32(data + off + 24, 48);
+        assert_eq_sz("sigdb_zero_entry_list", bythos_count_efi_sigdb_lists(data, sizeof(data)), 0);
+    }
+
+    {
+        unsigned char data[] = {0x07, 0x00, 0x00, 0x00};
+        assert_eq_sz("sigdb_empty", bythos_count_efi_sigdb_lists(data, sizeof(data)), 0);
     }
 
     printf("efi boot parser: all tests passed\n");