Skip to contentSkip to conversation

usercopy: add testcases to check zeroing on failure of usercopy

PATCH In review Hoeun Ryu 3 participants 9 messages Feb 12, 2017 – Feb 15, 2017 Library code

lore
Share & tools
lore

Hoeun Ryu

author
#0 lore raw

PATCH 1/1 usercopy: add testcases to check zeroing on failure of usercopy

In the hardend usercopy, the destination buffer will be zeroed if copy_from_user/get_user fails. This patch adds testcases for it. The destination buffer is set with non-zero value before illegal copy_from_user/get_user is executed and the buffer is compared to zero after usercopy is done.

---
 lib/test_user_copy.c | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
lib/test_user_copy.c +17 -0
index 0ecef3e..54bd898 100644
@@ -41,11 +41,18 @@ static int __init test_user_copy_init(void)
 	char *bad_usermem;
 	unsigned long user_addr;
 	unsigned long value = 0x5A;
+	char *zerokmem;
 
 	kmem = kmalloc(PAGE_SIZE * 2, GFP_KERNEL);
 	if (!kmem)
 		return -ENOMEM;
 
+	zerokmem = kzalloc(PAGE_SIZE * 2, GFP_KERNEL);
+	if (!zerokmem) {
+		kfree(kmem);
+		return -ENOMEM;
+	}
+
 	user_addr = vm_mmap(NULL, 0, PAGE_SIZE * 2,
 			    PROT_READ | PROT_WRITE | PROT_EXEC,
 			    MAP_ANONYMOUS | MAP_PRIVATE, 0);
@@ -69,25 +76,35 @@ static int __init test_user_copy_init(void)
 		    "legitimate put_user failed");
 
 	/* Invalid usage: none of these should succeed. */
+	memset(kmem, 0x5A, PAGE_SIZE);
 	ret |= test(!copy_from_user(kmem, (char __user *)(kmem + PAGE_SIZE),
 				    PAGE_SIZE),
 		    "illegal all-kernel copy_from_user passed");
+	ret |= test(memcmp(zerokmem, kmem, PAGE_SIZE),
+		    "zeroing failure for illegal all-kernel copy_from_user");
+	memset(bad_usermem, 0x5A, PAGE_SIZE);
 	ret |= test(!copy_from_user(bad_usermem, (char __user *)kmem,
 				    PAGE_SIZE),
 		    "illegal reversed copy_from_user passed");
+	ret |= test(memcmp(zerokmem, bad_usermem, PAGE_SIZE),
+		    "zeroing failure for illegal reversed copy_from_user");
 	ret |= test(!copy_to_user((char __user *)kmem, kmem + PAGE_SIZE,
 				  PAGE_SIZE),
 		    "illegal all-kernel copy_to_user passed");
 	ret |= test(!copy_to_user((char __user *)kmem, bad_usermem,
 				  PAGE_SIZE),
 		    "illegal reversed copy_to_user passed");
+	memset(kmem, 0x5A, PAGE_SIZE);
 	ret |= test(!get_user(value, (unsigned long __user *)kmem),
 		    "illegal get_user passed");
+	ret |= test(memcmp(zerokmem, kmem, sizeof(value)),
+		    "zeroing failure for illegal get_user");
 	ret |= test(!put_user(value, (unsigned long __user *)kmem),
 		    "illegal put_user passed");
 
 	vm_munmap(user_addr, PAGE_SIZE * 2);
 	kfree(kmem);
+	kfree(zerokmem);
 
 	if (ret == 0) {
 		pr_info("tests passed.\n");
Signature · 1 line
2.7.4
#1 lore raw
Quoted 7 lines · Hoeun Ryu

In the hardend usercopy, the destination buffer will be zeroed if copy_from_user/get_user fails. This patch adds testcases for it. The destination buffer is set with non-zero value before illegal copy_from_user/get_user is executed and the buffer is compared to zero after usercopy is done.

This looks great!

I'll adjust the commit slightly (the zeroing always happens, regardless of hardened usercopy) and add it to my usercopy tree.

Thanks!

-Kees

Signature · 2 lines
Kees Cook
Pixel Security
#2 lore raw
In reply to Hoeun Ryu
Quoted 35 lines · Hoeun Ryu

In the hardend usercopy, the destination buffer will be zeroed if copy_from_user/get_user fails. This patch adds testcases for it. The destination buffer is set with non-zero value before illegal copy_from_user/get_user is executed and the buffer is compared to zero after usercopy is done.

---
 lib/test_user_copy.c | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
lib/test_user_copy.c +7 -0
index 0ecef3e..54bd898 100644
@@ -41,11 +41,18 @@ static int __init test_user_copy_init(void)
        char *bad_usermem;
        unsigned long user_addr;
        unsigned long value = 0x5A;
+       char *zerokmem;
 
        kmem = kmalloc(PAGE_SIZE * 2, GFP_KERNEL);
        if (!kmem)
                return -ENOMEM;
 
+       zerokmem = kzalloc(PAGE_SIZE * 2, GFP_KERNEL);
+       if (!zerokmem) {
+               kfree(kmem);
+               return -ENOMEM;
+       }
+
        user_addr = vm_mmap(NULL, 0, PAGE_SIZE * 2,
                            PROT_READ | PROT_WRITE | PROT_EXEC,
                            MAP_ANONYMOUS | MAP_PRIVATE, 0);

lib/test_user_copy.c static int __init test_user_copy_init(void) · line 85

Quoted 10 lines
lib/test_user_copy.c +4 -0
@@ -69,25 +76,35 @@ static int __init test_user_copy_init(void)
                    "legitimate put_user failed");
 
        /* Invalid usage: none of these should succeed. */
+       memset(kmem, 0x5A, PAGE_SIZE);
        ret |= test(!copy_from_user(kmem, (char __user *)(kmem + PAGE_SIZE),
                                    PAGE_SIZE),
                    "illegal all-kernel copy_from_user passed");
+       ret |= test(memcmp(zerokmem, kmem, PAGE_SIZE),
+                   "zeroing failure for illegal all-kernel copy_from_user");
+       memset(bad_usermem, 0x5A, PAGE_SIZE);

Oh, actually, ha-ha: this isn't legal: it's a direct copy from kernel to userspace. :) This needs a copy_to_user()... (and same for the memcmp...)

Quoted 26 lines
lib/test_user_copy.c +6 -1
        ret |= test(!copy_from_user(bad_usermem, (char __user *)kmem,
                                    PAGE_SIZE),
                    "illegal reversed copy_from_user passed");
+       ret |= test(memcmp(zerokmem, bad_usermem, PAGE_SIZE),
+                   "zeroing failure for illegal reversed copy_from_user");
        ret |= test(!copy_to_user((char __user *)kmem, kmem + PAGE_SIZE,
                                  PAGE_SIZE),
                    "illegal all-kernel copy_to_user passed");
        ret |= test(!copy_to_user((char __user *)kmem, bad_usermem,
                                  PAGE_SIZE),
                    "illegal reversed copy_to_user passed");
+       memset(kmem, 0x5A, PAGE_SIZE);
        ret |= test(!get_user(value, (unsigned long __user *)kmem),
                    "illegal get_user passed");
+       ret |= test(memcmp(zerokmem, kmem, sizeof(value)),
+                   "zeroing failure for illegal get_user");
        ret |= test(!put_user(value, (unsigned long __user *)kmem),
                    "illegal put_user passed");
 
        vm_munmap(user_addr, PAGE_SIZE * 2);
        kfree(kmem);
+       kfree(zerokmem);
 
        if (ret == 0) {
                pr_info("tests passed.\n");
--
Quoted 2 lines

2.7.4

Can you respin this?

-Kees

Signature · 2 lines
Kees Cook
Pixel Security
#3 lore raw
Quoted 74 lines · Kees Cook
Quoted 35 lines · Hoeun Ryu

In the hardend usercopy, the destination buffer will be zeroed if copy_from_user/get_user fails. This patch adds testcases for it. The destination buffer is set with non-zero value before illegal copy_from_user/get_user is executed and the buffer is compared to zero after usercopy is done.

---
 lib/test_user_copy.c | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
lib/test_user_copy.c +7 -0
index 0ecef3e..54bd898 100644
@@ -41,11 +41,18 @@ static int __init test_user_copy_init(void)
        char *bad_usermem;
        unsigned long user_addr;
        unsigned long value = 0x5A;
+       char *zerokmem;
 
        kmem = kmalloc(PAGE_SIZE * 2, GFP_KERNEL);
        if (!kmem)
                return -ENOMEM;
 
+       zerokmem = kzalloc(PAGE_SIZE * 2, GFP_KERNEL);
+       if (!zerokmem) {
+               kfree(kmem);
+               return -ENOMEM;
+       }
+
        user_addr = vm_mmap(NULL, 0, PAGE_SIZE * 2,
                            PROT_READ | PROT_WRITE | PROT_EXEC,
                            MAP_ANONYMOUS | MAP_PRIVATE, 0);

lib/test_user_copy.c static int __init test_user_copy_init(void) · line 85

Quoted 10 lines
lib/test_user_copy.c +4 -0
@@ -69,25 +76,35 @@ static int __init test_user_copy_init(void)
                    "legitimate put_user failed");
 
        /* Invalid usage: none of these should succeed. */
+       memset(kmem, 0x5A, PAGE_SIZE);
        ret |= test(!copy_from_user(kmem, (char __user *)(kmem + PAGE_SIZE),
                                    PAGE_SIZE),
                    "illegal all-kernel copy_from_user passed");
+       ret |= test(memcmp(zerokmem, kmem, PAGE_SIZE),
+                   "zeroing failure for illegal all-kernel copy_from_user");
+       memset(bad_usermem, 0x5A, PAGE_SIZE);

Oh, actually, ha-ha: this isn't legal: it's a direct copy from kernel to userspace. :) This needs a copy_to_user()... (and same for the memcmp...)

Quoted 23 lines
lib/test_user_copy.c +6 -0
        ret |= test(!copy_from_user(bad_usermem, (char __user *)kmem,
                                    PAGE_SIZE),
                    "illegal reversed copy_from_user passed");
+       ret |= test(memcmp(zerokmem, bad_usermem, PAGE_SIZE),
+                   "zeroing failure for illegal reversed copy_from_user");
        ret |= test(!copy_to_user((char __user *)kmem, kmem + PAGE_SIZE,
                                  PAGE_SIZE),
                    "illegal all-kernel copy_to_user passed");
        ret |= test(!copy_to_user((char __user *)kmem, bad_usermem,
                                  PAGE_SIZE),
                    "illegal reversed copy_to_user passed");
+       memset(kmem, 0x5A, PAGE_SIZE);
        ret |= test(!get_user(value, (unsigned long __user *)kmem),
                    "illegal get_user passed");
+       ret |= test(memcmp(zerokmem, kmem, sizeof(value)),
+                   "zeroing failure for illegal get_user");
        ret |= test(!put_user(value, (unsigned long __user *)kmem),
                    "illegal put_user passed");
 
        vm_munmap(user_addr, PAGE_SIZE * 2);
        kfree(kmem);
+       kfree(zerokmem);
 
Quoted 7 lines
Quoted 5 lines
lib/test_user_copy.c +0 -1
        if (ret == 0) {
                pr_info("tests passed.\n");
--

2.7.4

Can you respin this?

On second thought, don't worry about a respin, I had to adjust the bad copy_from_user() that was already in there (which fails under SMAP/PAN anyway). I'll clean this up and add it to the tree.

Thanks!

-Kees

Signature · 2 lines
Kees Cook
Pixel Security
author
#4 lore raw
Quoted 43 lines · Kees Cook
Quoted 40 lines · Kees Cook
Quoted 38 lines · Hoeun Ryu

In the hardend usercopy, the destination buffer will be zeroed if copy_from_user/get_user fails. This patch adds testcases for it. The destination buffer is set with non-zero value before illegal copy_from_user/get_user is executed and the buffer is compared to zero after usercopy is done.

---
lib/test_user_copy.c | 17 +++++++++++++++++

1 file changed, 17 insertions(+)
lib/test_user_copy.c +7 -0
index 0ecef3e..54bd898 100644
@@ -41,11 +41,18 @@ static int __init test_user_copy_init(void)
       char *bad_usermem;
       unsigned long user_addr;
       unsigned long value = 0x5A;
+       char *zerokmem;
 
       kmem = kmalloc(PAGE_SIZE * 2, GFP_KERNEL);
       if (!kmem)
               return -ENOMEM;
 
+       zerokmem = kzalloc(PAGE_SIZE * 2, GFP_KERNEL);
+       if (!zerokmem) {
+               kfree(kmem);
+               return -ENOMEM;
+       }
+
       user_addr = vm_mmap(NULL, 0, PAGE_SIZE * 2,
                           PROT_READ | PROT_WRITE | PROT_EXEC,
                           MAP_ANONYMOUS | MAP_PRIVATE, 0);
@@ -69,25 +76,35 @@ static int __init test_user_copy_init(void)
                   "legitimate put_user failed");
 
Quoted 12 lines
Quoted 9 lines

lib/test_user_copy.c static int __init test_user_copy_init(void) · line 85

Quoted 8 lines
lib/test_user_copy.c +4 -0
       /* Invalid usage: none of these should succeed. */
+       memset(kmem, 0x5A, PAGE_SIZE);
       ret |= test(!copy_from_user(kmem, (char __user *)(kmem + PAGE_SIZE),
                                   PAGE_SIZE),
                   "illegal all-kernel copy_from_user passed");
+       ret |= test(memcmp(zerokmem, kmem, PAGE_SIZE),
+                   "zeroing failure for illegal all-kernel copy_from_user");
+       memset(bad_usermem, 0x5A, PAGE_SIZE);
Quoted 3 lines

Oh, actually, ha-ha: this isn't legal: it's a direct copy from kernel to userspace. :) This needs a copy_to_user()... (and same for the memcmp...)

I just came up with that usercopy doesn't check the buffer is valid when zeroing happens. I mean if the buffer is wrong address pointing other kernel objects or user space address, is it possible for zeroing to overwrite the address ?

Quoted 17 lines
Quoted 17 lines
Quoted 7 lines
lib/test_user_copy.c +2 -0
       ret |= test(!copy_from_user(bad_usermem, (char __user *)kmem,
                                   PAGE_SIZE),
                   "illegal reversed copy_from_user passed");
+       ret |= test(memcmp(zerokmem, bad_usermem, PAGE_SIZE),
+                   "zeroing failure for illegal reversed copy_from_user");
       ret |= test(!copy_to_user((char __user *)kmem, kmem + PAGE_SIZE,

lib/test_user_copy.c static int __init test_user_copy_init(void) · line 101

Quoted 10 lines
lib/test_user_copy.c +3 -0
                                 PAGE_SIZE),
                   "illegal all-kernel copy_to_user passed");
       ret |= test(!copy_to_user((char __user *)kmem, bad_usermem,
                                 PAGE_SIZE),
                   "illegal reversed copy_to_user passed");
+       memset(kmem, 0x5A, PAGE_SIZE);
       ret |= test(!get_user(value, (unsigned long __user *)kmem),
                   "illegal get_user passed");
+       ret |= test(memcmp(zerokmem, kmem, sizeof(value)),
+                   "zeroing failure for illegal get_user");

Actually on my x86_64 (qemu), this testcase fails.
The generic get_user has zeroing but the one of arch x86 does not. Do we need to propagate zeroing to the other arch specific get_user code ?

Quoted 26 lines
Quoted 7 lines
Quoted 7 lines
lib/test_user_copy.c +1 -0
       ret |= test(!put_user(value, (unsigned long __user *)kmem),
                   "illegal put_user passed");
 
       vm_munmap(user_addr, PAGE_SIZE * 2);
       kfree(kmem);
+       kfree(zerokmem);
 
Quoted 7 lines
Quoted 5 lines
lib/test_user_copy.c +0 -1
       if (ret == 0) {
               pr_info("tests passed.\n");
--

2.7.4

Can you respin this?

On second thought, don't worry about a respin, I had to adjust the bad copy_from_user() that was already in there (which fails under SMAP/PAN anyway). I'll clean this up and add it to the tree.

Thanks!

-Kees

Signature · 2 lines
Kees Cook
Pixel Security
#5 lore raw
Quoted 56 lines · Hoeun Ryu
Quoted 43 lines · Kees Cook
Quoted 40 lines · Kees Cook
Quoted 38 lines · Hoeun Ryu

In the hardend usercopy, the destination buffer will be zeroed if copy_from_user/get_user fails. This patch adds testcases for it. The destination buffer is set with non-zero value before illegal copy_from_user/get_user is executed and the buffer is compared to zero after usercopy is done.

---
lib/test_user_copy.c | 17 +++++++++++++++++

1 file changed, 17 insertions(+)
lib/test_user_copy.c +7 -0
index 0ecef3e..54bd898 100644
@@ -41,11 +41,18 @@ static int __init test_user_copy_init(void)
       char *bad_usermem;
       unsigned long user_addr;
       unsigned long value = 0x5A;
+       char *zerokmem;
 
       kmem = kmalloc(PAGE_SIZE * 2, GFP_KERNEL);
       if (!kmem)
               return -ENOMEM;
 
+       zerokmem = kzalloc(PAGE_SIZE * 2, GFP_KERNEL);
+       if (!zerokmem) {
+               kfree(kmem);
+               return -ENOMEM;
+       }
+
       user_addr = vm_mmap(NULL, 0, PAGE_SIZE * 2,
                           PROT_READ | PROT_WRITE | PROT_EXEC,
                           MAP_ANONYMOUS | MAP_PRIVATE, 0);
@@ -69,25 +76,35 @@ static int __init test_user_copy_init(void)
                   "legitimate put_user failed");
 
Quoted 12 lines
Quoted 9 lines

lib/test_user_copy.c static int __init test_user_copy_init(void) · line 85

Quoted 8 lines
lib/test_user_copy.c +4 -0
       /* Invalid usage: none of these should succeed. */
+       memset(kmem, 0x5A, PAGE_SIZE);
       ret |= test(!copy_from_user(kmem, (char __user *)(kmem + PAGE_SIZE),
                                   PAGE_SIZE),
                   "illegal all-kernel copy_from_user passed");
+       ret |= test(memcmp(zerokmem, kmem, PAGE_SIZE),
+                   "zeroing failure for illegal all-kernel copy_from_user");
+       memset(bad_usermem, 0x5A, PAGE_SIZE);
Quoted 3 lines

Oh, actually, ha-ha: this isn't legal: it's a direct copy from kernel to userspace. :) This needs a copy_to_user()... (and same for the memcmp...)

Quoted 1 line

I just came up with that usercopy doesn't check the buffer is valid when zeroing happens. I mean if the buffer is wrong address pointing other kernel objects or user space address, is it possible for zeroing to overwrite the address ?

The overwrite happening even when the address is "wrong" seems like a bug to me, but it's sort of already too late (a bad kernel address would have already been a target for a userspace copy), but if something has gone really wrong (i.e. attacker doesn't have control over the source buffer) this does give a "write 0" primitive.

Mark Rutland noticed some order-of-operations issues here too, and his solution is pretty straight forward: move the checks outside the failure path. If the kernel target is demonstrably bad, then the process will be killed before the write 0 happens. (In the non-const case at least...)

(Oh, btw, I just noticed that x86's copy_from_user() already does the check before _copy_from_user() can do the memset, so x86 is already "ok" in this regard.)

Quoted 6 lines
Quoted 2 lines
Quoted 2 lines

lib/test_user_copy.c static int __init test_user_copy_init(void) · line 101

Quoted 2 lines
lib/test_user_copy.c +2 -0
+       ret |= test(memcmp(zerokmem, kmem, sizeof(value)),
+                   "zeroing failure for illegal get_user");

Actually on my x86_64 (qemu), this testcase fails.
The generic get_user has zeroing but the one of arch x86 does not. Do we need to propagate zeroing to the other arch specific get_user code ?

Hm, this didn't fail for me on x86 nor arm. Or, at least, my updated test doesn't fail:

       value = 0x5A;
       ret |= test(!get_user(value, (unsigned long __user *)kmem),
                   "illegal get_user passed");
       ret |= test(value != 0, "zeroing failure for illegal get_user");

I see the zeroing in the x86 uaccess.h, though it's a bit obfuscated:

#define get_user(x, ptr)                                                \
({                                                                      \
        int __ret_gu;                                                   \
        register __inttype(*(ptr)) __val_gu asm("%"_ASM_DX);            \
        register void *__sp asm(_ASM_SP);                               \
        __chk_user_ptr(ptr);                                            \
        might_fault();                                                  \
        asm volatile("call __get_user_%P4"                              \
                     : "=a" (__ret_gu), "=r" (__val_gu), "+r" (__sp)    \
                     : "0" (ptr), "i" (sizeof(*(ptr))));                \
        (x) = (__force __typeof__(*(ptr))) __val_gu;                    \
        __builtin_expect(__ret_gu, 0);                                  \

})

__ret_gu is the 0 or -EFAULT (from the __get_user_* assembly), and x is set unconditionally to __val_gu, which gets zero-set by the same assembly.

Regardless, I'll expand the tests to check all get_user() sizes...

-Kees

Signature · 2 lines
Kees Cook
Pixel Security
author
#6 lore raw
Quoted 109 lines · Kees Cook
Quoted 58 lines · Hoeun Ryu
Quoted 43 lines
Quoted 43 lines · Kees Cook
Quoted 40 lines · Kees Cook

On Sat, Feb 11, 2017 at 10:13 PM, Hoeun Ryu <[email protected]> wrote:
In the hardend usercopy, the destination buffer will be zeroed if copy_from_user/get_user fails. This patch adds testcases for it. The destination buffer is set with non-zero value before illegal copy_from_user/get_user is executed and the buffer is compared to zero after usercopy is done.

---
lib/test_user_copy.c | 17 +++++++++++++++++

1 file changed, 17 insertions(+)
lib/test_user_copy.c +7 -0
index 0ecef3e..54bd898 100644
@@ -41,11 +41,18 @@ static int __init test_user_copy_init(void)
      char *bad_usermem;
      unsigned long user_addr;
      unsigned long value = 0x5A;
+       char *zerokmem;
 
      kmem = kmalloc(PAGE_SIZE * 2, GFP_KERNEL);
      if (!kmem)
              return -ENOMEM;
 
+       zerokmem = kzalloc(PAGE_SIZE * 2, GFP_KERNEL);
+       if (!zerokmem) {
+               kfree(kmem);
+               return -ENOMEM;
+       }
+
      user_addr = vm_mmap(NULL, 0, PAGE_SIZE * 2,
                          PROT_READ | PROT_WRITE | PROT_EXEC,
                          MAP_ANONYMOUS | MAP_PRIVATE, 0);
@@ -69,25 +76,35 @@ static int __init test_user_copy_init(void)
                  "legitimate put_user failed");
 
Quoted 12 lines
Quoted 9 lines

lib/test_user_copy.c static int __init test_user_copy_init(void) · line 85

Quoted 8 lines
lib/test_user_copy.c +4 -0
      /* Invalid usage: none of these should succeed. */
+       memset(kmem, 0x5A, PAGE_SIZE);
      ret |= test(!copy_from_user(kmem, (char __user *)(kmem + PAGE_SIZE),
                                  PAGE_SIZE),
                  "illegal all-kernel copy_from_user passed");
+       ret |= test(memcmp(zerokmem, kmem, PAGE_SIZE),
+                   "zeroing failure for illegal all-kernel copy_from_user");
+       memset(bad_usermem, 0x5A, PAGE_SIZE);
Quoted 3 lines

Oh, actually, ha-ha: this isn't legal: it's a direct copy from kernel to userspace. :) This needs a copy_to_user()... (and same for the memcmp...)

Quoted 1 line

I just came up with that usercopy doesn't check the buffer is valid when zeroing happens. I mean if the buffer is wrong address pointing other kernel objects or user space address, is it possible for zeroing to overwrite the address ?

The overwrite happening even when the address is "wrong" seems like a bug to me, but it's sort of already too late (a bad kernel address would have already been a target for a userspace copy), but if something has gone really wrong (i.e. attacker doesn't have control over the source buffer) this does give a "write 0" primitive.

Mark Rutland noticed some order-of-operations issues here too, and his solution is pretty straight forward: move the checks outside the failure path. If the kernel target is demonstrably bad, then the process will be killed before the write 0 happens. (In the non-const case at least...)

(Oh, btw, I just noticed that x86's copy_from_user() already does the check before _copy_from_user() can do the memset, so x86 is already "ok" in this regard.)

Quoted 6 lines
Quoted 2 lines
Quoted 2 lines

lib/test_user_copy.c static int __init test_user_copy_init(void) · line 101

Quoted 2 lines
lib/test_user_copy.c +2 -0
+       ret |= test(memcmp(zerokmem, kmem, sizeof(value)),
+                   "zeroing failure for illegal get_user");

Actually on my x86_64 (qemu), this testcase fails.
The generic get_user has zeroing but the one of arch x86 does not. Do we need to propagate zeroing to the other arch specific get_user code ?

Hm, this didn't fail for me on x86 nor arm. Or, at least, my updated test doesn't fail:

      value = 0x5A;
      ret |= test(!get_user(value, (unsigned long __user *)kmem),
                  "illegal get_user passed");
      ret |= test(value != 0, "zeroing failure for illegal get_user");

I see the zeroing in the x86 uaccess.h, though it's a bit obfuscated:

#define get_user(x, ptr) \

({                                                                      \
       int __ret_gu;                                                   \
       register __inttype(*(ptr)) __val_gu asm("%"_ASM_DX);            \
       register void *__sp asm(_ASM_SP);                               \
       __chk_user_ptr(ptr);                                            \
       might_fault();                                                  \
       asm volatile("call __get_user_%P4"                              \
                    : "=a" (__ret_gu), "=r" (__val_gu), "+r" (__sp)    \
                    : "0" (ptr), "i" (sizeof(*(ptr))));                \
       (x) = (__force __typeof__(*(ptr))) __val_gu;                    \
       __builtin_expect(__ret_gu, 0);                                  \
})
Quoted 7 lines

__ret_gu is the 0 or -EFAULT (from the __get_user_* assembly), and x is set unconditionally to __val_gu, which gets zero-set by the same assembly.

Regardless, I'll expand the tests to check all get_user() sizes...

-Kees

Thank you for your detailed explanations.

Quoted 3 lines
Signature · 2 lines
Kees Cook
Pixel Security
#7 lore raw
In reply to Kees Cook
Quoted 38 lines · Kees Cook
Quoted 20 lines · Hoeun Ryu
Quoted 7 lines · Kees Cook
Quoted 6 lines · Kees Cook
Quoted 5 lines · Hoeun Ryu
lib/test_user_copy.c +0 -0
@@ -69,25 +76,35 @@ static int __init test_user_copy_init(void)
                   "legitimate put_user failed");
 
Quoted 12 lines
Quoted 9 lines

lib/test_user_copy.c static int __init test_user_copy_init(void) · line 85

Quoted 8 lines
lib/test_user_copy.c +4 -0
       /* Invalid usage: none of these should succeed. */
+       memset(kmem, 0x5A, PAGE_SIZE);
       ret |= test(!copy_from_user(kmem, (char __user *)(kmem + PAGE_SIZE),
                                   PAGE_SIZE),
                   "illegal all-kernel copy_from_user passed");
+       ret |= test(memcmp(zerokmem, kmem, PAGE_SIZE),
+                   "zeroing failure for illegal all-kernel copy_from_user");
+       memset(bad_usermem, 0x5A, PAGE_SIZE);
Quoted 3 lines

Oh, actually, ha-ha: this isn't legal: it's a direct copy from kernel to userspace. :) This needs a copy_to_user()... (and same for the memcmp...)

Quoted 4 lines

I just came up with that usercopy doesn't check the buffer is valid when zeroing happens. I mean if the buffer is wrong address pointing other kernel objects or user space address, is it possible for zeroing to overwrite the address ?

The overwrite happening even when the address is "wrong" seems like a bug to me, but it's sort of already too late (a bad kernel address would have already been a target for a userspace copy), but if something has gone really wrong (i.e. attacker doesn't have control over the source buffer) this does give a "write 0" primitive.

Mark Rutland noticed some order-of-operations issues here too, and his solution is pretty straight forward: move the checks outside the failure path. If the kernel target is demonstrably bad, then the process will be killed before the write 0 happens. (In the non-const case at least...)

Quoted 3 lines

(Oh, btw, I just noticed that x86's copy_from_user() already does the check before _copy_from_user() can do the memset, so x86 is already "ok" in this regard.)

FWIW, the patch making arm64 do the check first is queued [1], and should be in v4.11.

Doing the same for other architectures would be good.

Mark.

[1] https://git.kernel.org/cgit/linux/kernel/git/arm64/linux.git/commit/?h=for-next/core&id=76624175dcae6f7a808d345c0592908a15ca6975

#8 lore raw
Quoted 39 lines · Mark Rutland
Quoted 38 lines · Kees Cook
Quoted 20 lines · Hoeun Ryu
Quoted 7 lines · Kees Cook
Quoted 6 lines · Kees Cook
Quoted 5 lines · Hoeun Ryu
lib/test_user_copy.c +0 -0
@@ -69,25 +76,35 @@ static int __init test_user_copy_init(void)
                   "legitimate put_user failed");
 
Quoted 12 lines
Quoted 9 lines

lib/test_user_copy.c static int __init test_user_copy_init(void) · line 85

Quoted 8 lines
lib/test_user_copy.c +4 -0
       /* Invalid usage: none of these should succeed. */
+       memset(kmem, 0x5A, PAGE_SIZE);
       ret |= test(!copy_from_user(kmem, (char __user *)(kmem + PAGE_SIZE),
                                   PAGE_SIZE),
                   "illegal all-kernel copy_from_user passed");
+       ret |= test(memcmp(zerokmem, kmem, PAGE_SIZE),
+                   "zeroing failure for illegal all-kernel copy_from_user");
+       memset(bad_usermem, 0x5A, PAGE_SIZE);
Quoted 3 lines

Oh, actually, ha-ha: this isn't legal: it's a direct copy from kernel to userspace. :) This needs a copy_to_user()... (and same for the memcmp...)

Quoted 4 lines

I just came up with that usercopy doesn't check the buffer is valid when zeroing happens. I mean if the buffer is wrong address pointing other kernel objects or user space address, is it possible for zeroing to overwrite the address ?

The overwrite happening even when the address is "wrong" seems like a bug to me, but it's sort of already too late (a bad kernel address would have already been a target for a userspace copy), but if something has gone really wrong (i.e. attacker doesn't have control over the source buffer) this does give a "write 0" primitive.

Mark Rutland noticed some order-of-operations issues here too, and his solution is pretty straight forward: move the checks outside the failure path. If the kernel target is demonstrably bad, then the process will be killed before the write 0 happens. (In the non-const case at least...)

Quoted 8 lines
Quoted 3 lines

(Oh, btw, I just noticed that x86's copy_from_user() already does the check before _copy_from_user() can do the memset, so x86 is already "ok" in this regard.)

FWIW, the patch making arm64 do the check first is queued [1], and should be in v4.11.

Doing the same for other architectures would be good.

It looks like x86 is already ok (kind of by accident). ARM needs fixing. I think it'd be best to model it after arm64's approach.

-Kees

Signature · 2 lines
Kees Cook
Pixel Security