]> git.proxmox.com Git - mirror_ubuntu-zesty-kernel.git/commitdiff
UBUNTU: SAUCE: UEFI: MODSIGN: Import certificates from UEFI Secure Boot
authorJosh Boyer <jwboyer@fedoraproject.org>
Fri, 26 Oct 2012 16:42:16 +0000 (12:42 -0400)
committerTim Gardner <tim.gardner@canonical.com>
Mon, 20 Feb 2017 03:57:58 +0000 (20:57 -0700)
Secure Boot stores a list of allowed certificates in the 'db' variable.
This imports those certificates into the system trusted keyring.  This
allows for a third party signing certificate to be used in conjunction
with signed modules.  By importing the public certificate into the 'db'
variable, a user can allow a module signed with that certificate to
load.  The shim UEFI bootloader has a similar certificate list stored
in the 'MokListRT' variable.  We import those as well.

In the opposite case, Secure Boot maintains a list of disallowed
certificates in the 'dbx' variable.  We load those certificates into
the newly introduced system blacklist keyring and forbid any module
signed with those from loading.

Signed-off-by: Josh Boyer <jwboyer@fedoraproject.org>
Signed-off-by: Tim Gardner <tim.gardner@canonical.com>
certs/system_keyring.c
include/keys/system_keyring.h
include/linux/efi.h
init/Kconfig
kernel/Makefile
kernel/modsign_uefi.c [new file with mode: 0644]

index a7279e78072ccf180fdf8ba72458563212fab102..e1b81d47fa737b46b2bf4e5d2859eb4e41f8b752 100644 (file)
@@ -26,6 +26,19 @@ static struct key *secondary_trusted_keys;
 extern __initconst const u8 system_certificate_list[];
 extern __initconst const unsigned long system_certificate_list_size;
 
+/**
+ * get_system_keyring - Return a pointer to the system keyring
+ *
+ */
+struct key *get_system_keyring(void)
+{
+       struct key *system_keyring = NULL;
+
+       system_keyring = builtin_trusted_keys;
+       return system_keyring;
+}
+EXPORT_SYMBOL_GPL(get_system_keyring);
+
 /**
  * restrict_link_to_builtin_trusted - Restrict keyring addition by built in CA
  *
index fbd4647767e9162f10c5741825796c5c2061cef0..4009f3c018b5f6f85518202c0db72ee2eeaf400f 100644 (file)
@@ -32,6 +32,7 @@ extern int restrict_link_by_builtin_and_secondary_trusted(
 #else
 #define restrict_link_by_builtin_and_secondary_trusted restrict_link_by_builtin_trusted
 #endif
+extern struct key *get_system_keyring(void);
 
 #ifdef CONFIG_IMA_BLACKLIST_KEYRING
 extern struct key *ima_blacklist_keyring;
index 73bbe8da89d01f85001c09852549ea7199bdba6c..8405d29889133a6386185a9d00a347cf9bff4398 100644 (file)
@@ -631,6 +631,12 @@ typedef struct {
        u64 table;
 } efi_config_table_64_t;
 
+#define EFI_IMAGE_SECURITY_DATABASE_GUID \
+    EFI_GUID(  0xd719b2cb, 0x3d3a, 0x4596, 0xa3, 0xbc, 0xda, 0xd0, 0x0e, 0x67, 0x65, 0x6f )
+
+#define EFI_SHIM_LOCK_GUID \
+    EFI_GUID(  0x605dab50, 0xe046, 0x4300, 0xab, 0xb6, 0x3d, 0xd8, 0x10, 0xdd, 0x8b, 0x23 )
+
 typedef struct {
        efi_guid_t guid;
        u32 table;
index ab2da65e79f8ac12af95fdf6137f00b3199d576a..0f257260fcc1ad8c1f28f2f54de4d2ded3de1ba0 100644 (file)
@@ -2047,6 +2047,15 @@ config MODULE_SIG_ALL
 comment "Do not forget to sign required modules with scripts/sign-file"
        depends on MODULE_SIG_FORCE && !MODULE_SIG_ALL
 
+config MODULE_SIG_UEFI
+       bool "Allow modules signed with certs stored in UEFI"
+       depends on MODULE_SIG && SYSTEM_BLACKLIST_KEYRING && EFI
+       select EFI_SIGNATURE_LIST_PARSER
+       help
+         This will import certificates stored in UEFI and allow modules
+         signed with those to be loaded.  It will also disallow loading
+         of modules stored in the UEFI dbx variable.
+
 choice
        prompt "Which hash algorithm should modules be signed with?"
        depends on MODULE_SIG
index 12c679f769c6f82af6d65caf8f06d2707f86fb3f..187ed40560258e5920630aec9e91d834dbd6e2e9 100644 (file)
@@ -57,6 +57,7 @@ endif
 obj-$(CONFIG_UID16) += uid16.o
 obj-$(CONFIG_MODULES) += module.o
 obj-$(CONFIG_MODULE_SIG) += module_signing.o
+obj-$(CONFIG_MODULE_SIG_UEFI) += modsign_uefi.o
 obj-$(CONFIG_KALLSYMS) += kallsyms.o
 obj-$(CONFIG_BSD_PROCESS_ACCT) += acct.o
 obj-$(CONFIG_KEXEC_CORE) += kexec_core.o
@@ -114,6 +115,8 @@ obj-$(CONFIG_MEMBARRIER) += membarrier.o
 
 obj-$(CONFIG_HAS_IOMEM) += memremap.o
 
+$(obj)/modsign_uefi.o: KBUILD_CFLAGS += -fshort-wchar
+
 $(obj)/configs.o: $(obj)/config_data.h
 
 targets += config_data.gz
diff --git a/kernel/modsign_uefi.c b/kernel/modsign_uefi.c
new file mode 100644 (file)
index 0000000..fe4a6f2
--- /dev/null
@@ -0,0 +1,99 @@
+#include <linux/kernel.h>
+#include <linux/sched.h>
+#include <linux/cred.h>
+#include <linux/err.h>
+#include <linux/efi.h>
+#include <linux/slab.h>
+#include <keys/asymmetric-type.h>
+#include <keys/system_keyring.h>
+#include "module-internal.h"
+
+static __init void *get_cert_list(efi_char16_t *name, efi_guid_t *guid, unsigned long *size)
+{
+       efi_status_t status;
+       unsigned long lsize = 4;
+       unsigned long tmpdb[4];
+       void *db = NULL;
+
+       status = efi.get_variable(name, guid, NULL, &lsize, &tmpdb);
+       if (status != EFI_BUFFER_TOO_SMALL) {
+               pr_err("Couldn't get size: 0x%lx\n", status);
+               return NULL;
+       }
+
+       db = kmalloc(lsize, GFP_KERNEL);
+       if (!db) {
+               pr_err("Couldn't allocate memory for uefi cert list\n");
+               goto out;
+       }
+
+       status = efi.get_variable(name, guid, NULL, &lsize, db);
+       if (status != EFI_SUCCESS) {
+               kfree(db);
+               db = NULL;
+               pr_err("Error reading db var: 0x%lx\n", status);
+       }
+out:
+       *size = lsize;
+       return db;
+}
+
+/*
+ *  * Load the certs contained in the UEFI databases
+ *   */
+static int __init load_uefi_certs(void)
+{
+       efi_guid_t secure_var = EFI_IMAGE_SECURITY_DATABASE_GUID;
+       efi_guid_t mok_var = EFI_SHIM_LOCK_GUID;
+       void *db = NULL, *dbx = NULL, *mok = NULL;
+       unsigned long dbsize = 0, dbxsize = 0, moksize = 0;
+       int rc = 0;
+       struct key *keyring = NULL;
+
+       /* Check if SB is enabled and just return if not */
+       if (!efi_enabled(EFI_SECURE_BOOT))
+               return 0;
+
+       keyring = get_system_keyring();
+       if (!keyring) {
+               pr_err("MODSIGN: Couldn't get system keyring\n");
+               return -EINVAL;
+       }
+
+       /* Get db, MokListRT, and dbx.  They might not exist, so it isn't
+        * an error if we can't get them.
+        */
+       db = get_cert_list(L"db", &secure_var, &dbsize);
+       if (!db) {
+               pr_err("MODSIGN: Couldn't get UEFI db list\n");
+       } else {
+               rc = parse_efi_signature_list(db, dbsize, keyring);
+               if (rc)
+                       pr_err("Couldn't parse db signatures: %d\n", rc);
+               kfree(db);
+       }
+
+       mok = get_cert_list(L"MokListRT", &mok_var, &moksize);
+       if (!mok) {
+               pr_info("MODSIGN: Couldn't get UEFI MokListRT\n");
+       } else {
+               rc = parse_efi_signature_list(mok, moksize, keyring);
+               if (rc)
+                       pr_err("Couldn't parse MokListRT signatures: %d\n", rc);
+               kfree(mok);
+       }
+
+       dbx = get_cert_list(L"dbx", &secure_var, &dbxsize);
+       if (!dbx) {
+               pr_info("MODSIGN: Couldn't get UEFI dbx list\n");
+       } else {
+               rc = parse_efi_signature_list(dbx, dbxsize,
+                       system_blacklist_keyring);
+               if (rc)
+                       pr_err("Couldn't parse dbx signatures: %d\n", rc);
+               kfree(dbx);
+       }
+
+       return rc;
+}
+late_initcall(load_uefi_certs);