From patchwork Tue Dec 5 23:33:45 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Alexander Popov X-Patchwork-Id: 10094147 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork.web.codeaurora.org (Postfix) with ESMTP id 55F6460348 for ; Tue, 5 Dec 2017 23:34:51 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 4783E288DC for ; Tue, 5 Dec 2017 23:34:51 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id 3C17D289A3; Tue, 5 Dec 2017 23:34:51 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-4.2 required=2.0 tests=BAYES_00, RCVD_IN_DNSWL_MED autolearn=ham version=3.3.1 Received: from mother.openwall.net (mother.openwall.net [195.42.179.200]) by mail.wl.linuxfoundation.org (Postfix) with SMTP id 072EE288DC for ; Tue, 5 Dec 2017 23:34:49 +0000 (UTC) Received: (qmail 9276 invoked by uid 550); 5 Dec 2017 23:34:16 -0000 Mailing-List: contact kernel-hardening-help@lists.openwall.com; run by ezmlm Precedence: bulk List-Post: List-Help: List-Unsubscribe: List-Subscribe: List-ID: Delivered-To: mailing list kernel-hardening@lists.openwall.com Received: (qmail 8155 invoked from network); 5 Dec 2017 23:34:11 -0000 X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:subject:date:message-id:in-reply-to :references; bh=+SOwyU5UEZFZzt00sFWJcKsVl4rg7Ar+lvqcE1Z1sf8=; b=krp0akXi09RLvhWZ67OBOvXsUA1y2d3NKGrS87l1UsleKUROQ+YMmbKbbbdUWev7h0 lVrjRrzlu9zCClE7nGfWy+0SuChEYec2v/0HybgjGeqOjRr/228bJytKIRnZaBB9nS7p H5ffm+dIMiL6II8PJ5rjK/KJOdNL3FOXIo0wIW/Mze1ZJB4Bz6Wu88sx81A5YUqiCJsf nSp63Y2kQuKVCcdtWCLdF5ATQg9Fr4mwSnW/X7nU4TlEWWxpvlCvU2rj2Mr81nXdS8tU XFGv/nyJG3jaCj2GdCx13mlX0XL9sUQdp52wVuxRN9jJXJxiXbspdN/F5uLLT72H7GoO UmzA== X-Gm-Message-State: AKGB3mLD6RnCUqrfKCpKnNQ8PzOlB/3U/9d6yEMRiGnsu6FVB5FskdQQ sP4+xB/jOYJwZX3rkA8RdPAyt2xw X-Google-Smtp-Source: AGs4zMYMUiF0Xb8sQnVhAqxZkNVvm/O83fEaEy9OnWcUyizdsN2iFm/YOM75psSJMjeKj270QZp6VQ== X-Received: by 10.25.219.145 with SMTP id t17mr6443541lfi.73.1512516840264; Tue, 05 Dec 2017 15:34:00 -0800 (PST) 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 , Thomas Gleixner , "H . Peter Anvin" , Peter Zijlstra , x86@kernel.org, alex.popov@linux.com Date: Wed, 6 Dec 2017 02:33:45 +0300 Message-Id: <1512516827-29797-5-git-send-email-alex.popov@linux.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1512516827-29797-1-git-send-email-alex.popov@linux.com> References: <1512516827-29797-1-git-send-email-alex.popov@linux.com> Subject: [kernel-hardening] [PATCH RFC v6 4/6] lkdtm: Add a test for STACKLEAK X-Virus-Scanned: ClamAV using ClamSMTP Introduce two lkdtm tests for the STACKLEAK feature: STACKLEAK_CHECK_ALLOCA and STACKLEAK_TRACK_STACK. Both of them check that the current task stack is properly erased (filled with STACKLEAK_POISON). In addition, STACKLEAK_CHECK_ALLOCA tests that: - check_alloca() allows alloca calls which don't exhaust the kernel stack; - alloca calls which exhaust/overflow the kernel stack hit BUG() in check_alloca(). And STACKLEAK_TRACK_STACK checks that exhausting the thread stack with a recursion is detected: - it hits the BUG() in track_stack() if CONFIG_VMAP_STACK is not enabled, - or hits the guard page otherwise. Signed-off-by: Tycho Andersen Signed-off-by: Alexander Popov --- drivers/misc/Makefile | 3 + drivers/misc/lkdtm.h | 4 ++ drivers/misc/lkdtm_core.c | 2 + drivers/misc/lkdtm_stackleak.c | 139 +++++++++++++++++++++++++++++++++++++++++ 4 files changed, 148 insertions(+) create mode 100644 drivers/misc/lkdtm_stackleak.c diff --git a/drivers/misc/Makefile b/drivers/misc/Makefile index 5ca5f64..66c3605 100644 --- a/drivers/misc/Makefile +++ b/drivers/misc/Makefile @@ -63,6 +63,9 @@ lkdtm-$(CONFIG_LKDTM) += lkdtm_perms.o lkdtm-$(CONFIG_LKDTM) += lkdtm_refcount.o lkdtm-$(CONFIG_LKDTM) += lkdtm_rodata_objcopy.o lkdtm-$(CONFIG_LKDTM) += lkdtm_usercopy.o +lkdtm-$(CONFIG_LKDTM) += lkdtm_stackleak.o + +KASAN_SANITIZE_lkdtm_stackleak.o := n KCOV_INSTRUMENT_lkdtm_rodata.o := n diff --git a/drivers/misc/lkdtm.h b/drivers/misc/lkdtm.h index 687a0db..2a0cd0d 100644 --- a/drivers/misc/lkdtm.h +++ b/drivers/misc/lkdtm.h @@ -83,4 +83,8 @@ void lkdtm_USERCOPY_STACK_FRAME_FROM(void); void lkdtm_USERCOPY_STACK_BEYOND(void); void lkdtm_USERCOPY_KERNEL(void); +/* lkdtm_stackleak.c */ +void lkdtm_STACKLEAK_CHECK_ALLOCA(void); +void lkdtm_STACKLEAK_TRACK_STACK(void); + #endif diff --git a/drivers/misc/lkdtm_core.c b/drivers/misc/lkdtm_core.c index ba92291..3a22ffa 100644 --- a/drivers/misc/lkdtm_core.c +++ b/drivers/misc/lkdtm_core.c @@ -183,6 +183,8 @@ static const struct crashtype crashtypes[] = { CRASHTYPE(USERCOPY_STACK_FRAME_FROM), CRASHTYPE(USERCOPY_STACK_BEYOND), CRASHTYPE(USERCOPY_KERNEL), + CRASHTYPE(STACKLEAK_CHECK_ALLOCA), + CRASHTYPE(STACKLEAK_TRACK_STACK), }; diff --git a/drivers/misc/lkdtm_stackleak.c b/drivers/misc/lkdtm_stackleak.c new file mode 100644 index 0000000..1f95ee3 --- /dev/null +++ b/drivers/misc/lkdtm_stackleak.c @@ -0,0 +1,139 @@ +/* + * This file tests a few aspects of the STACKLEAK feature: + * - the current task stack is properly erased (filled with STACKLEAK_POISON); + * - check_alloca() allows alloca calls which don't exhaust the kernel stack; + * - alloca calls which exhaust/overflow the kernel stack hit BUG() in + * check_alloca(); + * - exhausting the thread stack with a recursion is detected: it hits the + * BUG() in track_stack() if CONFIG_VMAP_STACK is not enabled, or hits the + * guard page otherwise. + * + * Copyright (C) Docker, Inc. 2017 + * + * Authors: + * Tycho Andersen + * Alexander Popov + */ + +#include "lkdtm.h" +#include +#include + +#ifndef CONFIG_GCC_PLUGIN_STACKLEAK +# define STACKLEAK_POISON -0xBEEF +# define CONFIG_STACKLEAK_TRACK_MIN_SIZE 100 +#endif + +static noinline bool stack_is_erased(void) +{ + unsigned long *sp, left, found, i; + + /* + * 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--; + + /* + * Two unsigned long ints at the bottom of the thread stack are + * reserved and not poisoned. + */ + if (left <= 2) + return false; + + left -= 2; + pr_info("checking unused part of the thread stack (%lu bytes)...\n", + left * sizeof(unsigned long)); + + /* Search for 17 poison values in a row (like erase_kstack() does) */ + for (i = 0, found = 0; i < left && found < 17; i++) { + if (*(sp - i) == STACKLEAK_POISON) + found++; + else + found = 0; + } + + if (found < 17) { + 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, "hello world\n"); +} + +void lkdtm_STACKLEAK_CHECK_ALLOCA(void) +{ + unsigned long left = (unsigned long)&left & (THREAD_SIZE - 1); + + if (!stack_is_erased()) + return; + + /* Try a small alloca to see if it works */ + pr_info("try a small alloca of 16 bytes...\n"); + do_alloca(16); + pr_info("small alloca is successful\n"); + + /* Try to hit the BUG() in check_alloca() */ + pr_info("try a large alloca of %lu bytes (stack overflow)...\n", left); + do_alloca(left); + pr_err("FAIL: large alloca overstepped the thread stack boundary\n"); +} + +/* + * The stack frame size of recursion() is bigger than the + * CONFIG_STACKLEAK_TRACK_MIN_SIZE, hence that function is instrumented + * by the STACKLEAK gcc plugin and it calls track_stack() at the beginning. + */ +static noinline unsigned long recursion(unsigned long prev_sp) +{ + char buf[CONFIG_STACKLEAK_TRACK_MIN_SIZE + 42]; + unsigned long sp = (unsigned long)&sp; + + snprintf(buf, sizeof(buf), "hello world\n"); + + if (prev_sp < sp + THREAD_SIZE) + sp = recursion(prev_sp); + + return sp; +} + +void lkdtm_STACKLEAK_TRACK_STACK(void) +{ + unsigned long sp = (unsigned long)&sp; + + if (!stack_is_erased()) + return; + + /* + * Exhaust the thread stack with a recursion. It should hit the + * BUG() in track_stack() if CONFIG_VMAP_STACK is not enabled, or + * access the guard page otherwise. + */ + pr_info("try to exhaust the thread stack with the recursion...\n"); + pr_err("FAIL: thread stack exhaustion (%lu bytes) is not detected\n", + sp - recursion(sp)); +}