Re: [PATCH for-next 19/25] fortify: Allow strlen() and strnlen() to pass compile-time known lengths

From
Kees Cook <hidden>
Date
2021-08-26 02:56:42
Also in
linux-hardening, lkml
Reply to
Nick Desaulniers, 2021-08-25
On Wed, Aug 25, 2021 at 03:05:56PM -0700, Nick Desaulniers wrote:
On Sun, Aug 22, 2021 at 12:57 AM Kees Cook [off-list ref] wrote:
quoted
Under CONFIG_FORTIFY_SOURCE, it is possible for the compiler to perform
strlen() and strnlen() at compile-time when the string size is known.
This is required to support compile-time overflow checking in strlcpy().

Signed-off-by: Kees Cook <redacted>
---
 include/linux/fortify-string.h | 47 ++++++++++++++++++++++++++--------
 1 file changed, 36 insertions(+), 11 deletions(-)
diff --git a/include/linux/fortify-string.h b/include/linux/fortify-string.h
index a3cb1d9aacce..e232a63fd826 100644
--- a/include/linux/fortify-string.h
+++ b/include/linux/fortify-string.h
@@ -10,6 +10,18 @@ void __read_overflow(void) __compiletime_error("detected read beyond size of obj
 void __read_overflow2(void) __compiletime_error("detected read beyond size of object (2nd parameter)");
 void __write_overflow(void) __compiletime_error("detected write beyond size of object (1st parameter)");

+#define __compiletime_strlen(p)        ({              \
+       size_t ret = (size_t)-1;                        \
+       size_t p_size = __builtin_object_size(p, 1);    \
+       if (p_size != (size_t)-1) {                     \
+               size_t p_len = p_size - 1;              \
+               if (__builtin_constant_p(p[p_len]) &&   \
+                   p[p_len] == '\0')                   \
+                       ret = __builtin_strlen(p);      \
+       }                                               \
+       ret;                                            \
+})
Can this be a `static inline` function that accepts a `const char *`
and returns a `size_t` rather than a statement expression?
No because both __builtin_object_size() and __builtin_strlen() may not
work. See:
https://lore.kernel.org/lkml/20210818060533.3569517-64-keescook@chromium.org/ (local)

Regardless, it will always collapse to a const value of either -1 or
the length of the string.
quoted
+
 #if defined(CONFIG_KASAN_GENERIC) || defined(CONFIG_KASAN_SW_TAGS)
 extern void *__underlying_memchr(const void *p, int c, __kernel_size_t size) __RENAME(memchr);
 extern int __underlying_memcmp(const void *p, const void *q, __kernel_size_t size) __RENAME(memcmp);
@@ -60,21 +72,31 @@ extern __kernel_size_t __real_strnlen(const char *, __kernel_size_t) __RENAME(st
 __FORTIFY_INLINE __kernel_size_t strnlen(const char *p, __kernel_size_t maxlen)
 {
        size_t p_size = __builtin_object_size(p, 1);
-       __kernel_size_t ret = __real_strnlen(p, maxlen < p_size ? maxlen : p_size);
+       size_t p_len = __compiletime_strlen(p);
+       size_t ret;
+
+       /* We can take compile-time actions when maxlen is const. */
+       if (__builtin_constant_p(maxlen) && p_len != (size_t)-1) {
+               /* If p is const, we can use its compile-time-known len. */
+               if (maxlen >= p_size)
+                       return p_len;
+       }

+       /* Do no check characters beyond the end of p. */
s/no/not/
Thanks!
quoted
+       ret = __real_strnlen(p, maxlen < p_size ? maxlen : p_size);
        if (p_size <= ret && maxlen != ret)
                fortify_panic(__func__);
        return ret;
 }

+/* defined after fortified strnlen to reuse it. */
 __FORTIFY_INLINE __kernel_size_t strlen(const char *p)
 {
        __kernel_size_t ret;
        size_t p_size = __builtin_object_size(p, 1);

-       /* Work around gcc excess stack consumption issue */
-       if (p_size == (size_t)-1 ||
-               (__builtin_constant_p(p[p_size - 1]) && p[p_size - 1] == '\0'))
+       /* Give up if we don't know how large p is. */
+       if (p_size == (size_t)-1)
                return __underlying_strlen(p);
        ret = strnlen(p, p_size);
        if (p_size <= ret)
@@ -86,24 +108,27 @@ __FORTIFY_INLINE __kernel_size_t strlen(const char *p)
 extern size_t __real_strlcpy(char *, const char *, size_t) __RENAME(strlcpy);
 __FORTIFY_INLINE size_t strlcpy(char *p, const char *q, size_t size)
 {
-       size_t ret;
        size_t p_size = __builtin_object_size(p, 1);
        size_t q_size = __builtin_object_size(q, 1);
+       size_t q_len;   /* Full count of source string length. */
+       size_t len;     /* Count of characters going into destination. */

        if (p_size == (size_t)-1 && q_size == (size_t)-1)
                return __real_strlcpy(p, q, size);
-       ret = strlen(q);
-       if (size) {
-               size_t len = (ret >= size) ? size - 1 : ret;
-
-               if (__builtin_constant_p(len) && len >= p_size)
+       q_len = strlen(q);
+       len = (q_len >= size) ? size - 1 : q_len;
+       if (__builtin_constant_p(size) && __builtin_constant_p(q_len) && size) {
+               /* Write size is always larger than destintation. */
s/destintation/destination/
I can't type. :)

Fixed now.

-Kees
quoted
+               if (len >= p_size)
                        __write_overflow();
+       }
+       if (size) {
                if (len >= p_size)
                        fortify_panic(__func__);
                __underlying_memcpy(p, q, len);
                p[len] = '\0';
        }
-       return ret;
+       return q_len;
 }

 /* defined after fortified strnlen to reuse it */
--
2.30.2

--
You received this message because you are subscribed to the Google Groups "Clang Built Linux" group.
To unsubscribe from this group and stop receiving emails from it, send an email to clang-built-linux+unsubscribe@googlegroups.com.
To view this discussion on the web visit https://groups.google.com/d/msgid/clang-built-linux/20210822075122.864511-20-keescook%40chromium.org.


-- 
Thanks,
~Nick Desaulniers
-- 
Kees Cook
Thread (42 messages) 42 messages, 5 authors, last reply 2021-10-18
Keyboard shortcuts
hback out one level
jnext message in thread / next series-diff position
kprevious message in thread / previous series-diff position
ldrill in
Escclose help / fold thread tree
?toggle this help