dm: Add verity helpers for LoadPin

LoadPin limits loading of kernel modules, firmware and certain
other files to a 'pinned' file system (typically a read-only
rootfs). To provide more flexibility LoadPin is being extended
to also allow loading these files from trusted dm-verity
devices. For that purpose LoadPin can be provided with a list
of verity root digests that it should consider as trusted.

Add a bunch of helpers to allow LoadPin to check whether a DM
device is a trusted verity device. The new functions broadly
fall in two categories: those that need access to verity
internals (like the root digest), and the 'glue' between
LoadPin and verity. The new file dm-verity-loadpin.c contains
the glue functions.

Signed-off-by: Matthias Kaehlcke <mka@chromium.org>
Acked-by: Mike Snitzer <snitzer@kernel.org>
Link: https://lore.kernel.org/lkml/20220627083512.v7.1.I3e928575a23481121e73286874c4c2bdb403355d@changeid
Signed-off-by: Kees Cook <keescook@chromium.org>

diff --git a/drivers/md/Makefile b/drivers/md/Makefile
index 0454b08..7177190 100644 (file)
--- a/drivers/md/Makefile
+++ b/drivers/md/Makefile
@@ -108,6 +108,12 @@ ifeq ($(CONFIG_DM_VERITY_VERIFY_ROOTHASH_SIG),y)
 dm-verity-objs                 += dm-verity-verify-sig.o
 endif
 
+ifeq ($(CONFIG_DM_VERITY),y)
+ifeq ($(CONFIG_SECURITY_LOADPIN),y)
+dm-verity-objs                 += dm-verity-loadpin.o
+endif
+endif
+
 ifeq ($(CONFIG_DM_AUDIT),y)
 dm-mod-objs                    += dm-audit.o
 endif

diff --git a/drivers/md/dm-verity-loadpin.c b/drivers/md/dm-verity-loadpin.c
new file mode 100644 (file)
index 0000000..10c18bc
--- /dev/null
+++ b/drivers/md/dm-verity-loadpin.c
@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: GPL-2.0-only
+
+#include <linux/list.h>
+#include <linux/kernel.h>
+#include <linux/dm-verity-loadpin.h>
+
+#include "dm.h"
+#include "dm-verity.h"
+
+#define DM_MSG_PREFIX  "verity-loadpin"
+
+LIST_HEAD(dm_verity_loadpin_trusted_root_digests);
+
+static bool is_trusted_verity_target(struct dm_target *ti)
+{
+       u8 *root_digest;
+       unsigned int digest_size;
+       struct dm_verity_loadpin_trusted_root_digest *trd;
+       bool trusted = false;
+
+       if (!dm_is_verity_target(ti))
+               return false;
+
+       if (dm_verity_get_root_digest(ti, &root_digest, &digest_size))
+               return false;
+
+       list_for_each_entry(trd, &dm_verity_loadpin_trusted_root_digests, node) {
+               if ((trd->len == digest_size) &&
+                   !memcmp(trd->data, root_digest, digest_size)) {
+                       trusted = true;
+                       break;
+               }
+       }
+
+       kfree(root_digest);
+
+       return trusted;
+}
+
+/*
+ * Determines whether the file system of a superblock is located on
+ * a verity device that is trusted by LoadPin.
+ */
+bool dm_verity_loadpin_is_bdev_trusted(struct block_device *bdev)
+{
+       struct mapped_device *md;
+       struct dm_table *table;
+       struct dm_target *ti;
+       int srcu_idx;
+       bool trusted = false;
+
+       if (list_empty(&dm_verity_loadpin_trusted_root_digests))
+               return false;
+
+       md = dm_get_md(bdev->bd_dev);
+       if (!md)
+               return false;
+
+       table = dm_get_live_table(md, &srcu_idx);
+
+       if (dm_table_get_num_targets(table) != 1)
+               goto out;
+
+       ti = dm_table_get_target(table, 0);
+
+       if (is_trusted_verity_target(ti))
+               trusted = true;
+
+out:
+       dm_put_live_table(md, srcu_idx);
+       dm_put(md);
+
+       return trusted;
+}

diff --git a/drivers/md/dm-verity-target.c b/drivers/md/dm-verity-target.c
index d6dbd47..e5a01e2 100644 (file)
--- a/drivers/md/dm-verity-target.c
+++ b/drivers/md/dm-verity-target.c
@@ -19,6 +19,7 @@
 #include <linux/module.h>
 #include <linux/reboot.h>
 #include <linux/scatterlist.h>
+#include <linux/string.h>
 
 #define DM_MSG_PREFIX                  "verity"
 
@@ -1310,10 +1311,40 @@ bad:
        return r;
 }
 
+/*
+ * Check whether a DM target is a verity target.
+ */
+bool dm_is_verity_target(struct dm_target *ti)
+{
+       return ti->type->module == THIS_MODULE;
+}
+
+/*
+ * Get the root digest of a verity target.
+ *
+ * Returns a copy of the root digest, the caller is responsible for
+ * freeing the memory of the digest.
+ */
+int dm_verity_get_root_digest(struct dm_target *ti, u8 **root_digest, unsigned int *digest_size)
+{
+       struct dm_verity *v = ti->private;
+
+       if (!dm_is_verity_target(ti))
+               return -EINVAL;
+
+       *root_digest = kmemdup(v->root_digest, v->digest_size, GFP_KERNEL);
+       if (*root_digest == NULL)
+               return -ENOMEM;
+
+       *digest_size = v->digest_size;
+
+       return 0;
+}
+
 static struct target_type verity_target = {
        .name           = "verity",
        .features       = DM_TARGET_IMMUTABLE,
-       .version        = {1, 8, 0},
+       .version        = {1, 8, 1},
        .module         = THIS_MODULE,
        .ctr            = verity_ctr,
        .dtr            = verity_dtr,

diff --git a/drivers/md/dm-verity.h b/drivers/md/dm-verity.h
index 4e769d1..c832cc3 100644 (file)
--- a/drivers/md/dm-verity.h
+++ b/drivers/md/dm-verity.h
@@ -129,4 +129,8 @@ extern int verity_hash(struct dm_verity *v, struct ahash_request *req,
 extern int verity_hash_for_block(struct dm_verity *v, struct dm_verity_io *io,
                                 sector_t block, u8 *digest, bool *is_zero);
 
+extern bool dm_is_verity_target(struct dm_target *ti);
+extern int dm_verity_get_root_digest(struct dm_target *ti, u8 **root_digest,
+                                    unsigned int *digest_size);
+
 #endif /* DM_VERITY_H */

diff --git a/include/linux/dm-verity-loadpin.h b/include/linux/dm-verity-loadpin.h
new file mode 100644 (file)
index 0000000..fb695ec
--- /dev/null
+++ b/include/linux/dm-verity-loadpin.h
@@ -0,0 +1,27 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+
+#ifndef __LINUX_DM_VERITY_LOADPIN_H
+#define __LINUX_DM_VERITY_LOADPIN_H
+
+#include <linux/list.h>
+
+struct block_device;
+
+extern struct list_head dm_verity_loadpin_trusted_root_digests;
+
+struct dm_verity_loadpin_trusted_root_digest {
+       struct list_head node;
+       unsigned int len;
+       u8 data[];
+};
+
+#if IS_ENABLED(CONFIG_SECURITY_LOADPIN) && IS_BUILTIN(CONFIG_DM_VERITY)
+bool dm_verity_loadpin_is_bdev_trusted(struct block_device *bdev);
+#else
+static inline bool dm_verity_loadpin_is_bdev_trusted(struct block_device *bdev)
+{
+       return false;
+}
+#endif
+
+#endif /* __LINUX_DM_VERITY_LOADPIN_H */