usercopy: Remove HARDENED_USERCOPY_PAGESPAN
PATCH 1/1 usercopy: Remove HARDENED_USERCOPY_PAGESPAN
This feature continues to cause more problems than it solves[1]. Its intention was to check the bounds of page-allocator allocations by using __GFP_COMP, for which we would need to find all missing __GFP_COMP markings. This work has been on hold and there is an argument[2] that such markings are not even the correct signal for checking for same-allocation pages. Instead of depending on BROKEN, this just removes it entirely. It can be trivially reverted if/when a better solution for tracking page allocator sizes is found.
[1] https://www.mail-archive.com/[email protected]/msg37479.html
[2] https://lkml.kernel.org/r/[email protected]
--- mm/usercopy.c | 67 ------------------------------------------------ security/Kconfig | 11 -------- 2 files changed, 78 deletions(-)
mm/usercopy.c +0 -67
@@ -159,70 +159,6 @@ static inline void check_bogus_address(const unsigned long ptr, unsigned long n,usercopy_abort ("null address" ,NULL , to_user, ptr, n); } -/* Checks for allocs that are marked in some way as spanning multiple pages. */ -static inline void check_page_span (const void *ptr,unsigned long n, -struct page *page,bool to_user) -{ -#ifdef CONFIG_HARDENED_USERCOPY_PAGESPAN -const void *end = ptr + n -1 ; -struct page *endpage; -bool is_reserved, is_cma; - -/* -* Sometimes the kernel data regions are not marked Reserved (see -* check below). And sometimes [_sdata,_edata) does not cover -* rodata and/or bss, so check each range explicitly. -*/ - -/* Allow reads of kernel rodata region (if not marked as Reserved). */ -if (ptr >= (const void *)__start_rodata && - end <= (const void *)__end_rodata) { -if (!to_user) -usercopy_abort ("rodata" ,NULL , to_user,0 , n); -return ; - } - -/* Allow kernel data region (if not marked as Reserved). */ -if (ptr >= (const void *)_sdata && end <= (const void *)_edata) -return ; - -/* Allow kernel bss region (if not marked as Reserved). */ -if (ptr >= (const void *)__bss_start && - end <= (const void *)__bss_stop) -return ; - -/* Is the object wholly within one base page? */ -if (likely (((unsigned long )ptr & (unsigned long )PAGE_MASK ) == - ((unsigned long )end & (unsigned long )PAGE_MASK ))) -return ; - -/* Allow if fully inside the same compound (__GFP_COMP) page. */ - endpage =virt_to_head_page (end); -if (likely (endpage == page)) -return ; - -/* -* Reject if range is entirely either Reserved (i.e. special or -* device memory), or CMA. Otherwise, reject since the object spans -* several independently allocated pages. -*/ - is_reserved =PageReserved (page); - is_cma =is_migrate_cma_page (page); -if (!is_reserved && !is_cma) -usercopy_abort ("spans multiple pages" ,NULL , to_user,0 , n); - -for (ptr +=PAGE_SIZE ; ptr <= end; ptr +=PAGE_SIZE ) { - page =virt_to_head_page (ptr); -if (is_reserved && !PageReserved (page)) -usercopy_abort ("spans Reserved and non-Reserved pages" , -NULL , to_user,0 , n); -if (is_cma && !is_migrate_cma_page (page)) -usercopy_abort ("spans CMA and non-CMA pages" ,NULL , - to_user,0 , n); - } -#endif -} -static inline void check_heap_object (const void *ptr,unsigned long n,bool to_user) {
@@ -236,9 +172,6 @@ static inline void check_heap_object(const void *ptr, unsigned long n,if (PageSlab (page)) {/* Check slab allocator for flags and size. */ __check_heap_object (ptr, n, page, to_user); - }else { -/* Verify object does not incorrectly span multiple pages. */ -check_page_span (ptr, n, page, to_user); } }
security/Kconfig +0 -11
@@ -176,17 +176,6 @@ config HARDENED_USERCOPY_FALLBACK Booting with "slab_common.usercopy_fallback=Y/N" can change this setting. -config HARDENED_USERCOPY_PAGESPAN - bool "Refuse to copy allocations that span multiple pages" - depends on HARDENED_USERCOPY - depends on EXPERT - help - When a multi-page allocation is done without __GFP_COMP, - hardened usercopy will reject attempts to copy it. There are, - however, several cases of this in the kernel that have not all - been removed. This config is intended to be used only while - trying to find such users. - config FORTIFY_SOURCE bool "Harden common str/mem functions against buffer overflows" depends on ARCH_HAS_FORTIFY_SOURCE
Signature · 5 lines
2.17.1 -- Kees Cook
Quoted 49 lines · Kees Cook
This feature continues to cause more problems than it solves[1]. Its intention was to check the bounds of page-allocator allocations by using
__GFP_COMP, for which we would need to find all missing__GFP_COMPmarkings. This work has been on hold and there is an argument[2] that such markings are not even the correct signal for checking for same-allocation pages. Instead of depending on BROKEN, this just removes it entirely. It can be trivially reverted if/when a better solution for tracking page allocator sizes is found.[1] https://www.mail-archive.com/[email protected]/msg37479.html
[2] https://lkml.kernel.org/r/[email protected]Suggested-by Eric Biggers <[email protected]>Signed-off-by Kees Cook <[email protected]>--- mm/usercopy.c | 67 ------------------------------------------------ security/Kconfig | 11 -------- 2 files changed, 78 deletions(-)mm/usercopy.c +0
-22@@ -159,70 +159,6 @@ static inline void check_bogus_address(const unsigned long ptr, unsigned long n,usercopy_abort ("null address" ,NULL , to_user, ptr, n); } -/* Checks for allocs that are marked in some way as spanning multiple pages. */ -static inline void check_page_span (const void *ptr,unsigned long n, -struct page *page,bool to_user) -{ -#ifdef CONFIG_HARDENED_USERCOPY_PAGESPAN -const void *end = ptr + n -1 ; -struct page *endpage; -bool is_reserved, is_cma; - -/* -* Sometimes the kernel data regions are not marked Reserved (see -* check below). And sometimes [_sdata,_edata) does not cover -* rodata and/or bss, so check each range explicitly. -*/ - -/* Allow reads of kernel rodata region (if not marked as Reserved). */ -if (ptr >= (const void *)__start_rodata && - end <= (const void *)__end_rodata) { -if (!to_user) -usercopy_abort ("rodata" ,NULL , to_user,0 , n); -return ; - }
mm/usercopy.c static inline void check_bogus_address(const unsigned long ptr, unsigned long n, · line 193
Quoted 10 lines
mm/usercopy.c +0
-10- -/* Allow kernel data region (if not marked as Reserved). */ -if (ptr >= (const void *)_sdata && end <= (const void *)_edata) -return ; - -/* Allow kernel bss region (if not marked as Reserved). */ -if (ptr >= (const void *)__bss_start && - end <= (const void *)__bss_stop) -return ; -
I agree the page spanning is broken but is it worth keeping the checks against __rodata __bss etc.?
Quoted 68 lines
mm/usercopy.c +0
-35-/* Is the object wholly within one base page? */ -if (likely (((unsigned long )ptr & (unsigned long )PAGE_MASK ) == - ((unsigned long )end & (unsigned long )PAGE_MASK ))) -return ; - -/* Allow if fully inside the same compound (__GFP_COMP) page. */ - endpage =virt_to_head_page (end); -if (likely (endpage == page)) -return ; - -/* -* Reject if range is entirely either Reserved (i.e. special or -* device memory), or CMA. Otherwise, reject since the object spans -* several independently allocated pages. -*/ - is_reserved =PageReserved (page); - is_cma =is_migrate_cma_page (page); -if (!is_reserved && !is_cma) -usercopy_abort ("spans multiple pages" ,NULL , to_user,0 , n); - -for (ptr +=PAGE_SIZE ; ptr <= end; ptr +=PAGE_SIZE ) { - page =virt_to_head_page (ptr); -if (is_reserved && !PageReserved (page)) -usercopy_abort ("spans Reserved and non-Reserved pages" , -NULL , to_user,0 , n); -if (is_cma && !is_migrate_cma_page (page)) -usercopy_abort ("spans CMA and non-CMA pages" ,NULL , - to_user,0 , n); - } -#endif -} -static inline void check_heap_object (const void *ptr,unsigned long n,bool to_user) {@@ -236,9 +172,6 @@ static inline void check_heap_object(const void *ptr, unsigned long n,if (PageSlab (page)) {/* Check slab allocator for flags and size. */ __check_heap_object (ptr, n, page, to_user); - }else { -/* Verify object does not incorrectly span multiple pages. */ -check_page_span (ptr, n, page, to_user); } }security/Kconfig +0
-11@@ -176,17 +176,6 @@ config HARDENED_USERCOPY_FALLBACK Booting with "slab_common.usercopy_fallback=Y/N" can change this setting. -config HARDENED_USERCOPY_PAGESPAN - bool "Refuse to copy allocations that span multiple pages" - depends on HARDENED_USERCOPY - depends on EXPERT - help - When a multi-page allocation is done without __GFP_COMP, - hardened usercopy will reject attempts to copy it. There are, - however, several cases of this in the kernel that have not all - been removed. This config is intended to be used only while - trying to find such users. - config FORTIFY_SOURCE bool "Harden common str/mem functions against buffer overflows" depends on ARCH_HAS_FORTIFY_SOURCE
Quoted 55 lines · Laura Abbott
Quoted 54 lines · Kees Cook
This feature continues to cause more problems than it solves[1]. Its intention was to check the bounds of page-allocator allocations by using
__GFP_COMP, for which we would need to find all missing__GFP_COMPmarkings. This work has been on hold and there is an argument[2] that such markings are not even the correct signal for checking for same-allocation pages. Instead of depending on BROKEN, this just removes it entirely. It can be trivially reverted if/when a better solution for tracking page allocator sizes is found.[1] https://www.mail-archive.com/[email protected]/msg37479.html
[2] https://lkml.kernel.org/r/[email protected]Suggested-by Eric Biggers <[email protected]>Signed-off-by Kees Cook <[email protected]>--- mm/usercopy.c | 67 ------------------------------------------------ security/Kconfig | 11 -------- 2 files changed, 78 deletions(-)mm/usercopy.c +0
-28@@ -159,70 +159,6 @@ static inline void check_bogus_address(const unsigned long ptr, unsigned long n,usercopy_abort ("null address" ,NULL , to_user, ptr, n); } -/* Checks for allocs that are marked in some way as spanning multiple pages. */ -static inline void check_page_span (const void *ptr,unsigned long n, -struct page *page,bool to_user) -{ -#ifdef CONFIG_HARDENED_USERCOPY_PAGESPAN -const void *end = ptr + n -1 ; -struct page *endpage; -bool is_reserved, is_cma; - -/* -* Sometimes the kernel data regions are not marked Reserved (see -* check below). And sometimes [_sdata,_edata) does not cover -* rodata and/or bss, so check each range explicitly. -*/ - -/* Allow reads of kernel rodata region (if not marked as Reserved). */ -if (ptr >= (const void *)__start_rodata && - end <= (const void *)__end_rodata) { -if (!to_user) -usercopy_abort ("rodata" ,NULL , to_user,0 , n); -return ; - } - -/* Allow kernel data region (if not marked as Reserved). */ -if (ptr >= (const void *)_sdata && end <= (const void *)_edata) -return ; - -/* Allow kernel bss region (if not marked as Reserved). */
Quoted 8 lines
mm/usercopy.c static inline void check_bogus_address(const unsigned long ptr, unsigned long n, · line 193
Quoted 4 lines
mm/usercopy.c +0
-4-if (ptr >= (const void *)__bss_start && - end <= (const void *)__bss_stop) -return ; -I agree the page spanning is broken but is it worth keeping the checks against
__rodata__bssetc.?
They're all just white-listing later checks (except RODATA which is doing a cheap RO test which is redundant on any architecture with actual rodata...) so they don't have any value in staying without the rest of the page allocator logic.
Quoted 22 lines
Quoted 22 lines
mm/usercopy.c +0
-21-/* Is the object wholly within one base page? */ -if (likely (((unsigned long )ptr & (unsigned long )PAGE_MASK ) == - ((unsigned long )end & (unsigned long )PAGE_MASK ))) -return ; - -/* Allow if fully inside the same compound (__GFP_COMP) page. */ - endpage =virt_to_head_page (end); -if (likely (endpage == page)) -return ; - -/* -* Reject if range is entirely either Reserved (i.e. special or -* device memory), or CMA. Otherwise, reject since the object spans -* several independently allocated pages. -*/ - is_reserved =PageReserved (page); - is_cma =is_migrate_cma_page (page); -if (!is_reserved && !is_cma) -usercopy_abort ("spans multiple pages" ,NULL , to_user,0 , n); - -for (ptr +=PAGE_SIZE ; ptr <= end; ptr +=PAGE_SIZE ) {
Quoted 8 lines
mm/usercopy.c static inline void check_bogus_address(const unsigned long ptr, unsigned long n, · line 222
Quoted 8 lines
mm/usercopy.c +0
-8- page =virt_to_head_page (ptr); -if (is_reserved && !PageReserved (page)) -usercopy_abort ("spans Reserved and non-Reserved pages" , -NULL , to_user,0 , n); -if (is_cma && !is_migrate_cma_page (page)) -usercopy_abort ("spans CMA and non-CMA pages" ,NULL , - to_user,0 , n); - }
We _could_ keep the mixed CMA/reserved/neither check if we really wanted to, but that's such a corner case of a corner case, I'm not sure it's worth doing the virt_to_head_page() across the whole span to figure it out.
I really wish we had size of allocation reliably held somewhere. We'll need it for doing memory tagging of the page allocator too...
Signature · 1 line
Kees Cook
Quoted 22 lines · Kees Cook
Quoted 10 lines · Laura Abbott
Quoted 9 lines · Kees Cook
This feature continues to cause more problems than it solves[1]. Its intention was to check the bounds of page-allocator allocations by using
__GFP_COMP, for which we would need to find all missing__GFP_COMPmarkings. This work has been on hold and there is an argument[2] that such markings are not even the correct signal for checking for same-allocation pages. Instead of depending on BROKEN, this just removes it entirely. It can be trivially reverted if/when a better solution for tracking page allocator sizes is found.Quoted 5 lines
Quoted 2 lines
[1] https://www.mail-archive.com/[email protected]/msg37479.html
[2] https://lkml.kernel.org/r/[email protected]I agree the page spanning is broken but is it worth keeping the checks against
__rodata__bssetc.?They're all just white-listing later checks (except RODATA which is doing a cheap RO test which is redundant on any architecture with actual rodata...) so they don't have any value in staying without the rest of the page allocator logic.
Quoted 14 lines
Quoted 9 lines
mm/usercopy.c static inline void check_bogus_address(const unsigned long ptr, unsigned long n, · line 202
Quoted 9 lines
mm/usercopy.c +0
-9-/* Is the object wholly within one base page? */ -if (likely (((unsigned long )ptr & (unsigned long )PAGE_MASK ) == - ((unsigned long )end & (unsigned long )PAGE_MASK ))) -return ; - -/* Allow if fully inside the same compound (__GFP_COMP) page. */ - endpage =virt_to_head_page (end); -if (likely (endpage == page)) -return ;We _could_ keep the mixed CMA/reserved/neither check if we really wanted to, but that's such a corner case of a corner case, I'm not sure it's worth doing the
virt_to_head_page()across the whole span to figure it out.
I'd delete that first check, because it's a subset of the second check,
/* Is the object wholly within a single (base or compound) page? */
endpage = virt_to_head_page(end);
if (likely(endpage == page))
return;
/*
* If the start and end are more than MAX_ORDER apart, they must
* be from separate allocations
*/
if (n >= (PAGE_SIZE << MAX_ORDER))
usercopy_abort("spans too many pages", NULL, to_user, 0, n);
/*
* If neither page is compound, we can't tell if the object is
* within a single allocation or not
*/
if (!PageCompound(page) && !PageCompound(endpage))
return;Quoted 2 lines
I really wish we had size of allocation reliably held somewhere. We'll need it for doing memory tagging of the page allocator too...
I think we'll need to store those allocations in a separate data structure on the side. As far as the rest of the kernel is concerned, those struct pages belong to them once the page allocator has given them.
Quoted 38 lines · Matthew Wilcox
Quoted 22 lines · Kees Cook
Quoted 10 lines · Laura Abbott
Quoted 9 lines · Kees Cook
This feature continues to cause more problems than it solves[1]. Its intention was to check the bounds of page-allocator allocations by using
__GFP_COMP, for which we would need to find all missing__GFP_COMPmarkings. This work has been on hold and there is an argument[2] that such markings are not even the correct signal for checking for same-allocation pages. Instead of depending on BROKEN, this just removes it entirely. It can be trivially reverted if/when a better solution for tracking page allocator sizes is found.Quoted 5 lines
Quoted 2 lines
[1] https://www.mail-archive.com/[email protected]/msg37479.html
[2] https://lkml.kernel.org/r/[email protected]I agree the page spanning is broken but is it worth keeping the checks against
__rodata__bssetc.?They're all just white-listing later checks (except RODATA which is doing a cheap RO test which is redundant on any architecture with actual rodata...) so they don't have any value in staying without the rest of the page allocator logic.
Quoted 14 lines
Quoted 9 lines
mm/usercopy.c static inline void check_bogus_address(const unsigned long ptr, unsigned long n, · line 202
Quoted 9 lines
mm/usercopy.c +0
-9-/* Is the object wholly within one base page? */ -if (likely (((unsigned long )ptr & (unsigned long )PAGE_MASK ) == - ((unsigned long )end & (unsigned long )PAGE_MASK ))) -return ; - -/* Allow if fully inside the same compound (__GFP_COMP) page. */ - endpage =virt_to_head_page (end); -if (likely (endpage == page)) -return ;We _could_ keep the mixed CMA/reserved/neither check if we really wanted to, but that's such a corner case of a corner case, I'm not sure it's worth doing the
virt_to_head_page()across the whole span to figure it out.
Quoted 1 line
I'd delete that first check, because it's a subset of the second check,
It seemed easier to short-circuit with a math test before doing the slightly more expensive virt_to_head_page(end) call. Do you think that's sensible?
Quoted 20 lines
/* Is the object wholly within a single (base or compound) page? */
endpage = virt_to_head_page(end);
if (likely(endpage == page))
return;
/*
* If the start and end are more than MAX_ORDER apart, they must
* be from separate allocations
*/
if (n >= (PAGE_SIZE << MAX_ORDER))
usercopy_abort("spans too many pages", NULL, to_user, 0, n);
/*
* If neither page is compound, we can't tell if the object is
* within a single allocation or not
*/
if (!PageCompound(page) && !PageCompound(endpage))
return;Quoted 6 lines
Quoted 2 lines
I really wish we had size of allocation reliably held somewhere. We'll need it for doing memory tagging of the page allocator too...
I think we'll need to store those allocations in a separate data structure on the side. As far as the rest of the kernel is concerned, those struct pages belong to them once the page allocator has given them.
Okay, let me work up a page-type refactoring while allocation size can stay back-burnered.
Signature · 1 line
Kees Cook
Quoted 66 lines · Kees Cook
Quoted 38 lines · Matthew Wilcox
Quoted 22 lines · Kees Cook
Quoted 10 lines · Laura Abbott
Quoted 9 lines · Kees Cook
This feature continues to cause more problems than it solves[1]. Its intention was to check the bounds of page-allocator allocations by using
__GFP_COMP, for which we would need to find all missing__GFP_COMPmarkings. This work has been on hold and there is an argument[2] that such markings are not even the correct signal for checking for same-allocation pages. Instead of depending on BROKEN, this just removes it entirely. It can be trivially reverted if/when a better solution for tracking page allocator sizes is found.Quoted 5 lines
Quoted 2 lines
[1] https://www.mail-archive.com/[email protected]/msg37479.html
[2] https://lkml.kernel.org/r/[email protected]I agree the page spanning is broken but is it worth keeping the checks against
__rodata__bssetc.?They're all just white-listing later checks (except RODATA which is doing a cheap RO test which is redundant on any architecture with actual rodata...) so they don't have any value in staying without the rest of the page allocator logic.
Quoted 14 lines
Quoted 9 lines
mm/usercopy.c static inline void check_bogus_address(const unsigned long ptr, unsigned long n, · line 202
Quoted 9 lines
mm/usercopy.c +0
-9-/* Is the object wholly within one base page? */ -if (likely (((unsigned long )ptr & (unsigned long )PAGE_MASK ) == - ((unsigned long )end & (unsigned long )PAGE_MASK ))) -return ; - -/* Allow if fully inside the same compound (__GFP_COMP) page. */ - endpage =virt_to_head_page (end); -if (likely (endpage == page)) -return ;We _could_ keep the mixed CMA/reserved/neither check if we really wanted to, but that's such a corner case of a corner case, I'm not sure it's worth doing the
virt_to_head_page()across the whole span to figure it out.Quoted 1 line
I'd delete that first check, because it's a subset of the second check,
It seemed easier to short-circuit with a math test before doing the slightly more expensive
virt_to_head_page(end)call. Do you think that's sensible?Quoted 23 lines
/* Is the object wholly within a single (base or compound) page? */ endpage = virt_to_head_page(end); if (likely(endpage == page)) return; /* * If the start and end are more than MAX_ORDER apart, they must * be from separate allocations */ if (n >= (PAGE_SIZE << MAX_ORDER)) usercopy_abort("spans too many pages", NULL, to_user, 0, n); /* * If neither page is compound, we can't tell if the object is * within a single allocation or not */ if (!PageCompound(page) && !PageCompound(endpage)) return;Quoted 2 lines
I really wish we had size of allocation reliably held somewhere. We'll need it for doing memory tagging of the page allocator too...
Quoted 9 lines
Quoted 3 lines
I think we'll need to store those allocations in a separate data structure on the side. As far as the rest of the kernel is concerned, those struct pages belong to them once the page allocator has given them.
Okay, let me work up a page-type refactoring while allocation size can stay back-burnered.
Signature · 1 line
Kees Cook
Any progress on this patch?
- Eric
Quoted 1 line · Eric Biggers
Any progress on this patch?
I have no had time yet; sorry. If anyone else would like to take a stab at it, I'd appreciate it. :)
Signature · 1 line
Kees Cook
Quoted 9 lines · Kees Cook
This feature continues to cause more problems than it solves[1]. Its intention was to check the bounds of page-allocator allocations by using
__GFP_COMP, for which we would need to find all missing__GFP_COMPmarkings. This work has been on hold and there is an argument[2] that such markings are not even the correct signal for checking for same-allocation pages. Instead of depending on BROKEN, this just removes it entirely. It can be trivially reverted if/when a better solution for tracking page allocator sizes is found.
Quoted 5 lines
[1] https://www.mail-archive.com/[email protected]/msg37479.html
[2] https://lkml.kernel.org/r/[email protected]Suggested-by Eric Biggers <[email protected]>Signed-off-by Kees Cook <[email protected]>
So, after looking at this more, I think I'm going to keep this patch, and we can add new sanity checks on a per-Page flag check. (See below.)
Andrew, can you apply this to -mm please?
Quoted 81 lines
--- mm/usercopy.c | 67 ------------------------------------------------ security/Kconfig | 11 -------- 2 files changed, 78 deletions(-)mm/usercopy.c +0
-64@@ -159,70 +159,6 @@ static inline void check_bogus_address(const unsigned long ptr, unsigned long n,usercopy_abort ("null address" ,NULL , to_user, ptr, n); } -/* Checks for allocs that are marked in some way as spanning multiple pages. */ -static inline void check_page_span (const void *ptr,unsigned long n, -struct page *page,bool to_user) -{ -#ifdef CONFIG_HARDENED_USERCOPY_PAGESPAN -const void *end = ptr + n -1 ; -struct page *endpage; -bool is_reserved, is_cma; - -/* -* Sometimes the kernel data regions are not marked Reserved (see -* check below). And sometimes [_sdata,_edata) does not cover -* rodata and/or bss, so check each range explicitly. -*/ - -/* Allow reads of kernel rodata region (if not marked as Reserved). */ -if (ptr >= (const void *)__start_rodata && - end <= (const void *)__end_rodata) { -if (!to_user) -usercopy_abort ("rodata" ,NULL , to_user,0 , n); -return ; - } - -/* Allow kernel data region (if not marked as Reserved). */ -if (ptr >= (const void *)_sdata && end <= (const void *)_edata) -return ; - -/* Allow kernel bss region (if not marked as Reserved). */ -if (ptr >= (const void *)__bss_start && - end <= (const void *)__bss_stop) -return ; - -/* Is the object wholly within one base page? */ -if (likely (((unsigned long )ptr & (unsigned long )PAGE_MASK ) == - ((unsigned long )end & (unsigned long )PAGE_MASK ))) -return ; - -/* Allow if fully inside the same compound (__GFP_COMP) page. */ - endpage =virt_to_head_page (end); -if (likely (endpage == page)) -return ; - -/* -* Reject if range is entirely either Reserved (i.e. special or -* device memory), or CMA. Otherwise, reject since the object spans -* several independently allocated pages. -*/ - is_reserved =PageReserved (page); - is_cma =is_migrate_cma_page (page); -if (!is_reserved && !is_cma) -usercopy_abort ("spans multiple pages" ,NULL , to_user,0 , n); - -for (ptr +=PAGE_SIZE ; ptr <= end; ptr +=PAGE_SIZE ) { - page =virt_to_head_page (ptr); -if (is_reserved && !PageReserved (page)) -usercopy_abort ("spans Reserved and non-Reserved pages" , -NULL , to_user,0 , n); -if (is_cma && !is_migrate_cma_page (page)) -usercopy_abort ("spans CMA and non-CMA pages" ,NULL , - to_user,0 , n); - } -#endif -} -static inline void check_heap_object (const void *ptr,unsigned long n,bool to_user) {
mm/usercopy.c static inline void check_heap_object(const void *ptr, unsigned long n, · line 175
Quoted 7 lines
mm/usercopy.c +0
-3@@ -236,9 +172,6 @@ static inline void check_heap_object(const void *ptr, unsigned long n,if (PageSlab (page)) {/* Check slab allocator for flags and size. */ __check_heap_object (ptr, n, page, to_user); - }else { -/* Verify object does not incorrectly span multiple pages. */ -check_page_span (ptr, n, page, to_user); }
In the future, instead of this catch-all "else", we can add things like:
} else if (PageCompound(page)) {
... do some check for compound pages ...
} else if (PageReserved(page))
... etc ...
}But for 5.3, I think we need to just entirely drop the PAGESPAN thing.
-Kees
Quoted 30 lines
mm/usercopy.c +0
-0}security/Kconfig +0
-11@@ -176,17 +176,6 @@ config HARDENED_USERCOPY_FALLBACK Booting with "slab_common.usercopy_fallback=Y/N" can change this setting. -config HARDENED_USERCOPY_PAGESPAN - bool "Refuse to copy allocations that span multiple pages" - depends on HARDENED_USERCOPY - depends on EXPERT - help - When a multi-page allocation is done without __GFP_COMP, - hardened usercopy will reject attempts to copy it. There are, - however, several cases of this in the kernel that have not all - been removed. This config is intended to be used only while - trying to find such users. - config FORTIFY_SOURCE bool "Harden common str/mem functions against buffer overflows" depends on ARCH_HAS_FORTIFY_SOURCESignature · 5 lines
2.17.1 -- Kees Cook
Signature · 1 line
Kees Cook