From patchwork Wed Nov 8 22:30:18 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Rasmus Villemoes X-Patchwork-Id: 10049581 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 2326660381 for ; Wed, 8 Nov 2017 22:31:37 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 15F592912F for ; Wed, 8 Nov 2017 22:31:37 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id 0A6032A41A; Wed, 8 Nov 2017 22:31:37 +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.1 required=2.0 tests=BAYES_00,DKIM_SIGNED, RCVD_IN_DNSWL_MED,T_DKIM_INVALID 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 D4CD0299A3 for ; Wed, 8 Nov 2017 22:31:35 +0000 (UTC) Received: (qmail 17624 invoked by uid 550); 8 Nov 2017 22:31:00 -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 17539 invoked from network); 8 Nov 2017 22:30:58 -0000 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=rasmusvillemoes.dk; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=AspJt6JWzXv5sL/nl+UQqI3yl2kKQLSIfAHBpOKQWS8=; b=iIJQ+SxvJHPClg6c13NnaSxXEr1kYqcfiNg3g4ZqY1rSOZ/TkjzNRosjChY0Bl2bIr DfNdgNqiBGCWKgauPyBH6HCD0FrLtGrbzE3snwEPLZzEPNVac9IzZkhiiakKfmieTrfB 1UrGb3e4s6BeAF/QKhF0xWiFMqbMVRXfpQwJQ= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=AspJt6JWzXv5sL/nl+UQqI3yl2kKQLSIfAHBpOKQWS8=; b=H9lLaqTuuLjtE8AY5TM62r0fihqxM61JXcxf+MY/XQvMIS/likb1sy52n0X0kbPYrf ufVKxGt6aOH+3S6HpLmXVqmcxYA6Rmna4enzIeG4uNBMGEarc4r0dWw/AmS31ug2NxDu lRm6nzcf1mlNTAYX0sfexUOBmsnw9a+XF1E/DbcQwzaQkalwJ2nbZoxkb1spqpDN20EX 4LuEz5yJe1furqsDjb6Nj0cBWjtVTvWfaAmaGgWpupMxQVOPeAJHC8tZUWnEhPHvxezL sJMIiqAjwiDGWgxLmcYZXmYYEXt066WCQpjbuIjPFFdmBBlSSGZ3NW8syTKvJ4Jdg38e +lXg== X-Gm-Message-State: AJaThX5P1unt7aEScsy2ippar8F5ddFh+T+cSiyAY6VHNOI6tiCiD6ll uKfqwbM+Rk3oH5M1/Q6rLIwIb8kP X-Google-Smtp-Source: ABhQp+TZXt87+7L9dPqyPX/I//sM35kWq6GrVXZx7iHunZauXlG/TvimlN95nXrko7wl0EaySUKDxA== X-Received: by 10.223.147.135 with SMTP id 7mr1735547wrp.237.1510180247192; Wed, 08 Nov 2017 14:30:47 -0800 (PST) From: Rasmus Villemoes To: kernel-hardening@lists.openwall.com Cc: linux-kernel@vger.kernel.org, Andrew Morton , Kees Cook , Rasmus Villemoes Date: Wed, 8 Nov 2017 23:30:18 +0100 Message-Id: <20171108223020.24487-5-linux@rasmusvillemoes.dk> X-Mailer: git-send-email 2.11.0 In-Reply-To: <20171108223020.24487-1-linux@rasmusvillemoes.dk> References: <20171108223020.24487-1-linux@rasmusvillemoes.dk> Subject: [kernel-hardening] [RFC 4/6] lib/vsprintf.c: add fmtcheck utility X-Virus-Scanned: ClamAV using ClamSMTP We have a few places in the kernel where a *printf function is used with a non-constant format string, making the ordinary static type checking done by gcc et al. impossible. Some things can still be caught at build time with appropriate instrumentation (I'm sure one can do much better than the format_template plugin), but that still leaves a number of places unchecked. So this patch adds a function for doing run-time verification of a given format string against a template. The fmtcheck() function takes two format string arguments and checks whether they contain the same printf specifiers. If they do, the first (the string-to-be-checked) string is returned. If not, the second (the template) is returned. Regardless of which string is returned at run-time, the __format_arg attribute allows the compiler to do type-checking if the fmtcheck() function is used inside a *printf call, e.g. sprintf(buf, fmtcheck(what->ever, "%d %lx", 0), i, m) We actually make fmtcheck() a macro that tries very hard to ensure the template argument is a string literal - partly to help avoid mixing up the two "const char*" arguments, partly because much of the point of this sanity checking vanishes if the template is not a literal (e.g., the __format_arg annotation becomes useless). We don't treat "%*.*s" and "%d %d %s" as equivalent, despite them taking the same vararg types, since they're morally very distinct. In fact, at least for now, we don't even treat "%d" and "%u" as equivalent. We can relax that, possibly via FMTCHECK_* flags, but let's first see which users there might be and what they'd want. If either string contains a %p, we really should check the following alphanumerics to see which (if any) extension is used and check that they match as well. For now, just complain loudly, partly because I'm lazy, partly because I don't know any in-tree code that might use fmtcheck() with a %p in the template, and I can't really imagine anyone would use a %pXX extension in a non-constant format string. I don't know if WARN is too violent; maybe just pr_warn would be ok. The BSDs (and libbsd on linux) contain a fmtcheck() function; I took the name and return semantics from that. Signed-off-by: Rasmus Villemoes --- include/linux/kernel.h | 6 +++++ lib/vsprintf.c | 63 ++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 69 insertions(+) diff --git a/include/linux/kernel.h b/include/linux/kernel.h index 4b484ab9e163..d7c6f9a9c024 100644 --- a/include/linux/kernel.h +++ b/include/linux/kernel.h @@ -460,6 +460,12 @@ char *kvasprintf(gfp_t gfp, const char *fmt, va_list args); extern __printf(2, 0) const char *kvasprintf_const(gfp_t gfp, const char *fmt, va_list args); +extern __format_arg(2) __attribute_const__ +const char *_fmtcheck(const char *fmt, const char *tmpl, unsigned flags); +#define fmtcheck(fmt, tmpl, flags) _fmtcheck(fmt, "" tmpl "", flags) +#define FMTCHECK_SILENT 0x01 +#define FMTCHECK_NO_EXTRA_ARGS 0x02 + extern __scanf(2, 3) int sscanf(const char *, const char *, ...); extern __scanf(2, 0) diff --git a/lib/vsprintf.c b/lib/vsprintf.c index 86c3385b9eb3..db50acf682e7 100644 --- a/lib/vsprintf.c +++ b/lib/vsprintf.c @@ -3030,3 +3030,66 @@ int sscanf(const char *buf, const char *fmt, ...) return i; } EXPORT_SYMBOL(sscanf); + +static int +next_interesting_spec(const char **s, struct printf_spec *spec) +{ + int len; + + while (1) { + len = format_decode(*s, spec); + if (!len) + return 0; + *s += len; + if (spec->type == FORMAT_TYPE_NONE || + spec->type == FORMAT_TYPE_PERCENT_CHAR) + continue; + return len; + } +} + +const char * +_fmtcheck(const char *fmt, const char *tmpl, unsigned flags) +{ + const char *f = fmt; + const char *t = tmpl; + struct printf_spec fspec = {0}, tspec = {0}; + int flen, tlen; + int warn = !(flags & FMTCHECK_SILENT); + + while (1) { + flen = next_interesting_spec(&f, &fspec); + tlen = next_interesting_spec(&t, &tspec); + if (!flen) { + /* + * The given format string doesn't have any + * more specifiers. It's ok from a type-safety + * POV for the template to have extra, but + * optionally warn about it (e.g., a single %d + * may be required). + */ + if (tlen && (flags & FMTCHECK_NO_EXTRA_ARGS) && warn) + WARN_ONCE(warn, "template '%s' expects more arguments than '%s'\n", + tmpl, fmt); + return fmt; + } + if (!tlen) { + WARN_ONCE(warn, "format string '%s' expects more arguments than template '%s'", + fmt, tmpl); + return tmpl; + } + WARN_ONCE(warn && (fspec.type == FORMAT_TYPE_PTR || tspec.type == FORMAT_TYPE_PTR), + "don't use %%p in non-constant format strings"); + /* + * Should we also care about flags, field width, + * precision? Should we even care about base? + */ + if (fspec.type != tspec.type || + fspec.base != tspec.base) { + WARN_ONCE(warn, "format string '%s' incompatible with template '%s'", + fmt, tmpl); + return tmpl; + } + } +} +EXPORT_SYMBOL_GPL(_fmtcheck);