Skip to contentSkip to conversation

usercopy: Add tests for all get_user() sizes

PATCH Superseded Kees Cook 3 participants 5 messages Feb 14, 2017 – Feb 21, 2017 Library code

v1 of 2 Superseded Latest is v2 →

lore
Share & tools
lore

Kees Cook

author
#0 lore raw

PATCH 1/1 usercopy: Add tests for all get_user() sizes

The existing test was only exercising native unsigned long size get_user(). For completeness, we should check all sizes.

---
 lib/test_user_copy.c | 45 ++++++++++++++++++++++++++++++++++-----------
 1 file changed, 34 insertions(+), 11 deletions(-)
lib/test_user_copy.c +34 -11
index ac3a60ba9331..49569125b7c5 100644
@@ -40,8 +40,11 @@ static int __init test_user_copy_init(void)
 	char __user *usermem;
 	char *bad_usermem;
 	unsigned long user_addr;
-	unsigned long value = 0x5A;
 	char *zerokmem;
+	u8 val_u8;
+	u16 val_u16;
+	u32 val_u32;
+	u64 val_u64;
 
 	kmem = kmalloc(PAGE_SIZE * 2, GFP_KERNEL);
 	if (!kmem)
@@ -72,10 +75,20 @@ static int __init test_user_copy_init(void)
 		    "legitimate copy_from_user failed");
 	ret |= test(copy_to_user(usermem, kmem, PAGE_SIZE),
 		    "legitimate copy_to_user failed");
-	ret |= test(get_user(value, (unsigned long __user *)usermem),
-		    "legitimate get_user failed");
-	ret |= test(put_user(value, (unsigned long __user *)usermem),
-		    "legitimate put_user failed");
+
+#define test_legit(size)						  \
+	do {								  \
+		ret |= test(get_user(val_##size, (size __user *)usermem), \
+		    "legitimate get_user (" #size ") failed");		  \
+		ret |= test(put_user(val_##size, (size __user *)usermem), \
+		    "legitimate put_user (" #size ") failed");		  \
+	} while (0)
+
+	test_legit(u8);
+	test_legit(u16);
+	test_legit(u32);
+	test_legit(u64);
+#undef test_legit
 
 	/*
 	 * Invalid usage: none of these copies should succeed.
@@ -112,12 +125,22 @@ static int __init test_user_copy_init(void)
 				  PAGE_SIZE),
 		    "illegal reversed copy_to_user passed");
 
-	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");
-	ret |= test(!put_user(value, (unsigned long __user *)kmem),
-		    "illegal put_user passed");
+#define test_illegal(size, check)					    \
+	do {								    \
+		val_##size = (check);					    \
+		ret |= test(!get_user(val_##size, (size __user *)kmem),	    \
+		    "illegal get_user (" #size ") passed");		    \
+		ret |= test(val_##size != (size)0,			    \
+		    "zeroing failure for illegal get_user (" #size ")");    \
+		ret |= test(!put_user(val_##size, (size __user *)kmem),	    \
+		    "illegal put_user (" #size ") passed");		    \
+	} while (0)
+
+	test_illegal(u8,  0x5a);
+	test_illegal(u16, 0x5a5b);
+	test_illegal(u32, 0x5a5b5c5d);
+	test_illegal(u64, 0x5a5b5c5d6a6b6c6d);
+#undef test_illegal
 
 	vm_munmap(user_addr, PAGE_SIZE * 2);
 out_zerokmem:
Signature · 6 lines
2.7.4


-- 
Kees Cook
Pixel Security
#1 lore raw
Quoted 37 lines · Kees Cook

The existing test was only exercising native unsigned long size get_user(). For completeness, we should check all sizes.

---
 lib/test_user_copy.c | 45 ++++++++++++++++++++++++++++++++++-----------
 1 file changed, 34 insertions(+), 11 deletions(-)
lib/test_user_copy.c +8 -5
index ac3a60ba9331..49569125b7c5 100644
@@ -40,8 +40,11 @@ static int __init test_user_copy_init(void)
        char __user *usermem;
        char *bad_usermem;
        unsigned long user_addr;
-       unsigned long value = 0x5A;
        char *zerokmem;
+       u8 val_u8;
+       u16 val_u16;
+       u32 val_u32;
+       u64 val_u64;
 
        kmem = kmalloc(PAGE_SIZE * 2, GFP_KERNEL);
        if (!kmem)
@@ -72,10 +75,20 @@ static int __init test_user_copy_init(void)
                    "legitimate copy_from_user failed");
        ret |= test(copy_to_user(usermem, kmem, PAGE_SIZE),
                    "legitimate copy_to_user failed");
-       ret |= test(get_user(value, (unsigned long __user *)usermem),
-                   "legitimate get_user failed");
-       ret |= test(put_user(value, (unsigned long __user *)usermem),
-                   "legitimate put_user failed");
+
+#define test_legit(size)                                                 \
+       do {                                                              \
+               ret |= test(get_user(val_##size, (size __user *)usermem), \

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

Quoted 10 lines
lib/test_user_copy.c +10 -0
+                   "legitimate get_user (" #size ") failed");            \
+               ret |= test(put_user(val_##size, (size __user *)usermem), \
+                   "legitimate put_user (" #size ") failed");            \
+       } while (0)
+
+       test_legit(u8);
+       test_legit(u16);
+       test_legit(u32);
+       test_legit(u64);
+#undef test_legit

ERROR: "__get_user_bad" [lib/test_user_copy.ko] undefined!

http://kisskb.ellerman.id.au/kisskb/buildresult/12936728/

So 64-bit get_user() support is mandatory now?

Gr{oetje,eeting}s,

Geert

--
Geert Uytterhoeven -- There's lots of Linux beyond ia32 -- [email protected]

In personal conversations with technical people, I call myself a hacker. But when I'm talking to journalists I just say "programmer" or something like that.
-- Linus Torvalds

author
#2 lore raw
Quoted 51 lines · Geert Uytterhoeven
Quoted 37 lines · Kees Cook

The existing test was only exercising native unsigned long size get_user(). For completeness, we should check all sizes.

---
 lib/test_user_copy.c | 45 ++++++++++++++++++++++++++++++++++-----------
 1 file changed, 34 insertions(+), 11 deletions(-)
lib/test_user_copy.c +8 -5
index ac3a60ba9331..49569125b7c5 100644
@@ -40,8 +40,11 @@ static int __init test_user_copy_init(void)
        char __user *usermem;
        char *bad_usermem;
        unsigned long user_addr;
-       unsigned long value = 0x5A;
        char *zerokmem;
+       u8 val_u8;
+       u16 val_u16;
+       u32 val_u32;
+       u64 val_u64;
 
        kmem = kmalloc(PAGE_SIZE * 2, GFP_KERNEL);
        if (!kmem)
@@ -72,10 +75,20 @@ static int __init test_user_copy_init(void)
                    "legitimate copy_from_user failed");
        ret |= test(copy_to_user(usermem, kmem, PAGE_SIZE),
                    "legitimate copy_to_user failed");
-       ret |= test(get_user(value, (unsigned long __user *)usermem),
-                   "legitimate get_user failed");
-       ret |= test(put_user(value, (unsigned long __user *)usermem),
-                   "legitimate put_user failed");
+
+#define test_legit(size)                                                 \
+       do {                                                              \
+               ret |= test(get_user(val_##size, (size __user *)usermem), \

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

Quoted 10 lines
lib/test_user_copy.c +10 -0
+                   "legitimate get_user (" #size ") failed");            \
+               ret |= test(put_user(val_##size, (size __user *)usermem), \
+                   "legitimate put_user (" #size ") failed");            \
+       } while (0)
+
+       test_legit(u8);
+       test_legit(u16);
+       test_legit(u32);
+       test_legit(u64);
+#undef test_legit

ERROR: "__get_user_bad" [lib/test_user_copy.ko] undefined!

Quoted 3 lines

http://kisskb.ellerman.id.au/kisskb/buildresult/12936728/

So 64-bit get_user() support is mandatory now?

That's not my intention. :) In my sampling of architectures, I missed a couple 32-bit archs that don't support 64-bit getuser(). I'm not sure how to correctly write these tests, though, since it seems rather ad-hoc. e.g. m68k has 64-bit getuser() commented out due to an old gcc bug...

Should I just universally skip 64-bit getuser on 32-bit archs?

-Kees

Signature · 2 lines
Kees Cook
Pixel Security
#3 lore raw
Quoted 57 lines · Kees Cook
Quoted 51 lines · Geert Uytterhoeven
Quoted 37 lines · Kees Cook

The existing test was only exercising native unsigned long size get_user(). For completeness, we should check all sizes.

---
 lib/test_user_copy.c | 45 ++++++++++++++++++++++++++++++++++-----------
 1 file changed, 34 insertions(+), 11 deletions(-)
lib/test_user_copy.c +8 -5
index ac3a60ba9331..49569125b7c5 100644
@@ -40,8 +40,11 @@ static int __init test_user_copy_init(void)
        char __user *usermem;
        char *bad_usermem;
        unsigned long user_addr;
-       unsigned long value = 0x5A;
        char *zerokmem;
+       u8 val_u8;
+       u16 val_u16;
+       u32 val_u32;
+       u64 val_u64;
 
        kmem = kmalloc(PAGE_SIZE * 2, GFP_KERNEL);
        if (!kmem)
@@ -72,10 +75,20 @@ static int __init test_user_copy_init(void)
                    "legitimate copy_from_user failed");
        ret |= test(copy_to_user(usermem, kmem, PAGE_SIZE),
                    "legitimate copy_to_user failed");
-       ret |= test(get_user(value, (unsigned long __user *)usermem),
-                   "legitimate get_user failed");
-       ret |= test(put_user(value, (unsigned long __user *)usermem),
-                   "legitimate put_user failed");
+
+#define test_legit(size)                                                 \
+       do {                                                              \
+               ret |= test(get_user(val_##size, (size __user *)usermem), \

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

Quoted 10 lines
lib/test_user_copy.c +10 -0
+                   "legitimate get_user (" #size ") failed");            \
+               ret |= test(put_user(val_##size, (size __user *)usermem), \
+                   "legitimate put_user (" #size ") failed");            \
+       } while (0)
+
+       test_legit(u8);
+       test_legit(u16);
+       test_legit(u32);
+       test_legit(u64);
+#undef test_legit

ERROR: "__get_user_bad" [lib/test_user_copy.ko] undefined!

Quoted 3 lines

http://kisskb.ellerman.id.au/kisskb/buildresult/12936728/

So 64-bit get_user() support is mandatory now?

Quoted 7 lines

That's not my intention. :) In my sampling of architectures, I missed a couple 32-bit archs that don't support 64-bit getuser(). I'm not sure how to correctly write these tests, though, since it seems rather ad-hoc. e.g. m68k has 64-bit getuser() commented out due to an old gcc bug...

Should I just universally skip 64-bit getuser on 32-bit archs?

I think you should just make it opt-in for 32-bit arches.

cheers

author
#4 lore raw
Quoted 65 lines · Michael Ellerman
Quoted 63 lines · Kees Cook
Quoted 51 lines · Geert Uytterhoeven
Quoted 37 lines · Kees Cook

The existing test was only exercising native unsigned long size get_user(). For completeness, we should check all sizes.

---
 lib/test_user_copy.c | 45 ++++++++++++++++++++++++++++++++++-----------
 1 file changed, 34 insertions(+), 11 deletions(-)
lib/test_user_copy.c +8 -5
index ac3a60ba9331..49569125b7c5 100644
@@ -40,8 +40,11 @@ static int __init test_user_copy_init(void)
        char __user *usermem;
        char *bad_usermem;
        unsigned long user_addr;
-       unsigned long value = 0x5A;
        char *zerokmem;
+       u8 val_u8;
+       u16 val_u16;
+       u32 val_u32;
+       u64 val_u64;
 
        kmem = kmalloc(PAGE_SIZE * 2, GFP_KERNEL);
        if (!kmem)
@@ -72,10 +75,20 @@ static int __init test_user_copy_init(void)
                    "legitimate copy_from_user failed");
        ret |= test(copy_to_user(usermem, kmem, PAGE_SIZE),
                    "legitimate copy_to_user failed");
-       ret |= test(get_user(value, (unsigned long __user *)usermem),
-                   "legitimate get_user failed");
-       ret |= test(put_user(value, (unsigned long __user *)usermem),
-                   "legitimate put_user failed");
+
+#define test_legit(size)                                                 \
+       do {                                                              \
+               ret |= test(get_user(val_##size, (size __user *)usermem), \

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

Quoted 10 lines
lib/test_user_copy.c +10 -0
+                   "legitimate get_user (" #size ") failed");            \
+               ret |= test(put_user(val_##size, (size __user *)usermem), \
+                   "legitimate put_user (" #size ") failed");            \
+       } while (0)
+
+       test_legit(u8);
+       test_legit(u16);
+       test_legit(u32);
+       test_legit(u64);
+#undef test_legit

ERROR: "__get_user_bad" [lib/test_user_copy.ko] undefined!

Quoted 3 lines

http://kisskb.ellerman.id.au/kisskb/buildresult/12936728/

So 64-bit get_user() support is mandatory now?

That's not my intention. :) In my sampling of architectures, I missed a couple 32-bit archs that don't support 64-bit getuser(). I'm not sure how to correctly write these tests, though, since it seems rather ad-hoc. e.g. m68k has 64-bit getuser() commented out due to an old gcc bug...

Quoted 3 lines
Quoted 1 line

Should I just universally skip 64-bit getuser on 32-bit archs?

I think you should just make it opt-in for 32-bit arches.

I did this opt-out instead and manually inspected all the architectures that should skip the test. (That way future 32-bit architectures will get noticed if they don't support 64-bit get_user().)

-Kees

Signature · 2 lines
Kees Cook
Pixel Security