usercopy: add testcases to check zeroing on failure of usercopy
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
@@ -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
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.
Signed-off-by Hoeun Ryu <[email protected]>
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
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.
Signed-off-by Hoeun Ryu <[email protected]>--- lib/test_user_copy.c | 17 +++++++++++++++++ 1 file changed, 17 insertions(+)lib/test_user_copy.c +7
-0@@ -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
-1ret |=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
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.
Signed-off-by Hoeun Ryu <[email protected]>--- lib/test_user_copy.c | 17 +++++++++++++++++ 1 file changed, 17 insertions(+)lib/test_user_copy.c +7
-0@@ -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
-0ret |=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
-1if (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
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.
Signed-off-by Hoeun Ryu <[email protected]>---
lib/test_user_copy.c| 17 +++++++++++++++++1 file changed, 17 insertions(+)lib/test_user_copy.c +7
-0@@ -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
-0ret |=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
-0PAGE_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
-0ret |=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
-1if (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
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.
Signed-off-by Hoeun Ryu <[email protected]>---
lib/test_user_copy.c| 17 +++++++++++++++++1 file changed, 17 insertions(+)lib/test_user_copy.c +7
-0@@ -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 genericget_userhas zeroing but the one of arch x86 does not. Do we need to propagate zeroing to the other arch specificget_usercode ?
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
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.Signed-off-by Hoeun Ryu <[email protected]>---
lib/test_user_copy.c| 17 +++++++++++++++++1 file changed, 17 insertions(+)lib/test_user_copy.c +7
-0@@ -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 genericget_userhas zeroing but the one of arch x86 does not. Do we need to propagate zeroing to the other arch specificget_usercode ?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_guis 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
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.
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