mm/slab: Introduce kmem_buckets_create() and family

Dedicated caches are available for fixed size allocations via
kmem_cache_alloc(), but for dynamically sized allocations there is only
the global kmalloc API's set of buckets available. This means it isn't
possible to separate specific sets of dynamically sized allocations into
a separate collection of caches.

This leads to a use-after-free exploitation weakness in the Linux
kernel since many heap memory spraying/grooming attacks depend on using
userspace-controllable dynamically sized allocations to collide with
fixed size allocations that end up in same cache.

While CONFIG_RANDOM_KMALLOC_CACHES provides a probabilistic defense
against these kinds of "type confusion" attacks, including for fixed
same-size heap objects, we can create a complementary deterministic
defense for dynamically sized allocations that are directly user
controlled. Addressing these cases is limited in scope, so isolating these
kinds of interfaces will not become an unbounded game of whack-a-mole. For
example, many pass through memdup_user(), making isolation there very
effective.

In order to isolate user-controllable dynamically-sized
allocations from the common system kmalloc allocations, introduce
kmem_buckets_create(), which behaves like kmem_cache_create(). Introduce
kmem_buckets_alloc(), which behaves like kmem_cache_alloc(). Introduce
kmem_buckets_alloc_track_caller() for where caller tracking is
needed. Introduce kmem_buckets_valloc() for cases where vmalloc fallback
is needed. Note that these caches are specifically flagged with
SLAB_NO_MERGE, since merging would defeat the entire purpose of the
mitigation.

This can also be used in the future to extend allocation profiling's use
of code tagging to implement per-caller allocation cache isolation[1]
even for dynamic allocations.

Memory allocation pinning[2] is still needed to plug the Use-After-Free
cross-allocator weakness (where attackers can arrange to free an
entire slab page and have it reallocated to a different cache),
but that is an existing and separate issue which is complementary
to this improvement. Development continues for that feature via the
SLAB_VIRTUAL[3] series (which could also provide guard pages -- another
complementary improvement).

Link: https://lore.kernel.org/lkml/202402211449.401382D2AF@keescook
Link: https://googleprojectzero.blogspot.com/2021/10/how-simple-linux-kernel-memory.html
Link: https://lore.kernel.org/lkml/20230915105933.495735-1-matteorizzo@google.com/
Signed-off-by: Kees Cook <kees@kernel.org>
Signed-off-by: Vlastimil Babka <vbabka@suse.cz>

diff --git a/include/linux/slab.h b/include/linux/slab.h
index 837005314f96aa3d8e76c40119686d738f2aaada..d99afce3609835eab0366e07c2562e62cfb48555 100644 (file)
--- a/include/linux/slab.h
+++ b/include/linux/slab.h
@@ -549,6 +549,10 @@ void *kmem_cache_alloc_lru_noprof(struct kmem_cache *s, struct list_lru *lru,
 
 void kmem_cache_free(struct kmem_cache *s, void *objp);
 
+kmem_buckets *kmem_buckets_create(const char *name, slab_flags_t flags,
+                                 unsigned int useroffset, unsigned int usersize,
+                                 void (*ctor)(void *));
+
 /*
  * Bulk allocation and freeing operations. These are accelerated in an
  * allocator specific way to avoid taking locks repeatedly or building
@@ -682,6 +686,12 @@ static __always_inline __alloc_size(1) void *kmalloc_noprof(size_t size, gfp_t f
 }
 #define kmalloc(...)                           alloc_hooks(kmalloc_noprof(__VA_ARGS__))
 
+#define kmem_buckets_alloc(_b, _size, _flags)  \
+       alloc_hooks(__kmalloc_node_noprof(PASS_BUCKET_PARAMS(_size, _b), _flags, NUMA_NO_NODE))
+
+#define kmem_buckets_alloc_track_caller(_b, _size, _flags)     \
+       alloc_hooks(__kmalloc_node_track_caller_noprof(PASS_BUCKET_PARAMS(_size, _b), _flags, NUMA_NO_NODE, _RET_IP_))
+
 static __always_inline __alloc_size(1) void *kmalloc_node_noprof(size_t size, gfp_t flags, int node)
 {
        if (__builtin_constant_p(size) && size) {
@@ -809,6 +819,8 @@ void *__kvmalloc_node_noprof(DECL_BUCKET_PARAMS(size, b), gfp_t flags, int node)
 #define kvzalloc(_size, _flags)                        kvmalloc(_size, (_flags)|__GFP_ZERO)
 
 #define kvzalloc_node(_size, _flags, _node)    kvmalloc_node(_size, (_flags)|__GFP_ZERO, _node)
+#define kmem_buckets_valloc(_b, _size, _flags) \
+       alloc_hooks(__kvmalloc_node_noprof(PASS_BUCKET_PARAMS(_size, _b), _flags, NUMA_NO_NODE))
 
 static inline __alloc_size(1, 2) void *
 kvmalloc_array_node_noprof(size_t n, size_t size, gfp_t flags, int node)

diff --git a/mm/slab_common.c b/mm/slab_common.c
index bcc1e13d7f86964025e6493ab5abdbe284f4653d..70943a4c1c4b50be4366ab7277626937b43a82f9 100644 (file)
--- a/mm/slab_common.c
+++ b/mm/slab_common.c
@@ -392,6 +392,98 @@ kmem_cache_create(const char *name, unsigned int size, unsigned int align,
 }
 EXPORT_SYMBOL(kmem_cache_create);
 
+static struct kmem_cache *kmem_buckets_cache __ro_after_init;
+
+/**
+ * kmem_buckets_create - Create a set of caches that handle dynamic sized
+ *                      allocations via kmem_buckets_alloc()
+ * @name: A prefix string which is used in /proc/slabinfo to identify this
+ *       cache. The individual caches with have their sizes as the suffix.
+ * @flags: SLAB flags (see kmem_cache_create() for details).
+ * @useroffset: Starting offset within an allocation that may be copied
+ *             to/from userspace.
+ * @usersize: How many bytes, starting at @useroffset, may be copied
+ *             to/from userspace.
+ * @ctor: A constructor for the objects, run when new allocations are made.
+ *
+ * Cannot be called within an interrupt, but can be interrupted.
+ *
+ * Return: a pointer to the cache on success, NULL on failure. When
+ * CONFIG_SLAB_BUCKETS is not enabled, ZERO_SIZE_PTR is returned, and
+ * subsequent calls to kmem_buckets_alloc() will fall back to kmalloc().
+ * (i.e. callers only need to check for NULL on failure.)
+ */
+kmem_buckets *kmem_buckets_create(const char *name, slab_flags_t flags,
+                                 unsigned int useroffset,
+                                 unsigned int usersize,
+                                 void (*ctor)(void *))
+{
+       kmem_buckets *b;
+       int idx;
+
+       /*
+        * When the separate buckets API is not built in, just return
+        * a non-NULL value for the kmem_buckets pointer, which will be
+        * unused when performing allocations.
+        */
+       if (!IS_ENABLED(CONFIG_SLAB_BUCKETS))
+               return ZERO_SIZE_PTR;
+
+       if (WARN_ON(!kmem_buckets_cache))
+               return NULL;
+
+       b = kmem_cache_alloc(kmem_buckets_cache, GFP_KERNEL|__GFP_ZERO);
+       if (WARN_ON(!b))
+               return NULL;
+
+       flags |= SLAB_NO_MERGE;
+
+       for (idx = 0; idx < ARRAY_SIZE(kmalloc_caches[KMALLOC_NORMAL]); idx++) {
+               char *short_size, *cache_name;
+               unsigned int cache_useroffset, cache_usersize;
+               unsigned int size;
+
+               if (!kmalloc_caches[KMALLOC_NORMAL][idx])
+                       continue;
+
+               size = kmalloc_caches[KMALLOC_NORMAL][idx]->object_size;
+               if (!size)
+                       continue;
+
+               short_size = strchr(kmalloc_caches[KMALLOC_NORMAL][idx]->name, '-');
+               if (WARN_ON(!short_size))
+                       goto fail;
+
+               cache_name = kasprintf(GFP_KERNEL, "%s-%s", name, short_size + 1);
+               if (WARN_ON(!cache_name))
+                       goto fail;
+
+               if (useroffset >= size) {
+                       cache_useroffset = 0;
+                       cache_usersize = 0;
+               } else {
+                       cache_useroffset = useroffset;
+                       cache_usersize = min(size - cache_useroffset, usersize);
+               }
+               (*b)[idx] = kmem_cache_create_usercopy(cache_name, size,
+                                       0, flags, cache_useroffset,
+                                       cache_usersize, ctor);
+               kfree(cache_name);
+               if (WARN_ON(!(*b)[idx]))
+                       goto fail;
+       }
+
+       return b;
+
+fail:
+       for (idx = 0; idx < ARRAY_SIZE(kmalloc_caches[KMALLOC_NORMAL]); idx++)
+               kmem_cache_destroy((*b)[idx]);
+       kfree(b);
+
+       return NULL;
+}
+EXPORT_SYMBOL(kmem_buckets_create);
+
 #ifdef SLAB_SUPPORTS_SYSFS
 /*
  * For a given kmem_cache, kmem_cache_destroy() should only be called
@@ -932,6 +1024,11 @@ void __init create_kmalloc_caches(void)
 
        /* Kmalloc array is now usable */
        slab_state = UP;
+
+       if (IS_ENABLED(CONFIG_SLAB_BUCKETS))
+               kmem_buckets_cache = kmem_cache_create("kmalloc_buckets",
+                                                      sizeof(kmem_buckets),
+                                                      0, SLAB_NO_MERGE, NULL);
 }
 
 /**