From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: ARC-Seal: i=1; a=rsa-sha256; t=1526488130; cv=none; d=google.com; s=arc-20160816; b=zVQvEWAA1D9sXnwkjU8iIyj32bT0uR06E3qUoaFapwROPSknZXPoNsRsDQbkS2hon2 ymnLy7VTMAwteP9vFxhjwHfg8ynbgfV1h6gfwIlnhADbGVVhv3v2MZusmz0h/CaC7UyC F+M9lUXdJVRxYPUcL9Yc0LAzMzd0OLGKcwhEEsmrLQwhBRT1a8tr4eLnO6yaMcMJfyqR vHnXMyjwi5wyb8b8yWFMuX4LqVsnzf9WsG6LU4MS9Ak0NuW2JMpDP/sdU3alJEDvYjyA dL7cvpZUpCb/PQw08+SHb1F9R+vyBH9MEO5kWl7TkE+ZXMyCKBKX0SbohWeAI1h5N16C m6BQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=references:in-reply-to:message-id:date:subject:to:from :arc-authentication-results; bh=0F84AyHyRzstS25LUnRLo5EIou00WCahG8P20S/T87Y=; b=dy1U+W1xByxsTjWYOjiciCsZatMfCN+7Xt96iGsZvwZ1Fd4Y8WY3s/TlRukMxEEdhv cGhHHLb3u/+XUpbSZF6qcf64wFXHKKhxdyNnInO7lk77KlYO4rd+2BFLEFsYyWhA3IQv RIet0jYZaWiZXyYGNMnskVMjg3ChhiTY9hyQmjixB5ogzWhDnkH/IVit2IgvbTocp4fG quKK1HW+I8njRw1kaVndD7c1KnKojM4E8+L5cCm7Ha5cHJp7EBszy45nY3glmash0Qnp Z3excBdFTB1YVqnWKt+rvplpgJ/bp6gO6eiXYg3k3TVPxJJYcWBjUkbMsWD7uGcrx5wm 7mnw== ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: domain of a13xp0p0v88@gmail.com designates 209.85.220.65 as permitted sender) smtp.mailfrom=a13xp0p0v88@gmail.com Authentication-Results: mx.google.com; spf=pass (google.com: domain of a13xp0p0v88@gmail.com designates 209.85.220.65 as permitted sender) smtp.mailfrom=a13xp0p0v88@gmail.com X-Google-Smtp-Source: AB8JxZpdu6zuCJyguA6EzEUuaKwDaOIaEOArdtvVnH+WUA+4rTlIKx2Z+XNmxbb9vRvqLDqit7C30w== From: Alexander Popov To: kernel-hardening@lists.openwall.com, Kees Cook , PaX Team , Brad Spengler , Ingo Molnar , Andy Lutomirski , Tycho Andersen , Laura Abbott , Mark Rutland , Ard Biesheuvel , Borislav Petkov , Richard Sandiford , Thomas Gleixner , "H . Peter Anvin" , Peter Zijlstra , "Dmitry V . Levin" , Emese Revfy , Jonathan Corbet , Andrey Ryabinin , "Kirill A . Shutemov" , Thomas Garnier , Andrew Morton , Alexei Starovoitov , Josef Bacik , Masami Hiramatsu , Nicholas Piggin , Al Viro , "David S . Miller" , Ding Tianhong , David Woodhouse , Josh Poimboeuf , Steven Rostedt , Dominik Brodowski , Juergen Gross , Linus Torvalds , Greg Kroah-Hartman , Dan Williams , Dave Hansen , Mathias Krause , Vikas Shivappa , Kyle Huey , Dmitry Safonov , Will Deacon , Arnd Bergmann , Florian Weimer , Boris Lukashev , Andrey Konovalov , x86@kernel.org, linux-kernel@vger.kernel.org, alex.popov@linux.com Subject: [PATCH v12 4/6] lkdtm: Add a test for STACKLEAK Date: Wed, 16 May 2018 19:28:15 +0300 Message-Id: <1526488097-20611-5-git-send-email-alex.popov@linux.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1526488097-20611-1-git-send-email-alex.popov@linux.com> References: <1526488097-20611-1-git-send-email-alex.popov@linux.com> X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: =?utf-8?q?1600638818387237319?= X-GMAIL-MSGID: =?utf-8?q?1600638818387237319?= X-Mailing-List: linux-kernel@vger.kernel.org List-ID: Introduce lkdtm tests for the STACKLEAK feature. First, all of them check that the current task stack is properly erased (filled with STACKLEAK_POISON). STACKLEAK_DEEP_RECURSION tests that exhausting the current task stack with deep recursion is detected by CONFIG_VMAP_STACK (which is implied by CONFIG_GCC_PLUGIN_STACKLEAK). STACKLEAK_BIG_ALLOCA and STACKLEAK_RECURSION_WITH_ALLOCA test that alloca calls which overflow the kernel stack hit BUG()/panic() in check_alloca(). Signed-off-by: Alexander Popov Signed-off-by: Tycho Andersen --- drivers/misc/lkdtm/Makefile | 2 + drivers/misc/lkdtm/core.c | 3 + drivers/misc/lkdtm/lkdtm.h | 5 ++ drivers/misc/lkdtm/stackleak.c | 147 +++++++++++++++++++++++++++++++++++++++++ 4 files changed, 157 insertions(+) create mode 100644 drivers/misc/lkdtm/stackleak.c diff --git a/drivers/misc/lkdtm/Makefile b/drivers/misc/lkdtm/Makefile index 3370a41..951c984 100644 --- a/drivers/misc/lkdtm/Makefile +++ b/drivers/misc/lkdtm/Makefile @@ -8,7 +8,9 @@ lkdtm-$(CONFIG_LKDTM) += perms.o lkdtm-$(CONFIG_LKDTM) += refcount.o lkdtm-$(CONFIG_LKDTM) += rodata_objcopy.o lkdtm-$(CONFIG_LKDTM) += usercopy.o +lkdtm-$(CONFIG_LKDTM) += stackleak.o +KASAN_SANITIZE_stackleak.o := n KCOV_INSTRUMENT_rodata.o := n OBJCOPYFLAGS := diff --git a/drivers/misc/lkdtm/core.c b/drivers/misc/lkdtm/core.c index 2154d1b..9d0324a 100644 --- a/drivers/misc/lkdtm/core.c +++ b/drivers/misc/lkdtm/core.c @@ -183,6 +183,9 @@ static const struct crashtype crashtypes[] = { CRASHTYPE(USERCOPY_STACK_FRAME_FROM), CRASHTYPE(USERCOPY_STACK_BEYOND), CRASHTYPE(USERCOPY_KERNEL), + CRASHTYPE(STACKLEAK_BIG_ALLOCA), + CRASHTYPE(STACKLEAK_DEEP_RECURSION), + CRASHTYPE(STACKLEAK_RECURSION_WITH_ALLOCA), }; diff --git a/drivers/misc/lkdtm/lkdtm.h b/drivers/misc/lkdtm/lkdtm.h index 9e513dc..865a6c3 100644 --- a/drivers/misc/lkdtm/lkdtm.h +++ b/drivers/misc/lkdtm/lkdtm.h @@ -83,4 +83,9 @@ void lkdtm_USERCOPY_STACK_FRAME_FROM(void); void lkdtm_USERCOPY_STACK_BEYOND(void); void lkdtm_USERCOPY_KERNEL(void); +/* lkdtm_stackleak.c */ +void lkdtm_STACKLEAK_BIG_ALLOCA(void); +void lkdtm_STACKLEAK_DEEP_RECURSION(void); +void lkdtm_STACKLEAK_RECURSION_WITH_ALLOCA(void); + #endif diff --git a/drivers/misc/lkdtm/stackleak.c b/drivers/misc/lkdtm/stackleak.c new file mode 100644 index 0000000..8422e8d --- /dev/null +++ b/drivers/misc/lkdtm/stackleak.c @@ -0,0 +1,147 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * This code tests several aspects of the STACKLEAK feature: + * - the current task stack is properly erased (filled with STACKLEAK_POISON); + * - exhausting the current task stack with deep recursion is detected by + * CONFIG_VMAP_STACK (which is implied by CONFIG_GCC_PLUGIN_STACKLEAK); + * - alloca calls which overflow the kernel stack hit BUG()/panic() in + * check_alloca(). + * + * Authors: + * Tycho Andersen + * Alexander Popov + */ + +#include "lkdtm.h" +#include +#include + +static noinline bool stack_is_erased(void) +{ + unsigned long *sp, left, found, i; + const unsigned long check_depth = STACKLEAK_POISON_CHECK_DEPTH / + sizeof(unsigned long); + + /* + * For the details about the alignment of the poison values, see + * the comment in track_stack(). + */ + sp = PTR_ALIGN(&i, sizeof(unsigned long)); + + left = ((unsigned long)sp & (THREAD_SIZE - 1)) / sizeof(unsigned long); + sp--; + + /* + * One long int at the bottom of the thread stack is reserved + * and not poisoned. + */ + if (left > 1) + left--; + else + return false; + + pr_info("checking unused part of the thread stack (%lu bytes)...\n", + left * sizeof(unsigned long)); + + /* + * Search for check_depth poison values in a row (just like + * erase_kstack() does). + */ + for (i = 0, found = 0; i < left && found <= check_depth; i++) { + if (*(sp - i) == STACKLEAK_POISON) + found++; + else + found = 0; + } + + if (found <= check_depth) { + pr_err("FAIL: thread stack is not erased (checked %lu bytes)\n", + i * sizeof(unsigned long)); + return false; + } + + pr_info("first %lu bytes are unpoisoned\n", + (i - found) * sizeof(unsigned long)); + + /* The rest of thread stack should be erased */ + for (; i < left; i++) { + if (*(sp - i) != STACKLEAK_POISON) { + pr_err("FAIL: thread stack is NOT properly erased\n"); + return false; + } + } + + pr_info("the rest of the thread stack is properly erased\n"); + return true; +} + +static noinline void do_alloca(unsigned long size) +{ + char buf[size]; + + /* So this doesn't get inlined or optimized out */ + snprintf(buf, size, "testing alloca...\n"); +} + +void lkdtm_STACKLEAK_BIG_ALLOCA(void) +{ + if (!stack_is_erased()) + return; + + pr_info("try a small alloca of 16 bytes...\n"); + do_alloca(16); + pr_info("small alloca is successful\n"); + + pr_info("try alloca over the thread stack boundary...\n"); + do_alloca(THREAD_SIZE); + pr_err("FAIL: alloca over the thread stack boundary is not detected\n"); +} + +static noinline unsigned long recursion(unsigned long prev_sp, bool with_alloca) +{ + char buf[400]; + unsigned long sp = (unsigned long)&sp; + + snprintf(buf, sizeof(buf), "testing deep recursion...\n"); + + if (with_alloca) + do_alloca(400); + + if (prev_sp < sp + THREAD_SIZE) + sp = recursion(prev_sp, with_alloca); + + return sp; +} + +void lkdtm_STACKLEAK_DEEP_RECURSION(void) +{ + unsigned long sp = (unsigned long)&sp; + + if (!stack_is_erased()) + return; + + /* + * Overflow the thread stack using deep recursion. It should hit the + * guard page provided by CONFIG_VMAP_STACK (which is implied by + * CONFIG_GCC_PLUGIN_STACKLEAK). + */ + pr_info("try to overflow the thread stack using deep recursion...\n"); + pr_err("FAIL: stack depth overflow (%lu bytes) is not detected\n", + sp - recursion(sp, 0)); +} + +void lkdtm_STACKLEAK_RECURSION_WITH_ALLOCA(void) +{ + unsigned long sp = (unsigned long)&sp; + + if (!stack_is_erased()) + return; + + /* + * Overflow the thread stack using deep recursion with alloca. + * It should hit BUG()/panic() in check_alloca(). + */ + pr_info("try to overflow the thread stack using recursion & alloca\n"); + recursion(sp, 1); + pr_err("FAIL: stack depth overflow is not detected\n"); +} -- 2.7.4