Skip to contentSkip to conversation

crypto: Kernel memory overwrite attempt detected to spans multiple pages

PATCH In review Geert Uytterhoeven 9 participants 27 messages Mar 19, 2019 – Apr 17, 2019

Subsystems (5)
lore
Share & tools
lore
#0 lore raw

When running the sha1-asm crypto selftest on arm with CONFIG_HARDENED_USERCOPY_PAGESPAN=y:

usercopy: Kernel memory overwrite attempt detected to spans
multiple pages (offset 0, size 42)!

    ------------[ cut here ]------------
    kernel BUG at mm/usercopy.c:102!
    Internal error: Oops - BUG: 0 [#1] SMP ARM
    Modules linked in:
    CPU: 0 PID: 35 Comm: cryptomgr_test Not tainted
5.1.0-rc1-koelsch-01109-gbeb7d6376ecfbf07-dirty #397
    Hardware name: Generic R-Car Gen2 (Flattened Device Tree)
    PC is at usercopy_abort+0x68/0x90
    LR is at usercopy_abort+0x68/0x90
    pc : [<c030fd60>]    lr : [<c030fd60>]    psr: 60000013
    sp : ea54bc60  ip : 00000010  fp : cccccccd
    r10: 00000000  r9 : c0e0ce04  r8 : ea54d009
    r7 : ea54d00a  r6 : 00000000  r5 : 0000002a  r4 : c09d1120
    r3 : dd6cd422  r2 : dd6cd422  r1 : 2abb4000  r0 : 0000005f
    Flags: nZCv  IRQs on  FIQs on  Mode SVC_32  ISA ARM  Segment user
    Control: 30c5387d  Table: 40003000  DAC: fffffffd
    Process cryptomgr_test (pid: 35, stack limit = 0x(ptrval))
    Stack: (0xea54bc60 to 0xea54c000)
    bc60: c09d1120 c09d1120 c09d1120 00000000 0000002a 0000002a
00000000 c0310060
    bc80: 0000002a 00000000 000001c0 00000000 00000000 c0eb11e8
ea54cfe0 ea538c00
    bca0: 00000000 ea54cfe0 ebef73e0 0000002a ea538c20 ea54bd84
0000003a c0427a30
    bcc0: ea54bdbc 00000000 00000000 c081cf70 eb074280 c081cf70
0000002a c081cf80
    bce0: 0000000e c07da138 ea54bd0c 00000000 c084061c c04248e8
c0e0a408 eb074240
    bd00: eb074200 c04253c8 eb074280 ea550000 00000012 dd6cd422
ebef7480 eb074200
    bd20: ea54bd84 c081cf64 ea537200 00000002 00000000 00000014
c084061c c0428c38
    bd40: ea54bd84 ea54bdbc c081cd34 00000000 c0e4e4b4 ea538c40
00000002 eabe4e80
    bd60: ea538c00 00000400 ea4f7a00 ea4f7a60 eb074240 00000060
00000006 c09d544c
    bd80: 00000038 00000003 00000000 00000038 ea54bd7c 00000001
eb074200 00000000
    bda0: 00000000 dead4ead ffffffff ffffffff ea54bdb0 ea54bdb0
00000000 c081cf70
    bdc0: c081ce68 c081ce78 ea4f7480 eb000780 00000dc0 eb000780
c0e4ee80 443e9884
    bde0: 6ed23b1c a14aaeba e52951f9 f17046e5 fefefefe fefefefe
fefefefe fefefefe
    be00: eb000780 c04292c4 c0e0a638 60000013 60000013 c0305298
ea4f7a00 c03062bc
    be20: eb000780 00000cc0 ea4f7a00 dd6cd422 00000cc0 ea538c00
00000002 eabe4e40
    be40: ea537200 00000007 00000000 ea4f7a00 eb074200 c0429314
eb074200 ea538c00
    be60: ea4f7a00 0000000a eabe4e80 c084061c c08405fc 00000006
c04dace8 00000006
    be80: 00000000 c084065c ea537200 0000000e 00000400 eb04de08
ea4f71a8 c0429420
    bea0: 00000400 ea537200 0000000e ea537200 0000000e c0429374
00000400 ffffffff
    bec0: 000000a2 c042a414 00000103 c0e0a408 00000000 c0e0a438
c0e5a2a0 c0e5a2a0
    bee0: 00000001 00000001 00000017 ffffe000 00000000 60000013
c0e5a2a0 c0269470
    bf00: c09c9ed0 ea54bf5c 00000103 00000000 00000000 c0e0a408
ea537280 0000000e
    bf20: 00000400 c0426500 00000000 eb04de08 ea4f71a8 c02694f4
c09c9ed0 ea54bf5c
    bf40: ea54bf28 c02699d0 ea54bf5c dd6cd422 ea537200 dd6cd422
c09c9ed0 ea537200
    bf60: ea4af1c0 ea54a000 ea537200 c0426500 00000000 eb04de08
ea4f71a8 c0426524
    bf80: ea4f7180 c023dcec ea54a000 ea4af1c0 c023dbb4 00000000
00000000 00000000
    bfa0: 00000000 00000000 00000000 c02010d8 00000000 00000000
00000000 00000000
    bfc0: 00000000 00000000 00000000 00000000 00000000 00000000
00000000 00000000
    bfe0: 00000000 00000000 00000000 00000000 00000013 00000000
00000000 00000000
    [<c030fd60>] (usercopy_abort) from [<c0310060>]
(__check_object_size+0x2d8/0x448)
    [<c0310060>] (__check_object_size) from [<c0427a30>]
(build_test_sglist+0x268/0x2d8)
    [<c0427a30>] (build_test_sglist) from [<c0428c38>]
(test_hash_vec_cfg+0x110/0x694)
    [<c0428c38>] (test_hash_vec_cfg) from [<c0429314>]
(__alg_test_hash+0x158/0x1b8)
    [<c0429314>] (__alg_test_hash) from [<c0429420>] (alg_test_hash+0xac/0xf4)
    [<c0429420>] (alg_test_hash) from [<c042a414>] (alg_test.part.4+0x264/0x2f8)
    [<c042a414>] (alg_test.part.4) from [<c0426524>] (cryptomgr_test+0x24/0x44)
    [<c0426524>] (cryptomgr_test) from [<c023dcec>] (kthread+0x138/0x150)
    [<c023dcec>] (kthread) from [<c02010d8>] (ret_from_fork+0x14/0x3c)
    Exception stack(0xea54bfb0 to 0xea54bff8)
    bfa0:                                     00000000 00000000
00000000 00000000
    bfc0: 00000000 00000000 00000000 00000000 00000000 00000000
00000000 00000000
    bfe0: 00000000 00000000 00000000 00000000 00000013 00000000
    Code: e58de000 e98d0012 e1a0100c ebfd6712 (e7f001f2)
    ---[ end trace 190b3cf48e720f78 ]---
    BUG: sleeping function called from invalid context at

include/linux/percpu-rwsem.h:34
in_atomic(): 0, irqs_disabled(): 128, pid: 35, name: cryptomgr_test
CPU: 0 PID: 35 Comm: cryptomgr_test Tainted: G D
5.1.0-rc1-koelsch-01109-gbeb7d6376ecfbf07-dirty #397

    Hardware name: Generic R-Car Gen2 (Flattened Device Tree)
    [<c020ec74>] (unwind_backtrace) from [<c020ae58>] (show_stack+0x10/0x14)
    [<c020ae58>] (show_stack) from [<c07c3624>] (dump_stack+0x7c/0x9c)
    [<c07c3624>] (dump_stack) from [<c0242e14>] (___might_sleep+0xf4/0x158)
    [<c0242e14>] (___might_sleep) from [<c0230210>] (exit_signals+0x2c/0x258)
    [<c0230210>] (exit_signals) from [<c0223d6c>] (do_exit+0x114/0xa20)
    [<c0223d6c>] (do_exit) from [<c020b160>] (die+0x304/0x344)
    [<c020b160>] (die) from [<c020b388>] (do_undefinstr+0x80/0x190)
    [<c020b388>] (do_undefinstr) from [<c0201b24>] (__und_svc_finish+0x0/0x3c)
    Exception stack(0xea54bc10 to 0xea54bc58)
    bc00:                                     0000005f 2abb4000
dd6cd422 dd6cd422
    bc20: c09d1120 0000002a 00000000 ea54d00a ea54d009 c0e0ce04
00000000 cccccccd
    bc40: 00000010 ea54bc60 c030fd60 c030fd60 60000013 ffffffff
    [<c0201b24>] (__und_svc_finish) from [<c030fd60>] (usercopy_abort+0x68/0x90)
    [<c030fd60>] (usercopy_abort) from [<c0310060>]
(__check_object_size+0x2d8/0x448)
    [<c0310060>] (__check_object_size) from [<c0427a30>]
(build_test_sglist+0x268/0x2d8)
    [<c0427a30>] (build_test_sglist) from [<c0428c38>]
(test_hash_vec_cfg+0x110/0x694)
    [<c0428c38>] (test_hash_vec_cfg) from [<c0429314>]
(__alg_test_hash+0x158/0x1b8)
    [<c0429314>] (__alg_test_hash) from [<c0429420>] (alg_test_hash+0xac/0xf4)
    [<c0429420>] (alg_test_hash) from [<c042a414>] (alg_test.part.4+0x264/0x2f8)
    [<c042a414>] (alg_test.part.4) from [<c0426524>] (cryptomgr_test+0x24/0x44)
    [<c0426524>] (cryptomgr_test) from [<c023dcec>] (kthread+0x138/0x150)
    [<c023dcec>] (kthread) from [<c02010d8>] (ret_from_fork+0x14/0x3c)
    Exception stack(0xea54bfb0 to 0xea54bff8)
    bfa0:                                     00000000 00000000
00000000 00000000
    bfc0: 00000000 00000000 00000000 00000000 00000000 00000000
00000000 00000000
    bfe0: 00000000 00000000 00000000 00000000 00000013 00000000

A similar trace is seen with sha1-ce on arm64:

usercopy: Kernel memory overwrite attempt detected to spans
multiple pages (offset 0, size 42)!

    ------------[ cut here ]------------
    kernel BUG at mm/usercopy.c:102!
    Internal error: Oops - BUG: 0 [#1] SMP
    Modules linked in:
    CPU: 1 PID: 33 Comm: cryptomgr_test Not tainted
5.1.0-rc1-salvator-x-01109-gbeb7d6376ecfbf07-dirty #352
    Hardware name: Renesas Salvator-X 2nd version board based on r8a77965 (DT)
    pstate: 60400005 (nZCv daif +PAN -UAO)
    pc : usercopy_abort+0x64/0x90
    lr : usercopy_abort+0x64/0x90
    sp : ffffff8011eb38d0
    x29: ffffff8011eb38e0 x28: 6db6db6db6db6db7
    x27: ffffffbf00000000 x26: 0000000000000038
    x25: ffffffc0778fd009 x24: 0000000000000000
    x23: ffffffc0778fd00a x22: ffffff8010d51000
    x21: 0000000000000000 x20: 000000000000002a
    x19: ffffffc0778fcfe0 x18: 000000000000000a
    x17: 00000000526a1be5 x16: 0000000000000014
    x15: 000000000009f6c2 x14: 0720072007200720
    x13: 0720072007200720 x12: 0720072007200720
    x11: 0720072007200720 x10: 0720072007200720
    x9 : ffffff80110126c8 x8 : 0000000000000000
    x7 : ffffff801015700c x6 : 0000000000000000
    x5 : 0000000000000000 x4 : ffffff8011eb4000
    x3 : 0000000000000080 x2 : a045404094166600
    x1 : 0000000000000000 x0 : 000000000000005f
    Process cryptomgr_test (pid: 33, stack limit = 0x(____ptrval____))
    Call trace:
     usercopy_abort+0x64/0x90
     __check_object_size+0x64/0x464
     build_test_sglist+0x238/0x2c8
     test_hash_vec_cfg+0x130/0x660
     __alg_test_hash+0x1b4/0x1f4
     alg_test_hash+0x88/0x104
     alg_test.part.6+0x2a8/0x330
     alg_test+0x98/0xa0
     cryptomgr_test+0x24/0x4c
     kthread+0x120/0x130
     ret_from_fork+0x10/0x18
    Code: aa0003e3 b00053e0 91148000 97fc3bf2 (d4210000)
    ---[ end trace d9f3261d50a7f84f ]---
    BUG: sleeping function called from invalid context at

include/linux/percpu-rwsem.h:34
in_atomic(): 0, irqs_disabled(): 128, pid: 33, name: cryptomgr_test
INFO: lockdep is turned off.
irq event stamp: 262
hardirqs last enabled at (261): [<ffffff8010157050>]

console_unlock+0x554/0x560
    hardirqs last disabled at (262): [<ffffff8010081a28>]
do_debug_exception+0x48/0x13c
    softirqs last  enabled at (258): [<ffffff8010081ee4>]
__do_softirq+0x18c/0x4a0
    softirqs last disabled at (245): [<ffffff80100f3e10>] irq_exit+0xa4/0x100
    CPU: 1 PID: 33 Comm: cryptomgr_test Tainted: G      D
5.1.0-rc1-salvator-x-01109-gbeb7d6376ecfbf07-dirty #352
    Hardware name: Renesas Salvator-X 2nd version board based on r8a77965 (DT)
    Call trace:
     dump_backtrace+0x0/0x118
     show_stack+0x14/0x1c
     dump_stack+0xc8/0x118
     ___might_sleep+0x24c/0x25c
     __might_sleep+0x70/0x80
     exit_signals+0x48/0x278
     do_exit+0x10c/0xa30
     die+0x1f4/0x208
     bug_handler+0x4c/0x78
     brk_handler+0x15c/0x188
     do_debug_exception+0xd4/0x13c
     el1_dbg+0x18/0xbc
     usercopy_abort+0x64/0x90
     __check_object_size+0x64/0x464
     build_test_sglist+0x238/0x2c8
     test_hash_vec_cfg+0x130/0x660
     __alg_test_hash+0x1b4/0x1f4
     alg_test_hash+0x88/0x104
     alg_test.part.6+0x2a8/0x330
     alg_test+0x98/0xa0
     cryptomgr_test+0x24/0x4c
     kthread+0x120/0x130
     ret_from_fork+0x10/0x18

Gr{oetje,eeting}s,

Geert

Signature · 5 lines
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
#1 lore raw
Quoted 228 lines · Geert Uytterhoeven

When running the sha1-asm crypto selftest on arm with CONFIG_HARDENED_USERCOPY_PAGESPAN=y:

usercopy: Kernel memory overwrite attempt detected to spans
multiple pages (offset 0, size 42)!

    ------------[ cut here ]------------
    kernel BUG at mm/usercopy.c:102!
    Internal error: Oops - BUG: 0 [#1] SMP ARM
    Modules linked in:
    CPU: 0 PID: 35 Comm: cryptomgr_test Not tainted
5.1.0-rc1-koelsch-01109-gbeb7d6376ecfbf07-dirty #397
    Hardware name: Generic R-Car Gen2 (Flattened Device Tree)
    PC is at usercopy_abort+0x68/0x90
    LR is at usercopy_abort+0x68/0x90
    pc : [<c030fd60>]    lr : [<c030fd60>]    psr: 60000013
    sp : ea54bc60  ip : 00000010  fp : cccccccd
    r10: 00000000  r9 : c0e0ce04  r8 : ea54d009
    r7 : ea54d00a  r6 : 00000000  r5 : 0000002a  r4 : c09d1120
    r3 : dd6cd422  r2 : dd6cd422  r1 : 2abb4000  r0 : 0000005f
    Flags: nZCv  IRQs on  FIQs on  Mode SVC_32  ISA ARM  Segment user
    Control: 30c5387d  Table: 40003000  DAC: fffffffd
    Process cryptomgr_test (pid: 35, stack limit = 0x(ptrval))
    Stack: (0xea54bc60 to 0xea54c000)
    bc60: c09d1120 c09d1120 c09d1120 00000000 0000002a 0000002a
00000000 c0310060
    bc80: 0000002a 00000000 000001c0 00000000 00000000 c0eb11e8
ea54cfe0 ea538c00
    bca0: 00000000 ea54cfe0 ebef73e0 0000002a ea538c20 ea54bd84
0000003a c0427a30
    bcc0: ea54bdbc 00000000 00000000 c081cf70 eb074280 c081cf70
0000002a c081cf80
    bce0: 0000000e c07da138 ea54bd0c 00000000 c084061c c04248e8
c0e0a408 eb074240
    bd00: eb074200 c04253c8 eb074280 ea550000 00000012 dd6cd422
ebef7480 eb074200
    bd20: ea54bd84 c081cf64 ea537200 00000002 00000000 00000014
c084061c c0428c38
    bd40: ea54bd84 ea54bdbc c081cd34 00000000 c0e4e4b4 ea538c40
00000002 eabe4e80
    bd60: ea538c00 00000400 ea4f7a00 ea4f7a60 eb074240 00000060
00000006 c09d544c
    bd80: 00000038 00000003 00000000 00000038 ea54bd7c 00000001
eb074200 00000000
    bda0: 00000000 dead4ead ffffffff ffffffff ea54bdb0 ea54bdb0
00000000 c081cf70
    bdc0: c081ce68 c081ce78 ea4f7480 eb000780 00000dc0 eb000780
c0e4ee80 443e9884
    bde0: 6ed23b1c a14aaeba e52951f9 f17046e5 fefefefe fefefefe
fefefefe fefefefe
    be00: eb000780 c04292c4 c0e0a638 60000013 60000013 c0305298
ea4f7a00 c03062bc
    be20: eb000780 00000cc0 ea4f7a00 dd6cd422 00000cc0 ea538c00
00000002 eabe4e40
    be40: ea537200 00000007 00000000 ea4f7a00 eb074200 c0429314
eb074200 ea538c00
    be60: ea4f7a00 0000000a eabe4e80 c084061c c08405fc 00000006
c04dace8 00000006
    be80: 00000000 c084065c ea537200 0000000e 00000400 eb04de08
ea4f71a8 c0429420
    bea0: 00000400 ea537200 0000000e ea537200 0000000e c0429374
00000400 ffffffff
    bec0: 000000a2 c042a414 00000103 c0e0a408 00000000 c0e0a438
c0e5a2a0 c0e5a2a0
    bee0: 00000001 00000001 00000017 ffffe000 00000000 60000013
c0e5a2a0 c0269470
    bf00: c09c9ed0 ea54bf5c 00000103 00000000 00000000 c0e0a408
ea537280 0000000e
    bf20: 00000400 c0426500 00000000 eb04de08 ea4f71a8 c02694f4
c09c9ed0 ea54bf5c
    bf40: ea54bf28 c02699d0 ea54bf5c dd6cd422 ea537200 dd6cd422
c09c9ed0 ea537200
    bf60: ea4af1c0 ea54a000 ea537200 c0426500 00000000 eb04de08
ea4f71a8 c0426524
    bf80: ea4f7180 c023dcec ea54a000 ea4af1c0 c023dbb4 00000000
00000000 00000000
    bfa0: 00000000 00000000 00000000 c02010d8 00000000 00000000
00000000 00000000
    bfc0: 00000000 00000000 00000000 00000000 00000000 00000000
00000000 00000000
    bfe0: 00000000 00000000 00000000 00000000 00000013 00000000
00000000 00000000
    [<c030fd60>] (usercopy_abort) from [<c0310060>]
(__check_object_size+0x2d8/0x448)
    [<c0310060>] (__check_object_size) from [<c0427a30>]
(build_test_sglist+0x268/0x2d8)
    [<c0427a30>] (build_test_sglist) from [<c0428c38>]
(test_hash_vec_cfg+0x110/0x694)
    [<c0428c38>] (test_hash_vec_cfg) from [<c0429314>]
(__alg_test_hash+0x158/0x1b8)
    [<c0429314>] (__alg_test_hash) from [<c0429420>] (alg_test_hash+0xac/0xf4)
    [<c0429420>] (alg_test_hash) from [<c042a414>] (alg_test.part.4+0x264/0x2f8)
    [<c042a414>] (alg_test.part.4) from [<c0426524>] (cryptomgr_test+0x24/0x44)
    [<c0426524>] (cryptomgr_test) from [<c023dcec>] (kthread+0x138/0x150)
    [<c023dcec>] (kthread) from [<c02010d8>] (ret_from_fork+0x14/0x3c)
    Exception stack(0xea54bfb0 to 0xea54bff8)
    bfa0:                                     00000000 00000000
00000000 00000000
    bfc0: 00000000 00000000 00000000 00000000 00000000 00000000
00000000 00000000
    bfe0: 00000000 00000000 00000000 00000000 00000013 00000000
    Code: e58de000 e98d0012 e1a0100c ebfd6712 (e7f001f2)
    ---[ end trace 190b3cf48e720f78 ]---
    BUG: sleeping function called from invalid context at

include/linux/percpu-rwsem.h:34
in_atomic(): 0, irqs_disabled(): 128, pid: 35, name: cryptomgr_test
CPU: 0 PID: 35 Comm: cryptomgr_test Tainted: G D
5.1.0-rc1-koelsch-01109-gbeb7d6376ecfbf07-dirty #397

    Hardware name: Generic R-Car Gen2 (Flattened Device Tree)
    [<c020ec74>] (unwind_backtrace) from [<c020ae58>] (show_stack+0x10/0x14)
    [<c020ae58>] (show_stack) from [<c07c3624>] (dump_stack+0x7c/0x9c)
    [<c07c3624>] (dump_stack) from [<c0242e14>] (___might_sleep+0xf4/0x158)
    [<c0242e14>] (___might_sleep) from [<c0230210>] (exit_signals+0x2c/0x258)
    [<c0230210>] (exit_signals) from [<c0223d6c>] (do_exit+0x114/0xa20)
    [<c0223d6c>] (do_exit) from [<c020b160>] (die+0x304/0x344)
    [<c020b160>] (die) from [<c020b388>] (do_undefinstr+0x80/0x190)
    [<c020b388>] (do_undefinstr) from [<c0201b24>] (__und_svc_finish+0x0/0x3c)
    Exception stack(0xea54bc10 to 0xea54bc58)
    bc00:                                     0000005f 2abb4000
dd6cd422 dd6cd422
    bc20: c09d1120 0000002a 00000000 ea54d00a ea54d009 c0e0ce04
00000000 cccccccd
    bc40: 00000010 ea54bc60 c030fd60 c030fd60 60000013 ffffffff
    [<c0201b24>] (__und_svc_finish) from [<c030fd60>] (usercopy_abort+0x68/0x90)
    [<c030fd60>] (usercopy_abort) from [<c0310060>]
(__check_object_size+0x2d8/0x448)
    [<c0310060>] (__check_object_size) from [<c0427a30>]
(build_test_sglist+0x268/0x2d8)
    [<c0427a30>] (build_test_sglist) from [<c0428c38>]
(test_hash_vec_cfg+0x110/0x694)
    [<c0428c38>] (test_hash_vec_cfg) from [<c0429314>]
(__alg_test_hash+0x158/0x1b8)
    [<c0429314>] (__alg_test_hash) from [<c0429420>] (alg_test_hash+0xac/0xf4)
    [<c0429420>] (alg_test_hash) from [<c042a414>] (alg_test.part.4+0x264/0x2f8)
    [<c042a414>] (alg_test.part.4) from [<c0426524>] (cryptomgr_test+0x24/0x44)
    [<c0426524>] (cryptomgr_test) from [<c023dcec>] (kthread+0x138/0x150)
    [<c023dcec>] (kthread) from [<c02010d8>] (ret_from_fork+0x14/0x3c)
    Exception stack(0xea54bfb0 to 0xea54bff8)
    bfa0:                                     00000000 00000000
00000000 00000000
    bfc0: 00000000 00000000 00000000 00000000 00000000 00000000
00000000 00000000
    bfe0: 00000000 00000000 00000000 00000000 00000013 00000000

A similar trace is seen with sha1-ce on arm64:

usercopy: Kernel memory overwrite attempt detected to spans
multiple pages (offset 0, size 42)!

    ------------[ cut here ]------------
    kernel BUG at mm/usercopy.c:102!
    Internal error: Oops - BUG: 0 [#1] SMP
    Modules linked in:
    CPU: 1 PID: 33 Comm: cryptomgr_test Not tainted
5.1.0-rc1-salvator-x-01109-gbeb7d6376ecfbf07-dirty #352
    Hardware name: Renesas Salvator-X 2nd version board based on r8a77965 (DT)
    pstate: 60400005 (nZCv daif +PAN -UAO)
    pc : usercopy_abort+0x64/0x90
    lr : usercopy_abort+0x64/0x90
    sp : ffffff8011eb38d0
    x29: ffffff8011eb38e0 x28: 6db6db6db6db6db7
    x27: ffffffbf00000000 x26: 0000000000000038
    x25: ffffffc0778fd009 x24: 0000000000000000
    x23: ffffffc0778fd00a x22: ffffff8010d51000
    x21: 0000000000000000 x20: 000000000000002a
    x19: ffffffc0778fcfe0 x18: 000000000000000a
    x17: 00000000526a1be5 x16: 0000000000000014
    x15: 000000000009f6c2 x14: 0720072007200720
    x13: 0720072007200720 x12: 0720072007200720
    x11: 0720072007200720 x10: 0720072007200720
    x9 : ffffff80110126c8 x8 : 0000000000000000
    x7 : ffffff801015700c x6 : 0000000000000000
    x5 : 0000000000000000 x4 : ffffff8011eb4000
    x3 : 0000000000000080 x2 : a045404094166600
    x1 : 0000000000000000 x0 : 000000000000005f
    Process cryptomgr_test (pid: 33, stack limit = 0x(____ptrval____))
    Call trace:
     usercopy_abort+0x64/0x90
     __check_object_size+0x64/0x464
     build_test_sglist+0x238/0x2c8
     test_hash_vec_cfg+0x130/0x660
     __alg_test_hash+0x1b4/0x1f4
     alg_test_hash+0x88/0x104
     alg_test.part.6+0x2a8/0x330
     alg_test+0x98/0xa0
     cryptomgr_test+0x24/0x4c
     kthread+0x120/0x130
     ret_from_fork+0x10/0x18
    Code: aa0003e3 b00053e0 91148000 97fc3bf2 (d4210000)
    ---[ end trace d9f3261d50a7f84f ]---
    BUG: sleeping function called from invalid context at

include/linux/percpu-rwsem.h:34
in_atomic(): 0, irqs_disabled(): 128, pid: 33, name: cryptomgr_test
INFO: lockdep is turned off.
irq event stamp: 262
hardirqs last enabled at (261): [<ffffff8010157050>]

console_unlock+0x554/0x560
    hardirqs last disabled at (262): [<ffffff8010081a28>]
do_debug_exception+0x48/0x13c
    softirqs last  enabled at (258): [<ffffff8010081ee4>]
__do_softirq+0x18c/0x4a0
    softirqs last disabled at (245): [<ffffff80100f3e10>] irq_exit+0xa4/0x100
    CPU: 1 PID: 33 Comm: cryptomgr_test Tainted: G      D
5.1.0-rc1-salvator-x-01109-gbeb7d6376ecfbf07-dirty #352
    Hardware name: Renesas Salvator-X 2nd version board based on r8a77965 (DT)
    Call trace:
     dump_backtrace+0x0/0x118
     show_stack+0x14/0x1c
     dump_stack+0xc8/0x118
     ___might_sleep+0x24c/0x25c
     __might_sleep+0x70/0x80
     exit_signals+0x48/0x278
     do_exit+0x10c/0xa30
     die+0x1f4/0x208
     bug_handler+0x4c/0x78
     brk_handler+0x15c/0x188
     do_debug_exception+0xd4/0x13c
     el1_dbg+0x18/0xbc
     usercopy_abort+0x64/0x90
     __check_object_size+0x64/0x464
     build_test_sglist+0x238/0x2c8
     test_hash_vec_cfg+0x130/0x660
     __alg_test_hash+0x1b4/0x1f4
     alg_test_hash+0x88/0x104
     alg_test.part.6+0x2a8/0x330
     alg_test+0x98/0xa0
     cryptomgr_test+0x24/0x4c
     kthread+0x120/0x130
     ret_from_fork+0x10/0x18
Quoted 4 lines

Gr{oetje,eeting}s,

Geert

Well, this must happen with the new (in 5.1) crypto self-tests implementation for any crypto algorithm when CONFIG_HARDENED_USERCOPY_PAGESPAN=y. I don't understand why hardened usercopy considers it a bug though, as there's no buffer overflow. The crypto tests use copy_from_iter() to copy data into a 2-page buffer that was allocated with __get_free_pages():

	__get_free_pages(GFP_KERNEL, 1)

... where 1 means an order-1 allocation.

If it copies to offset=4064 len=42, for example, then hardened usercopy considers it a bug even though the buffer is 8192 bytes long. Why?

It isn't actually copying anything to/from userspace, BTW; it's using iov_iter with ITER_KVEC.

- Eric

#2 lore raw
Quoted 155 lines · Eric Biggers
Quoted 134 lines · Geert Uytterhoeven

When running the sha1-asm crypto selftest on arm with CONFIG_HARDENED_USERCOPY_PAGESPAN=y:

usercopy: Kernel memory overwrite attempt detected to spans
multiple pages (offset 0, size 42)!

    ------------[ cut here ]------------
    kernel BUG at mm/usercopy.c:102!
    Internal error: Oops - BUG: 0 [#1] SMP ARM
    Modules linked in:
    CPU: 0 PID: 35 Comm: cryptomgr_test Not tainted
5.1.0-rc1-koelsch-01109-gbeb7d6376ecfbf07-dirty #397
    Hardware name: Generic R-Car Gen2 (Flattened Device Tree)
    PC is at usercopy_abort+0x68/0x90
    LR is at usercopy_abort+0x68/0x90
    pc : [<c030fd60>]    lr : [<c030fd60>]    psr: 60000013
    sp : ea54bc60  ip : 00000010  fp : cccccccd
    r10: 00000000  r9 : c0e0ce04  r8 : ea54d009
    r7 : ea54d00a  r6 : 00000000  r5 : 0000002a  r4 : c09d1120
    r3 : dd6cd422  r2 : dd6cd422  r1 : 2abb4000  r0 : 0000005f
    Flags: nZCv  IRQs on  FIQs on  Mode SVC_32  ISA ARM  Segment user
    Control: 30c5387d  Table: 40003000  DAC: fffffffd
    Process cryptomgr_test (pid: 35, stack limit = 0x(ptrval))
    Stack: (0xea54bc60 to 0xea54c000)
    bc60: c09d1120 c09d1120 c09d1120 00000000 0000002a 0000002a
00000000 c0310060
    bc80: 0000002a 00000000 000001c0 00000000 00000000 c0eb11e8
ea54cfe0 ea538c00
    bca0: 00000000 ea54cfe0 ebef73e0 0000002a ea538c20 ea54bd84
0000003a c0427a30
    bcc0: ea54bdbc 00000000 00000000 c081cf70 eb074280 c081cf70
0000002a c081cf80
    bce0: 0000000e c07da138 ea54bd0c 00000000 c084061c c04248e8
c0e0a408 eb074240
    bd00: eb074200 c04253c8 eb074280 ea550000 00000012 dd6cd422
ebef7480 eb074200
    bd20: ea54bd84 c081cf64 ea537200 00000002 00000000 00000014
c084061c c0428c38
    bd40: ea54bd84 ea54bdbc c081cd34 00000000 c0e4e4b4 ea538c40
00000002 eabe4e80
    bd60: ea538c00 00000400 ea4f7a00 ea4f7a60 eb074240 00000060
00000006 c09d544c
    bd80: 00000038 00000003 00000000 00000038 ea54bd7c 00000001
eb074200 00000000
    bda0: 00000000 dead4ead ffffffff ffffffff ea54bdb0 ea54bdb0
00000000 c081cf70
    bdc0: c081ce68 c081ce78 ea4f7480 eb000780 00000dc0 eb000780
c0e4ee80 443e9884
    bde0: 6ed23b1c a14aaeba e52951f9 f17046e5 fefefefe fefefefe
fefefefe fefefefe
    be00: eb000780 c04292c4 c0e0a638 60000013 60000013 c0305298
ea4f7a00 c03062bc
    be20: eb000780 00000cc0 ea4f7a00 dd6cd422 00000cc0 ea538c00
00000002 eabe4e40
    be40: ea537200 00000007 00000000 ea4f7a00 eb074200 c0429314
eb074200 ea538c00
    be60: ea4f7a00 0000000a eabe4e80 c084061c c08405fc 00000006
c04dace8 00000006
    be80: 00000000 c084065c ea537200 0000000e 00000400 eb04de08
ea4f71a8 c0429420
    bea0: 00000400 ea537200 0000000e ea537200 0000000e c0429374
00000400 ffffffff
    bec0: 000000a2 c042a414 00000103 c0e0a408 00000000 c0e0a438
c0e5a2a0 c0e5a2a0
    bee0: 00000001 00000001 00000017 ffffe000 00000000 60000013
c0e5a2a0 c0269470
    bf00: c09c9ed0 ea54bf5c 00000103 00000000 00000000 c0e0a408
ea537280 0000000e
    bf20: 00000400 c0426500 00000000 eb04de08 ea4f71a8 c02694f4
c09c9ed0 ea54bf5c
    bf40: ea54bf28 c02699d0 ea54bf5c dd6cd422 ea537200 dd6cd422
c09c9ed0 ea537200
    bf60: ea4af1c0 ea54a000 ea537200 c0426500 00000000 eb04de08
ea4f71a8 c0426524
    bf80: ea4f7180 c023dcec ea54a000 ea4af1c0 c023dbb4 00000000
00000000 00000000
    bfa0: 00000000 00000000 00000000 c02010d8 00000000 00000000
00000000 00000000
    bfc0: 00000000 00000000 00000000 00000000 00000000 00000000
00000000 00000000
    bfe0: 00000000 00000000 00000000 00000000 00000013 00000000
00000000 00000000
    [<c030fd60>] (usercopy_abort) from [<c0310060>]
(__check_object_size+0x2d8/0x448)
    [<c0310060>] (__check_object_size) from [<c0427a30>]
(build_test_sglist+0x268/0x2d8)
    [<c0427a30>] (build_test_sglist) from [<c0428c38>]
(test_hash_vec_cfg+0x110/0x694)
    [<c0428c38>] (test_hash_vec_cfg) from [<c0429314>]
(__alg_test_hash+0x158/0x1b8)
    [<c0429314>] (__alg_test_hash) from [<c0429420>] (alg_test_hash+0xac/0xf4)
    [<c0429420>] (alg_test_hash) from [<c042a414>] (alg_test.part.4+0x264/0x2f8)
    [<c042a414>] (alg_test.part.4) from [<c0426524>] (cryptomgr_test+0x24/0x44)
    [<c0426524>] (cryptomgr_test) from [<c023dcec>] (kthread+0x138/0x150)
    [<c023dcec>] (kthread) from [<c02010d8>] (ret_from_fork+0x14/0x3c)
    Exception stack(0xea54bfb0 to 0xea54bff8)
    bfa0:                                     00000000 00000000
00000000 00000000
    bfc0: 00000000 00000000 00000000 00000000 00000000 00000000
00000000 00000000
    bfe0: 00000000 00000000 00000000 00000000 00000013 00000000
    Code: e58de000 e98d0012 e1a0100c ebfd6712 (e7f001f2)
    ---[ end trace 190b3cf48e720f78 ]---
    BUG: sleeping function called from invalid context at

include/linux/percpu-rwsem.h:34
in_atomic(): 0, irqs_disabled(): 128, pid: 35, name: cryptomgr_test
CPU: 0 PID: 35 Comm: cryptomgr_test Tainted: G D
5.1.0-rc1-koelsch-01109-gbeb7d6376ecfbf07-dirty #397

    Hardware name: Generic R-Car Gen2 (Flattened Device Tree)
    [<c020ec74>] (unwind_backtrace) from [<c020ae58>] (show_stack+0x10/0x14)
    [<c020ae58>] (show_stack) from [<c07c3624>] (dump_stack+0x7c/0x9c)
    [<c07c3624>] (dump_stack) from [<c0242e14>] (___might_sleep+0xf4/0x158)
    [<c0242e14>] (___might_sleep) from [<c0230210>] (exit_signals+0x2c/0x258)
    [<c0230210>] (exit_signals) from [<c0223d6c>] (do_exit+0x114/0xa20)
    [<c0223d6c>] (do_exit) from [<c020b160>] (die+0x304/0x344)
    [<c020b160>] (die) from [<c020b388>] (do_undefinstr+0x80/0x190)
    [<c020b388>] (do_undefinstr) from [<c0201b24>] (__und_svc_finish+0x0/0x3c)
    Exception stack(0xea54bc10 to 0xea54bc58)
    bc00:                                     0000005f 2abb4000
dd6cd422 dd6cd422
    bc20: c09d1120 0000002a 00000000 ea54d00a ea54d009 c0e0ce04
00000000 cccccccd
    bc40: 00000010 ea54bc60 c030fd60 c030fd60 60000013 ffffffff
    [<c0201b24>] (__und_svc_finish) from [<c030fd60>] (usercopy_abort+0x68/0x90)
    [<c030fd60>] (usercopy_abort) from [<c0310060>]
(__check_object_size+0x2d8/0x448)
    [<c0310060>] (__check_object_size) from [<c0427a30>]
(build_test_sglist+0x268/0x2d8)
    [<c0427a30>] (build_test_sglist) from [<c0428c38>]
(test_hash_vec_cfg+0x110/0x694)
    [<c0428c38>] (test_hash_vec_cfg) from [<c0429314>]
(__alg_test_hash+0x158/0x1b8)
    [<c0429314>] (__alg_test_hash) from [<c0429420>] (alg_test_hash+0xac/0xf4)
    [<c0429420>] (alg_test_hash) from [<c042a414>] (alg_test.part.4+0x264/0x2f8)
    [<c042a414>] (alg_test.part.4) from [<c0426524>] (cryptomgr_test+0x24/0x44)
Quoted 9 lines
    [<c0426524>] (cryptomgr_test) from [<c023dcec>] (kthread+0x138/0x150)
    [<c023dcec>] (kthread) from [<c02010d8>] (ret_from_fork+0x14/0x3c)
    Exception stack(0xea54bfb0 to 0xea54bff8)
    bfa0:                                     00000000 00000000
00000000 00000000
    bfc0: 00000000 00000000 00000000 00000000 00000000 00000000
00000000 00000000
    bfe0: 00000000 00000000 00000000 00000000 00000013 00000000

Well, this must happen with the new (in 5.1) crypto self-tests implementation for any crypto algorithm when CONFIG_HARDENED_USERCOPY_PAGESPAN=y. I don't understand why hardened usercopy considers it a bug though, as there's no buffer overflow. The crypto tests use copy_from_iter() to copy data into a 2-page buffer that was allocated with __get_free_pages():

	__get_free_pages(GFP_KERNEL, 1)

... where 1 means an order-1 allocation.

Quoted 7 lines

If it copies to offset=4064 len=42, for example, then hardened usercopy considers it a bug even though the buffer is 8192 bytes long. Why?

It isn't actually copying anything to/from userspace, BTW; it's using iov_iter with ITER_KVEC.

- Eric

Kees, any thoughts on why hardened usercopy rejects copies spanning a page boundary when they seem to be fine?

- Eric

#3 lore raw
Quoted 160 lines · Eric Biggers
Quoted 158 lines · Eric Biggers
Quoted 134 lines · Geert Uytterhoeven

When running the sha1-asm crypto selftest on arm with CONFIG_HARDENED_USERCOPY_PAGESPAN=y:

usercopy: Kernel memory overwrite attempt detected to spans
multiple pages (offset 0, size 42)!

    ------------[ cut here ]------------
    kernel BUG at mm/usercopy.c:102!
    Internal error: Oops - BUG: 0 [#1] SMP ARM
    Modules linked in:
    CPU: 0 PID: 35 Comm: cryptomgr_test Not tainted
5.1.0-rc1-koelsch-01109-gbeb7d6376ecfbf07-dirty #397
    Hardware name: Generic R-Car Gen2 (Flattened Device Tree)
    PC is at usercopy_abort+0x68/0x90
    LR is at usercopy_abort+0x68/0x90
    pc : [<c030fd60>]    lr : [<c030fd60>]    psr: 60000013
    sp : ea54bc60  ip : 00000010  fp : cccccccd
    r10: 00000000  r9 : c0e0ce04  r8 : ea54d009
    r7 : ea54d00a  r6 : 00000000  r5 : 0000002a  r4 : c09d1120
    r3 : dd6cd422  r2 : dd6cd422  r1 : 2abb4000  r0 : 0000005f
    Flags: nZCv  IRQs on  FIQs on  Mode SVC_32  ISA ARM  Segment user
    Control: 30c5387d  Table: 40003000  DAC: fffffffd
    Process cryptomgr_test (pid: 35, stack limit = 0x(ptrval))
    Stack: (0xea54bc60 to 0xea54c000)
    bc60: c09d1120 c09d1120 c09d1120 00000000 0000002a 0000002a
00000000 c0310060
    bc80: 0000002a 00000000 000001c0 00000000 00000000 c0eb11e8
ea54cfe0 ea538c00
    bca0: 00000000 ea54cfe0 ebef73e0 0000002a ea538c20 ea54bd84
0000003a c0427a30
    bcc0: ea54bdbc 00000000 00000000 c081cf70 eb074280 c081cf70
0000002a c081cf80
    bce0: 0000000e c07da138 ea54bd0c 00000000 c084061c c04248e8
c0e0a408 eb074240
    bd00: eb074200 c04253c8 eb074280 ea550000 00000012 dd6cd422
ebef7480 eb074200
    bd20: ea54bd84 c081cf64 ea537200 00000002 00000000 00000014
c084061c c0428c38
    bd40: ea54bd84 ea54bdbc c081cd34 00000000 c0e4e4b4 ea538c40
00000002 eabe4e80
    bd60: ea538c00 00000400 ea4f7a00 ea4f7a60 eb074240 00000060
00000006 c09d544c
    bd80: 00000038 00000003 00000000 00000038 ea54bd7c 00000001
eb074200 00000000
    bda0: 00000000 dead4ead ffffffff ffffffff ea54bdb0 ea54bdb0
00000000 c081cf70
    bdc0: c081ce68 c081ce78 ea4f7480 eb000780 00000dc0 eb000780
c0e4ee80 443e9884
    bde0: 6ed23b1c a14aaeba e52951f9 f17046e5 fefefefe fefefefe
fefefefe fefefefe
    be00: eb000780 c04292c4 c0e0a638 60000013 60000013 c0305298
ea4f7a00 c03062bc
    be20: eb000780 00000cc0 ea4f7a00 dd6cd422 00000cc0 ea538c00
00000002 eabe4e40
    be40: ea537200 00000007 00000000 ea4f7a00 eb074200 c0429314
eb074200 ea538c00
    be60: ea4f7a00 0000000a eabe4e80 c084061c c08405fc 00000006
c04dace8 00000006
    be80: 00000000 c084065c ea537200 0000000e 00000400 eb04de08
ea4f71a8 c0429420
    bea0: 00000400 ea537200 0000000e ea537200 0000000e c0429374
00000400 ffffffff
    bec0: 000000a2 c042a414 00000103 c0e0a408 00000000 c0e0a438
c0e5a2a0 c0e5a2a0
    bee0: 00000001 00000001 00000017 ffffe000 00000000 60000013
c0e5a2a0 c0269470
    bf00: c09c9ed0 ea54bf5c 00000103 00000000 00000000 c0e0a408
ea537280 0000000e
    bf20: 00000400 c0426500 00000000 eb04de08 ea4f71a8 c02694f4
c09c9ed0 ea54bf5c
    bf40: ea54bf28 c02699d0 ea54bf5c dd6cd422 ea537200 dd6cd422
c09c9ed0 ea537200
    bf60: ea4af1c0 ea54a000 ea537200 c0426500 00000000 eb04de08
ea4f71a8 c0426524
    bf80: ea4f7180 c023dcec ea54a000 ea4af1c0 c023dbb4 00000000
00000000 00000000
    bfa0: 00000000 00000000 00000000 c02010d8 00000000 00000000
00000000 00000000
    bfc0: 00000000 00000000 00000000 00000000 00000000 00000000
00000000 00000000
    bfe0: 00000000 00000000 00000000 00000000 00000013 00000000
00000000 00000000
    [<c030fd60>] (usercopy_abort) from [<c0310060>]
(__check_object_size+0x2d8/0x448)
    [<c0310060>] (__check_object_size) from [<c0427a30>]
(build_test_sglist+0x268/0x2d8)
    [<c0427a30>] (build_test_sglist) from [<c0428c38>]
(test_hash_vec_cfg+0x110/0x694)
    [<c0428c38>] (test_hash_vec_cfg) from [<c0429314>]
(__alg_test_hash+0x158/0x1b8)
    [<c0429314>] (__alg_test_hash) from [<c0429420>] (alg_test_hash+0xac/0xf4)
    [<c0429420>] (alg_test_hash) from [<c042a414>] (alg_test.part.4+0x264/0x2f8)
    [<c042a414>] (alg_test.part.4) from [<c0426524>] (cryptomgr_test+0x24/0x44)
    [<c0426524>] (cryptomgr_test) from [<c023dcec>] (kthread+0x138/0x150)
    [<c023dcec>] (kthread) from [<c02010d8>] (ret_from_fork+0x14/0x3c)
    Exception stack(0xea54bfb0 to 0xea54bff8)
    bfa0:                                     00000000 00000000
00000000 00000000
    bfc0: 00000000 00000000 00000000 00000000 00000000 00000000
00000000 00000000
    bfe0: 00000000 00000000 00000000 00000000 00000013 00000000
    Code: e58de000 e98d0012 e1a0100c ebfd6712 (e7f001f2)
    ---[ end trace 190b3cf48e720f78 ]---
    BUG: sleeping function called from invalid context at

include/linux/percpu-rwsem.h:34
in_atomic(): 0, irqs_disabled(): 128, pid: 35, name: cryptomgr_test
CPU: 0 PID: 35 Comm: cryptomgr_test Tainted: G D
5.1.0-rc1-koelsch-01109-gbeb7d6376ecfbf07-dirty #397

    Hardware name: Generic R-Car Gen2 (Flattened Device Tree)
    [<c020ec74>] (unwind_backtrace) from [<c020ae58>] (show_stack+0x10/0x14)
    [<c020ae58>] (show_stack) from [<c07c3624>] (dump_stack+0x7c/0x9c)
    [<c07c3624>] (dump_stack) from [<c0242e14>] (___might_sleep+0xf4/0x158)
    [<c0242e14>] (___might_sleep) from [<c0230210>] (exit_signals+0x2c/0x258)
    [<c0230210>] (exit_signals) from [<c0223d6c>] (do_exit+0x114/0xa20)
    [<c0223d6c>] (do_exit) from [<c020b160>] (die+0x304/0x344)
    [<c020b160>] (die) from [<c020b388>] (do_undefinstr+0x80/0x190)
    [<c020b388>] (do_undefinstr) from [<c0201b24>] (__und_svc_finish+0x0/0x3c)
    Exception stack(0xea54bc10 to 0xea54bc58)
    bc00:                                     0000005f 2abb4000
dd6cd422 dd6cd422
    bc20: c09d1120 0000002a 00000000 ea54d00a ea54d009 c0e0ce04
00000000 cccccccd
    bc40: 00000010 ea54bc60 c030fd60 c030fd60 60000013 ffffffff
    [<c0201b24>] (__und_svc_finish) from [<c030fd60>] (usercopy_abort+0x68/0x90)
    [<c030fd60>] (usercopy_abort) from [<c0310060>]
(__check_object_size+0x2d8/0x448)
    [<c0310060>] (__check_object_size) from [<c0427a30>]
(build_test_sglist+0x268/0x2d8)
    [<c0427a30>] (build_test_sglist) from [<c0428c38>]
(test_hash_vec_cfg+0x110/0x694)
    [<c0428c38>] (test_hash_vec_cfg) from [<c0429314>]
(__alg_test_hash+0x158/0x1b8)
    [<c0429314>] (__alg_test_hash) from [<c0429420>] (alg_test_hash+0xac/0xf4)
    [<c0429420>] (alg_test_hash) from [<c042a414>] (alg_test.part.4+0x264/0x2f8)
    [<c042a414>] (alg_test.part.4) from [<c0426524>] (cryptomgr_test+0x24/0x44)
Quoted 9 lines
    [<c0426524>] (cryptomgr_test) from [<c023dcec>] (kthread+0x138/0x150)
    [<c023dcec>] (kthread) from [<c02010d8>] (ret_from_fork+0x14/0x3c)
    Exception stack(0xea54bfb0 to 0xea54bff8)
    bfa0:                                     00000000 00000000
00000000 00000000
    bfc0: 00000000 00000000 00000000 00000000 00000000 00000000
00000000 00000000
    bfe0: 00000000 00000000 00000000 00000000 00000013 00000000

Well, this must happen with the new (in 5.1) crypto self-tests implementation for any crypto algorithm when CONFIG_HARDENED_USERCOPY_PAGESPAN=y. I don't understand why hardened usercopy considers it a bug though, as there's no buffer overflow. The crypto tests use copy_from_iter() to copy data into a 2-page buffer that was allocated with __get_free_pages():

      __get_free_pages(GFP_KERNEL, 1)

... where 1 means an order-1 allocation.

If it copies to offset=4064 len=42, for example, then hardened usercopy considers it a bug even though the buffer is 8192 bytes long. Why?

Quoted 7 lines
Quoted 4 lines

It isn't actually copying anything to/from userspace, BTW; it's using iov_iter with ITER_KVEC.

- Eric

Kees, any thoughts on why hardened usercopy rejects copies spanning a page boundary when they seem to be fine?

This is due to missing the compound page marking, if I remember correctly. However, I tend to leave the pagespan test disabled: it really isn't ready for production use -- there are a lot of missing annotations still.

Signature · 1 line
Kees Cook
#4 lore raw
Quoted 166 lines · Kees Cook
Quoted 165 lines · Eric Biggers
Quoted 162 lines · Eric Biggers
Quoted 134 lines · Geert Uytterhoeven

When running the sha1-asm crypto selftest on arm with CONFIG_HARDENED_USERCOPY_PAGESPAN=y:

usercopy: Kernel memory overwrite attempt detected to spans
multiple pages (offset 0, size 42)!

    ------------[ cut here ]------------
    kernel BUG at mm/usercopy.c:102!
    Internal error: Oops - BUG: 0 [#1] SMP ARM
    Modules linked in:
    CPU: 0 PID: 35 Comm: cryptomgr_test Not tainted
5.1.0-rc1-koelsch-01109-gbeb7d6376ecfbf07-dirty #397
    Hardware name: Generic R-Car Gen2 (Flattened Device Tree)
    PC is at usercopy_abort+0x68/0x90
    LR is at usercopy_abort+0x68/0x90
    pc : [<c030fd60>]    lr : [<c030fd60>]    psr: 60000013
    sp : ea54bc60  ip : 00000010  fp : cccccccd
    r10: 00000000  r9 : c0e0ce04  r8 : ea54d009
    r7 : ea54d00a  r6 : 00000000  r5 : 0000002a  r4 : c09d1120
    r3 : dd6cd422  r2 : dd6cd422  r1 : 2abb4000  r0 : 0000005f
    Flags: nZCv  IRQs on  FIQs on  Mode SVC_32  ISA ARM  Segment user
    Control: 30c5387d  Table: 40003000  DAC: fffffffd
    Process cryptomgr_test (pid: 35, stack limit = 0x(ptrval))
    Stack: (0xea54bc60 to 0xea54c000)
    bc60: c09d1120 c09d1120 c09d1120 00000000 0000002a 0000002a
00000000 c0310060
    bc80: 0000002a 00000000 000001c0 00000000 00000000 c0eb11e8
ea54cfe0 ea538c00
    bca0: 00000000 ea54cfe0 ebef73e0 0000002a ea538c20 ea54bd84
0000003a c0427a30
    bcc0: ea54bdbc 00000000 00000000 c081cf70 eb074280 c081cf70
0000002a c081cf80
    bce0: 0000000e c07da138 ea54bd0c 00000000 c084061c c04248e8
c0e0a408 eb074240
    bd00: eb074200 c04253c8 eb074280 ea550000 00000012 dd6cd422
ebef7480 eb074200
    bd20: ea54bd84 c081cf64 ea537200 00000002 00000000 00000014
c084061c c0428c38
    bd40: ea54bd84 ea54bdbc c081cd34 00000000 c0e4e4b4 ea538c40
00000002 eabe4e80
    bd60: ea538c00 00000400 ea4f7a00 ea4f7a60 eb074240 00000060
00000006 c09d544c
    bd80: 00000038 00000003 00000000 00000038 ea54bd7c 00000001
eb074200 00000000
    bda0: 00000000 dead4ead ffffffff ffffffff ea54bdb0 ea54bdb0
00000000 c081cf70
    bdc0: c081ce68 c081ce78 ea4f7480 eb000780 00000dc0 eb000780
c0e4ee80 443e9884
    bde0: 6ed23b1c a14aaeba e52951f9 f17046e5 fefefefe fefefefe
fefefefe fefefefe
    be00: eb000780 c04292c4 c0e0a638 60000013 60000013 c0305298
ea4f7a00 c03062bc
    be20: eb000780 00000cc0 ea4f7a00 dd6cd422 00000cc0 ea538c00
00000002 eabe4e40
    be40: ea537200 00000007 00000000 ea4f7a00 eb074200 c0429314
eb074200 ea538c00
    be60: ea4f7a00 0000000a eabe4e80 c084061c c08405fc 00000006
c04dace8 00000006
    be80: 00000000 c084065c ea537200 0000000e 00000400 eb04de08
ea4f71a8 c0429420
    bea0: 00000400 ea537200 0000000e ea537200 0000000e c0429374
00000400 ffffffff
    bec0: 000000a2 c042a414 00000103 c0e0a408 00000000 c0e0a438
c0e5a2a0 c0e5a2a0
    bee0: 00000001 00000001 00000017 ffffe000 00000000 60000013
c0e5a2a0 c0269470
    bf00: c09c9ed0 ea54bf5c 00000103 00000000 00000000 c0e0a408
ea537280 0000000e
    bf20: 00000400 c0426500 00000000 eb04de08 ea4f71a8 c02694f4
c09c9ed0 ea54bf5c
    bf40: ea54bf28 c02699d0 ea54bf5c dd6cd422 ea537200 dd6cd422
c09c9ed0 ea537200
    bf60: ea4af1c0 ea54a000 ea537200 c0426500 00000000 eb04de08
ea4f71a8 c0426524
    bf80: ea4f7180 c023dcec ea54a000 ea4af1c0 c023dbb4 00000000
00000000 00000000
    bfa0: 00000000 00000000 00000000 c02010d8 00000000 00000000
00000000 00000000
    bfc0: 00000000 00000000 00000000 00000000 00000000 00000000
00000000 00000000
    bfe0: 00000000 00000000 00000000 00000000 00000013 00000000
00000000 00000000
    [<c030fd60>] (usercopy_abort) from [<c0310060>]
(__check_object_size+0x2d8/0x448)
    [<c0310060>] (__check_object_size) from [<c0427a30>]
(build_test_sglist+0x268/0x2d8)
    [<c0427a30>] (build_test_sglist) from [<c0428c38>]
(test_hash_vec_cfg+0x110/0x694)
    [<c0428c38>] (test_hash_vec_cfg) from [<c0429314>]
(__alg_test_hash+0x158/0x1b8)
    [<c0429314>] (__alg_test_hash) from [<c0429420>] (alg_test_hash+0xac/0xf4)
    [<c0429420>] (alg_test_hash) from [<c042a414>] (alg_test.part.4+0x264/0x2f8)
    [<c042a414>] (alg_test.part.4) from [<c0426524>] (cryptomgr_test+0x24/0x44)
    [<c0426524>] (cryptomgr_test) from [<c023dcec>] (kthread+0x138/0x150)
    [<c023dcec>] (kthread) from [<c02010d8>] (ret_from_fork+0x14/0x3c)
    Exception stack(0xea54bfb0 to 0xea54bff8)
    bfa0:                                     00000000 00000000
00000000 00000000
    bfc0: 00000000 00000000 00000000 00000000 00000000 00000000
00000000 00000000
    bfe0: 00000000 00000000 00000000 00000000 00000013 00000000
    Code: e58de000 e98d0012 e1a0100c ebfd6712 (e7f001f2)
    ---[ end trace 190b3cf48e720f78 ]---
    BUG: sleeping function called from invalid context at

include/linux/percpu-rwsem.h:34
in_atomic(): 0, irqs_disabled(): 128, pid: 35, name: cryptomgr_test
CPU: 0 PID: 35 Comm: cryptomgr_test Tainted: G D
5.1.0-rc1-koelsch-01109-gbeb7d6376ecfbf07-dirty #397

    Hardware name: Generic R-Car Gen2 (Flattened Device Tree)
    [<c020ec74>] (unwind_backtrace) from [<c020ae58>] (show_stack+0x10/0x14)
    [<c020ae58>] (show_stack) from [<c07c3624>] (dump_stack+0x7c/0x9c)
    [<c07c3624>] (dump_stack) from [<c0242e14>] (___might_sleep+0xf4/0x158)
    [<c0242e14>] (___might_sleep) from [<c0230210>] (exit_signals+0x2c/0x258)
    [<c0230210>] (exit_signals) from [<c0223d6c>] (do_exit+0x114/0xa20)
    [<c0223d6c>] (do_exit) from [<c020b160>] (die+0x304/0x344)
    [<c020b160>] (die) from [<c020b388>] (do_undefinstr+0x80/0x190)
    [<c020b388>] (do_undefinstr) from [<c0201b24>] (__und_svc_finish+0x0/0x3c)
    Exception stack(0xea54bc10 to 0xea54bc58)
    bc00:                                     0000005f 2abb4000
dd6cd422 dd6cd422
    bc20: c09d1120 0000002a 00000000 ea54d00a ea54d009 c0e0ce04
00000000 cccccccd
    bc40: 00000010 ea54bc60 c030fd60 c030fd60 60000013 ffffffff
    [<c0201b24>] (__und_svc_finish) from [<c030fd60>] (usercopy_abort+0x68/0x90)
    [<c030fd60>] (usercopy_abort) from [<c0310060>]
(__check_object_size+0x2d8/0x448)
    [<c0310060>] (__check_object_size) from [<c0427a30>]
(build_test_sglist+0x268/0x2d8)
    [<c0427a30>] (build_test_sglist) from [<c0428c38>]
(test_hash_vec_cfg+0x110/0x694)
    [<c0428c38>] (test_hash_vec_cfg) from [<c0429314>]
(__alg_test_hash+0x158/0x1b8)
    [<c0429314>] (__alg_test_hash) from [<c0429420>] (alg_test_hash+0xac/0xf4)
    [<c0429420>] (alg_test_hash) from [<c042a414>] (alg_test.part.4+0x264/0x2f8)
    [<c042a414>] (alg_test.part.4) from [<c0426524>] (cryptomgr_test+0x24/0x44)
Quoted 9 lines
    [<c0426524>] (cryptomgr_test) from [<c023dcec>] (kthread+0x138/0x150)
    [<c023dcec>] (kthread) from [<c02010d8>] (ret_from_fork+0x14/0x3c)
    Exception stack(0xea54bfb0 to 0xea54bff8)
    bfa0:                                     00000000 00000000
00000000 00000000
    bfc0: 00000000 00000000 00000000 00000000 00000000 00000000
00000000 00000000
    bfe0: 00000000 00000000 00000000 00000000 00000013 00000000

Well, this must happen with the new (in 5.1) crypto self-tests implementation for any crypto algorithm when CONFIG_HARDENED_USERCOPY_PAGESPAN=y. I don't understand why hardened usercopy considers it a bug though, as there's no buffer overflow. The crypto tests use copy_from_iter() to copy data into a 2-page buffer that was allocated with __get_free_pages():

      __get_free_pages(GFP_KERNEL, 1)

... where 1 means an order-1 allocation.

If it copies to offset=4064 len=42, for example, then hardened usercopy considers it a bug even though the buffer is 8192 bytes long. Why?

It isn't actually copying anything to/from userspace, BTW; it's using iov_iter with ITER_KVEC.

- Eric

Quoted 8 lines
Quoted 2 lines

Kees, any thoughts on why hardened usercopy rejects copies spanning a page boundary when they seem to be fine?

This is due to missing the compound page marking, if I remember correctly. However, I tend to leave the pagespan test disabled: it really isn't ready for production use -- there are a lot of missing annotations still.

So do I need to add __GFP_COMP? Is there any actual reason to do so? Why does hardened usercopy check for it?

- Eric

#5 lore raw
Quoted 176 lines · Eric Biggers
Quoted 166 lines · Kees Cook
Quoted 165 lines · Eric Biggers
Quoted 162 lines · Eric Biggers
Quoted 134 lines · Geert Uytterhoeven

When running the sha1-asm crypto selftest on arm with CONFIG_HARDENED_USERCOPY_PAGESPAN=y:

usercopy: Kernel memory overwrite attempt detected to spans
multiple pages (offset 0, size 42)!

    ------------[ cut here ]------------
    kernel BUG at mm/usercopy.c:102!
    Internal error: Oops - BUG: 0 [#1] SMP ARM
    Modules linked in:
    CPU: 0 PID: 35 Comm: cryptomgr_test Not tainted
5.1.0-rc1-koelsch-01109-gbeb7d6376ecfbf07-dirty #397
    Hardware name: Generic R-Car Gen2 (Flattened Device Tree)
    PC is at usercopy_abort+0x68/0x90
    LR is at usercopy_abort+0x68/0x90
    pc : [<c030fd60>]    lr : [<c030fd60>]    psr: 60000013
    sp : ea54bc60  ip : 00000010  fp : cccccccd
    r10: 00000000  r9 : c0e0ce04  r8 : ea54d009
    r7 : ea54d00a  r6 : 00000000  r5 : 0000002a  r4 : c09d1120
    r3 : dd6cd422  r2 : dd6cd422  r1 : 2abb4000  r0 : 0000005f
    Flags: nZCv  IRQs on  FIQs on  Mode SVC_32  ISA ARM  Segment user
    Control: 30c5387d  Table: 40003000  DAC: fffffffd
    Process cryptomgr_test (pid: 35, stack limit = 0x(ptrval))
    Stack: (0xea54bc60 to 0xea54c000)
    bc60: c09d1120 c09d1120 c09d1120 00000000 0000002a 0000002a
00000000 c0310060
    bc80: 0000002a 00000000 000001c0 00000000 00000000 c0eb11e8
ea54cfe0 ea538c00
    bca0: 00000000 ea54cfe0 ebef73e0 0000002a ea538c20 ea54bd84
0000003a c0427a30
    bcc0: ea54bdbc 00000000 00000000 c081cf70 eb074280 c081cf70
0000002a c081cf80
    bce0: 0000000e c07da138 ea54bd0c 00000000 c084061c c04248e8
c0e0a408 eb074240
    bd00: eb074200 c04253c8 eb074280 ea550000 00000012 dd6cd422
ebef7480 eb074200
    bd20: ea54bd84 c081cf64 ea537200 00000002 00000000 00000014
c084061c c0428c38
    bd40: ea54bd84 ea54bdbc c081cd34 00000000 c0e4e4b4 ea538c40
00000002 eabe4e80
    bd60: ea538c00 00000400 ea4f7a00 ea4f7a60 eb074240 00000060
00000006 c09d544c
    bd80: 00000038 00000003 00000000 00000038 ea54bd7c 00000001
eb074200 00000000
    bda0: 00000000 dead4ead ffffffff ffffffff ea54bdb0 ea54bdb0
00000000 c081cf70
    bdc0: c081ce68 c081ce78 ea4f7480 eb000780 00000dc0 eb000780
c0e4ee80 443e9884
    bde0: 6ed23b1c a14aaeba e52951f9 f17046e5 fefefefe fefefefe
fefefefe fefefefe
    be00: eb000780 c04292c4 c0e0a638 60000013 60000013 c0305298
ea4f7a00 c03062bc
    be20: eb000780 00000cc0 ea4f7a00 dd6cd422 00000cc0 ea538c00
00000002 eabe4e40
    be40: ea537200 00000007 00000000 ea4f7a00 eb074200 c0429314
eb074200 ea538c00
    be60: ea4f7a00 0000000a eabe4e80 c084061c c08405fc 00000006
c04dace8 00000006
    be80: 00000000 c084065c ea537200 0000000e 00000400 eb04de08
ea4f71a8 c0429420
    bea0: 00000400 ea537200 0000000e ea537200 0000000e c0429374
00000400 ffffffff
    bec0: 000000a2 c042a414 00000103 c0e0a408 00000000 c0e0a438
c0e5a2a0 c0e5a2a0
    bee0: 00000001 00000001 00000017 ffffe000 00000000 60000013
c0e5a2a0 c0269470
    bf00: c09c9ed0 ea54bf5c 00000103 00000000 00000000 c0e0a408
ea537280 0000000e
    bf20: 00000400 c0426500 00000000 eb04de08 ea4f71a8 c02694f4
c09c9ed0 ea54bf5c
    bf40: ea54bf28 c02699d0 ea54bf5c dd6cd422 ea537200 dd6cd422
c09c9ed0 ea537200
    bf60: ea4af1c0 ea54a000 ea537200 c0426500 00000000 eb04de08
ea4f71a8 c0426524
    bf80: ea4f7180 c023dcec ea54a000 ea4af1c0 c023dbb4 00000000
00000000 00000000
    bfa0: 00000000 00000000 00000000 c02010d8 00000000 00000000
00000000 00000000
    bfc0: 00000000 00000000 00000000 00000000 00000000 00000000
00000000 00000000
    bfe0: 00000000 00000000 00000000 00000000 00000013 00000000
00000000 00000000
    [<c030fd60>] (usercopy_abort) from [<c0310060>]
(__check_object_size+0x2d8/0x448)
    [<c0310060>] (__check_object_size) from [<c0427a30>]
(build_test_sglist+0x268/0x2d8)
    [<c0427a30>] (build_test_sglist) from [<c0428c38>]
(test_hash_vec_cfg+0x110/0x694)
    [<c0428c38>] (test_hash_vec_cfg) from [<c0429314>]
(__alg_test_hash+0x158/0x1b8)
    [<c0429314>] (__alg_test_hash) from [<c0429420>] (alg_test_hash+0xac/0xf4)
    [<c0429420>] (alg_test_hash) from [<c042a414>] (alg_test.part.4+0x264/0x2f8)
    [<c042a414>] (alg_test.part.4) from [<c0426524>] (cryptomgr_test+0x24/0x44)
    [<c0426524>] (cryptomgr_test) from [<c023dcec>] (kthread+0x138/0x150)
    [<c023dcec>] (kthread) from [<c02010d8>] (ret_from_fork+0x14/0x3c)
    Exception stack(0xea54bfb0 to 0xea54bff8)
    bfa0:                                     00000000 00000000
00000000 00000000
    bfc0: 00000000 00000000 00000000 00000000 00000000 00000000
00000000 00000000
    bfe0: 00000000 00000000 00000000 00000000 00000013 00000000
    Code: e58de000 e98d0012 e1a0100c ebfd6712 (e7f001f2)
    ---[ end trace 190b3cf48e720f78 ]---
    BUG: sleeping function called from invalid context at

include/linux/percpu-rwsem.h:34
in_atomic(): 0, irqs_disabled(): 128, pid: 35, name: cryptomgr_test
CPU: 0 PID: 35 Comm: cryptomgr_test Tainted: G D
5.1.0-rc1-koelsch-01109-gbeb7d6376ecfbf07-dirty #397

    Hardware name: Generic R-Car Gen2 (Flattened Device Tree)
    [<c020ec74>] (unwind_backtrace) from [<c020ae58>] (show_stack+0x10/0x14)
    [<c020ae58>] (show_stack) from [<c07c3624>] (dump_stack+0x7c/0x9c)
    [<c07c3624>] (dump_stack) from [<c0242e14>] (___might_sleep+0xf4/0x158)
    [<c0242e14>] (___might_sleep) from [<c0230210>] (exit_signals+0x2c/0x258)
    [<c0230210>] (exit_signals) from [<c0223d6c>] (do_exit+0x114/0xa20)
    [<c0223d6c>] (do_exit) from [<c020b160>] (die+0x304/0x344)
    [<c020b160>] (die) from [<c020b388>] (do_undefinstr+0x80/0x190)
    [<c020b388>] (do_undefinstr) from [<c0201b24>] (__und_svc_finish+0x0/0x3c)
    Exception stack(0xea54bc10 to 0xea54bc58)
    bc00:                                     0000005f 2abb4000
dd6cd422 dd6cd422
    bc20: c09d1120 0000002a 00000000 ea54d00a ea54d009 c0e0ce04
00000000 cccccccd
    bc40: 00000010 ea54bc60 c030fd60 c030fd60 60000013 ffffffff
    [<c0201b24>] (__und_svc_finish) from [<c030fd60>] (usercopy_abort+0x68/0x90)
    [<c030fd60>] (usercopy_abort) from [<c0310060>]
(__check_object_size+0x2d8/0x448)
    [<c0310060>] (__check_object_size) from [<c0427a30>]
(build_test_sglist+0x268/0x2d8)
    [<c0427a30>] (build_test_sglist) from [<c0428c38>]
(test_hash_vec_cfg+0x110/0x694)
    [<c0428c38>] (test_hash_vec_cfg) from [<c0429314>]
(__alg_test_hash+0x158/0x1b8)
    [<c0429314>] (__alg_test_hash) from [<c0429420>] (alg_test_hash+0xac/0xf4)
    [<c0429420>] (alg_test_hash) from [<c042a414>] (alg_test.part.4+0x264/0x2f8)
    [<c042a414>] (alg_test.part.4) from [<c0426524>] (cryptomgr_test+0x24/0x44)
Quoted 9 lines
    [<c0426524>] (cryptomgr_test) from [<c023dcec>] (kthread+0x138/0x150)
    [<c023dcec>] (kthread) from [<c02010d8>] (ret_from_fork+0x14/0x3c)
    Exception stack(0xea54bfb0 to 0xea54bff8)
    bfa0:                                     00000000 00000000
00000000 00000000
    bfc0: 00000000 00000000 00000000 00000000 00000000 00000000
00000000 00000000
    bfe0: 00000000 00000000 00000000 00000000 00000013 00000000

Well, this must happen with the new (in 5.1) crypto self-tests implementation for any crypto algorithm when CONFIG_HARDENED_USERCOPY_PAGESPAN=y. I don't understand why hardened usercopy considers it a bug though, as there's no buffer overflow. The crypto tests use copy_from_iter() to copy data into a 2-page buffer that was allocated with __get_free_pages():

      __get_free_pages(GFP_KERNEL, 1)

... where 1 means an order-1 allocation.

If it copies to offset=4064 len=42, for example, then hardened usercopy considers it a bug even though the buffer is 8192 bytes long. Why?

It isn't actually copying anything to/from userspace, BTW; it's using iov_iter with ITER_KVEC.

- Eric

Quoted 8 lines
Quoted 2 lines

Kees, any thoughts on why hardened usercopy rejects copies spanning a page boundary when they seem to be fine?

This is due to missing the compound page marking, if I remember correctly. However, I tend to leave the pagespan test disabled: it really isn't ready for production use -- there are a lot of missing annotations still.

Quoted 4 lines

So do I need to add __GFP_COMP? Is there any actual reason to do so? Why does hardened usercopy check for it?

- Eric

Hi Kees, any answer to this question?

- Eric

#6 lore raw
Quoted 40 lines · Eric Biggers
Quoted 38 lines · Eric Biggers
Quoted 36 lines · Kees Cook
Quoted 22 lines · Eric Biggers
Quoted 20 lines · Eric Biggers
Quoted 5 lines · Geert Uytterhoeven

When running the sha1-asm crypto selftest on arm with CONFIG_HARDENED_USERCOPY_PAGESPAN=y:

usercopy: Kernel memory overwrite attempt detected to spans
multiple pages (offset 0, size 42)!

Well, this must happen with the new (in 5.1) crypto self-tests implementation for any crypto algorithm when CONFIG_HARDENED_USERCOPY_PAGESPAN=y. I don't understand why hardened usercopy considers it a bug though, as there's no buffer overflow. The crypto tests use copy_from_iter() to copy data into a 2-page buffer that was allocated with __get_free_pages():

      __get_free_pages(GFP_KERNEL, 1)

... where 1 means an order-1 allocation.

If it copies to offset=4064 len=42, for example, then hardened usercopy considers it a bug even though the buffer is 8192 bytes long. Why?

Quoted 7 lines
Quoted 4 lines

It isn't actually copying anything to/from userspace, BTW; it's using iov_iter with ITER_KVEC.

- Eric

Kees, any thoughts on why hardened usercopy rejects copies spanning a page boundary when they seem to be fine?

This is due to missing the compound page marking, if I remember correctly. However, I tend to leave the pagespan test disabled: it really isn't ready for production use -- there are a lot of missing annotations still.

Quoted 6 lines
Quoted 4 lines

So do I need to add __GFP_COMP? Is there any actual reason to do so? Why does hardened usercopy check for it?

- Eric

Hi Kees, any answer to this question?

Hi! Sorry, this got lost in my inbox. Yes, if you can add __GFP_COMP, that would fix this case. No one has had time lately to track down all these cases, but avoiding adding new ones would be wonderful. :)

It's in there because it's a state I'd like to get to in the kernel, but it'll require a lot more work to get there.

Signature · 1 line
Kees Cook
#7 lore raw
Quoted 46 lines · Kees Cook
Quoted 45 lines · Eric Biggers
Quoted 42 lines · Eric Biggers
Quoted 28 lines · Kees Cook
Quoted 27 lines · Eric Biggers
Quoted 24 lines · Eric Biggers
Quoted 5 lines · Geert Uytterhoeven

When running the sha1-asm crypto selftest on arm with CONFIG_HARDENED_USERCOPY_PAGESPAN=y:

usercopy: Kernel memory overwrite attempt detected to spans
multiple pages (offset 0, size 42)!

Well, this must happen with the new (in 5.1) crypto self-tests implementation for any crypto algorithm when CONFIG_HARDENED_USERCOPY_PAGESPAN=y. I don't understand why hardened usercopy considers it a bug though, as there's no buffer overflow. The crypto tests use copy_from_iter() to copy data into a 2-page buffer that was allocated with __get_free_pages():

      __get_free_pages(GFP_KERNEL, 1)

... where 1 means an order-1 allocation.

If it copies to offset=4064 len=42, for example, then hardened usercopy considers it a bug even though the buffer is 8192 bytes long. Why?

It isn't actually copying anything to/from userspace, BTW; it's using iov_iter with ITER_KVEC.

- Eric

Quoted 8 lines
Quoted 2 lines

Kees, any thoughts on why hardened usercopy rejects copies spanning a page boundary when they seem to be fine?

This is due to missing the compound page marking, if I remember correctly. However, I tend to leave the pagespan test disabled: it really isn't ready for production use -- there are a lot of missing annotations still.

So do I need to add __GFP_COMP? Is there any actual reason to do so? Why does hardened usercopy check for it?

- Eric

Quoted 9 lines
Quoted 1 line

Hi Kees, any answer to this question?

Hi! Sorry, this got lost in my inbox. Yes, if you can add __GFP_COMP, that would fix this case. No one has had time lately to track down all these cases, but avoiding adding new ones would be wonderful. :)

It's in there because it's a state I'd like to get to in the kernel, but it'll require a lot more work to get there.

That didn't answer my question. My question is what is the purpose of this? If there was actual buffer overflow when __GFP_COMP isn't specified that would make perfect sense, but AFAICS there isn't. So why does hardened usercopy consider it broken when __GFP_COMP isn't specified?

- Eric

#8 lore raw
Quoted 4 lines · Eric Biggers

That didn't answer my question. My question is what is the purpose of this? If there was actual buffer overflow when __GFP_COMP isn't specified that would make perfect sense, but AFAICS there isn't. So why does hardened usercopy consider it broken when __GFP_COMP isn't specified?

The goal of CONFIG_HARDENED_USERCOPY_PAGESPAN was to detect copies across page boundaries in memory allocated by the page allocator. There appear to be enough cases of allocations that span pages but do not mark them with __GFP_COMP, so this logic hasn't proven useful in the real world (which is why no one should use the ..._PAGESPAN config in production). I'd like to get the kernel to the point where hardened usercopy can correctly do these checks (right now it's mainly only useful at checking for overflows in slub and slab), but it'll take time/focus for a while. No one has had time yet to track all of these down and fix them. (I defer to Laura and Rik on the design of the pagespan checks; they did the bulk of the work there.)

Does that help explain it, or am I still missing your question?

Signature · 1 line
Kees Cook
#9 lore raw
Quoted 18 lines · Kees Cook
Quoted 4 lines · Eric Biggers

That didn't answer my question. My question is what is the purpose of this? If there was actual buffer overflow when __GFP_COMP isn't specified that would make perfect sense, but AFAICS there isn't. So why does hardened usercopy consider it broken when __GFP_COMP isn't specified?

The goal of CONFIG_HARDENED_USERCOPY_PAGESPAN was to detect copies across page boundaries in memory allocated by the page allocator. There appear to be enough cases of allocations that span pages but do not mark them with __GFP_COMP, so this logic hasn't proven useful in the real world (which is why no one should use the ..._PAGESPAN config in production). I'd like to get the kernel to the point where hardened usercopy can correctly do these checks (right now it's mainly only useful at checking for overflows in slub and slab), but it'll take time/focus for a while. No one has had time yet to track all of these down and fix them. (I defer to Laura and Rik on the design of the pagespan checks; they did the bulk of the work there.)

Quoted 4 lines

Does that help explain it, or am I still missing your question?

Signature · 1 line
Kees Cook

You've explained *what* it does again, but not *why*. *Why* do you want hardened usercopy to detect copies across page boundaries, when there is no actual buffer overflow?

- Eric

#10 lore raw
Quoted 3 lines · Eric Biggers

You've explained *what* it does again, but not *why*. *Why* do you want hardened usercopy to detect copies across page boundaries, when there is no actual buffer overflow?

But that *is* how it determines it was a buffer overflow: "if you cross page boundaries (of a non-compound allocation), it *is* a buffer overflow". This assertion, however, is flawed because many contiguous allocations are not marked as being grouped together when it reality they were. It was an attempt to get allocation size information out of the page allocator, similar to how slab can be queries about allocation size. I'm open to improvements here, since it's obviously broken in its current state. :)

Signature · 1 line
Kees Cook
#11 lore raw
Quoted 5 lines · Kees Cook
Quoted 3 lines · Eric Biggers

You've explained *what* it does again, but not *why*. *Why* do you want hardened usercopy to detect copies across page boundaries, when there is no actual buffer overflow?

Quoted 11 lines

But that *is* how it determines it was a buffer overflow: "if you cross page boundaries (of a non-compound allocation), it *is* a buffer overflow". This assertion, however, is flawed because many contiguous allocations are not marked as being grouped together when it reality they were. It was an attempt to get allocation size information out of the page allocator, similar to how slab can be queries about allocation size. I'm open to improvements here, since it's obviously broken in its current state. :)

Signature · 1 line
Kees Cook

Well, I'm still at a loss as to whether I'm actually supposed to "fix" this by adding __GFP_COMP, or whether you're saying the option is broken anyway so I shouldn't bother doing anything. IIUC, even the kernel stack is still not marked __GFP_COMP, so copies to/from the stack can trigger this too, despite this being reported over 2 years ago
(http://lkml.iu.edu/hypermail/linux/kernel/1701.2/01450.html)?
CONFIG_HARDENED_USERCOPY_PAGESPAN is even disabled in syzbot because you already said the option is broken and should not be used.

I worry that people will enable all the hardened usercopy options "because security", then when the pagespan check breaks something they will disable all hardened usercopy options, because they don't understand the individual options. Providing broken options is actively harmful, IMO.

- Eric

#12 lore raw
Quoted 16 lines · Eric Biggers
Quoted 14 lines · Kees Cook
Quoted 3 lines · Eric Biggers

You've explained *what* it does again, but not *why*. *Why* do you want hardened usercopy to detect copies across page boundaries, when there is no actual buffer overflow?

But that *is* how it determines it was a buffer overflow: "if you cross page boundaries (of a non-compound allocation), it *is* a buffer overflow". This assertion, however, is flawed because many contiguous allocations are not marked as being grouped together when it reality they were. It was an attempt to get allocation size information out of the page allocator, similar to how slab can be queries about allocation size. I'm open to improvements here, since it's obviously broken in its current state. :)

Quoted 5 lines
Quoted 2 lines

--
Kees Cook

Well, I'm still at a loss as to whether I'm actually supposed to "fix" this by adding __GFP_COMP, or whether you're saying the option is broken anyway so I

I would love it if you could fix it, yes.

Quoted 6 lines

shouldn't bother doing anything. IIUC, even the kernel stack is still not marked __GFP_COMP, so copies to/from the stack can trigger this too, despite this being reported over 2 years ago
(http://lkml.iu.edu/hypermail/linux/kernel/1701.2/01450.html)?
CONFIG_HARDENED_USERCOPY_PAGESPAN is even disabled in syzbot because you already said the option is broken and should not be used.

stacks are checked before PAGESPAN, so that particular problem should no longer be present since commit 7bff3c069973 ("mm/usercopy.c: no check page span for stack objects").

Quoted 4 lines

I worry that people will enable all the hardened usercopy options "because security", then when the pagespan check breaks something they will disable all hardened usercopy options, because they don't understand the individual options. Providing broken options is actively harmful, IMO.

It's behind EXPERT, default-n, and says:

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.

I'd rather leave it since it's still useful.

Perhaps it could be switched to WARN by default and we reenable it in syzbot to improve its utility there?

mm/usercopy.c +0 -0
index 14faadcedd06..6e7e28fe062b 100644
@@ -208,8 +208,13 @@ static inline void check_page_span(const void

*ptr, unsigned long n,

         */
        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);
+ if (!is_reserved && !is_cma) {
+ usercopy_warn("spans multiple pages without __GFP_COMP",

+                               NULL, to_user,
+                               (unsigned long)ptr & (unsigned long)PAGE_MASK,
+                               n);

+ return;
+ }

        for (ptr += PAGE_SIZE; ptr <= end; ptr += PAGE_SIZE) {
                page = virt_to_head_page(ptr);
Signature · 1 line
Kees Cook
#13 lore raw
Quoted 74 lines · Kees Cook
Quoted 16 lines · Eric Biggers
Quoted 14 lines · Kees Cook
Quoted 3 lines · Eric Biggers

You've explained *what* it does again, but not *why*. *Why* do you want hardened usercopy to detect copies across page boundaries, when there is no actual buffer overflow?

But that *is* how it determines it was a buffer overflow: "if you cross page boundaries (of a non-compound allocation), it *is* a buffer overflow". This assertion, however, is flawed because many contiguous allocations are not marked as being grouped together when it reality they were. It was an attempt to get allocation size information out of the page allocator, similar to how slab can be queries about allocation size. I'm open to improvements here, since it's obviously broken in its current state. :)

Quoted 5 lines
Quoted 2 lines

--
Kees Cook

Well, I'm still at a loss as to whether I'm actually supposed to "fix" this by adding __GFP_COMP, or whether you're saying the option is broken anyway so I

I would love it if you could fix it, yes.

Quoted 6 lines

shouldn't bother doing anything. IIUC, even the kernel stack is still not marked __GFP_COMP, so copies to/from the stack can trigger this too, despite this being reported over 2 years ago
(http://lkml.iu.edu/hypermail/linux/kernel/1701.2/01450.html)?
CONFIG_HARDENED_USERCOPY_PAGESPAN is even disabled in syzbot because you already said the option is broken and should not be used.

stacks are checked before PAGESPAN, so that particular problem should no longer be present since commit 7bff3c069973 ("mm/usercopy.c: no check page span for stack objects").

Quoted 4 lines

I worry that people will enable all the hardened usercopy options "because security", then when the pagespan check breaks something they will disable all hardened usercopy options, because they don't understand the individual options. Providing broken options is actively harmful, IMO.

It's behind EXPERT, default-n, and says:

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.

I'd rather leave it since it's still useful.

Perhaps it could be switched to WARN by default and we reenable it in syzbot to improve its utility there?

mm/usercopy.c +7 -2
index 14faadcedd06..6e7e28fe062b 100644
@@ -208,8 +208,13 @@ static inline void check_page_span(const void
 *ptr, unsigned long n,
         */
        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);
+       if (!is_reserved && !is_cma) {
+               usercopy_warn("spans multiple pages without __GFP_COMP",
+                               NULL, to_user,
+                               (unsigned long)ptr & (unsigned long)PAGE_MASK,
+                               n);
+               return;
+       }
 
        for (ptr += PAGE_SIZE; ptr <= end; ptr += PAGE_SIZE) {
Quoted 5 lines
                page = virt_to_head_page(ptr);
Signature · 1 line
Kees Cook

Well, I guess I'll just add __GFP_COMP so I at least don't get spammed with useless bug reports.

But I don't think it's in any way acceptable to change the semantics of the kernel's page allocator but only under some obscure config option, don't document it anywhere, ignore the known problems for years, say that the option is broken anyway so it shouldn't be used, and have to exchange 15 emails to get anything resembling an explanation.

- Eric

#14 lore raw

PATCH 1/1 crypto: testmgr - allocate buffers with __GFP_COMP

From: Eric Biggers <[email protected]>

This is needed so that CONFIG_HARDENED_USERCOPY_PAGESPAN=y doesn't incorrectly report a buffer overflow when the destination of copy_from_iter() spans the page boundary in the 2-page buffer.

Fixes 3f47a03df6e8 ("crypto: testmgr - add testvec_config struct and helper functions")
---
 crypto/testmgr.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)
crypto/testmgr.c +2 -1
index 0f6bfb6ce6a46..3522c0bed2492 100644
@@ -156,7 +156,8 @@ static int __testmgr_alloc_buf(char *buf[XBUFSIZE], int order)
 	int i;
 
 	for (i = 0; i < XBUFSIZE; i++) {
-		buf[i] = (char *)__get_free_pages(GFP_KERNEL, order);
+		buf[i] = (char *)__get_free_pages(GFP_KERNEL | __GFP_COMP,
+						  order);
 		if (!buf[i])
 			goto err_free_buf;
 	}
Signature · 1 line
2.21.0.392.gf8f6787159e-goog
Reviewed-by on v1 1/1
#15 lore raw

Re: [PATCH] crypto: testmgr - allocate buffers with __GFP_COMP

Quoted 9 lines · Eric Biggers

From: Eric Biggers <[email protected]>

This is needed so that CONFIG_HARDENED_USERCOPY_PAGESPAN=y doesn't incorrectly report a buffer overflow when the destination of copy_from_iter() spans the page boundary in the 2-page buffer.

Fixes 3f47a03df6e8 ("crypto: testmgr - add testvec_config struct and helper functions")
Quoted 9 lines
---
 crypto/testmgr.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)
crypto/testmgr.c +0 -0
index 0f6bfb6ce6a46..3522c0bed2492 100644

crypto/testmgr.c static int __testmgr_alloc_buf(char *buf[XBUFSIZE], int order) · line 160

Quoted 6 lines
crypto/testmgr.c +2 -1
@@ -156,7 +156,8 @@ static int __testmgr_alloc_buf(char *buf[XBUFSIZE], int order)
        int i;
 
        for (i = 0; i < XBUFSIZE; i++) {
-               buf[i] = (char *)__get_free_pages(GFP_KERNEL, order);
+               buf[i] = (char *)__get_free_pages(GFP_KERNEL | __GFP_COMP,
+                                                 order);

Is there a reason __GFP_COMP isn't automatically included in all page allocations? (Or rather, it seems like the exception is when things should NOT be considered part of the same allocation, so something like __GFP_SINGLE should exist?.)

-Kees

Quoted 6 lines
crypto/testmgr.c +0 -1
                if (!buf[i])
                        goto err_free_buf;
        }
--

2.21.0.392.gf8f6787159e-goog

Signature · 1 line
Kees Cook
#16 lore raw

Re: [PATCH] crypto: testmgr - allocate buffers with __GFP_COMP

Quoted 25 lines · Kees Cook
Quoted 9 lines · Eric Biggers

From: Eric Biggers <[email protected]>

This is needed so that CONFIG_HARDENED_USERCOPY_PAGESPAN=y doesn't incorrectly report a buffer overflow when the destination of copy_from_iter() spans the page boundary in the 2-page buffer.

Fixes 3f47a03df6e8 ("crypto: testmgr - add testvec_config struct and helper functions")
Quoted 11 lines
---
 crypto/testmgr.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)
crypto/testmgr.c +0 -0
index 0f6bfb6ce6a46..3522c0bed2492 100644
@@ -156,7 +156,8 @@ static int __testmgr_alloc_buf(char *buf[XBUFSIZE], int order)
        int i;
 
Quoted 9 lines

crypto/testmgr.c static int __testmgr_alloc_buf(char *buf[XBUFSIZE], int order) · line 160

Quoted 4 lines
crypto/testmgr.c +2 -1
        for (i = 0; i < XBUFSIZE; i++) {
-               buf[i] = (char *)__get_free_pages(GFP_KERNEL, order);
+               buf[i] = (char *)__get_free_pages(GFP_KERNEL | __GFP_COMP,
+                                                 order);

Is there a reason __GFP_COMP isn't automatically included in all page allocations? (Or rather, it seems like the exception is when things should NOT be considered part of the same allocation, so something like __GFP_SINGLE should exist?.)

It would be reasonable if __get_free_pages would automatically mark consecutive pages as consecutive.
When these should not be considered part of the same allocation? Is it possible to free them separately? Will that BUG with __GFP_COMP mark? I understand that there can be a weak "these are actually the same allocation, but I would like to think about them as separate". But potentially we can ignore such cases.

Quoted 12 lines

-Kees

Quoted 6 lines
crypto/testmgr.c +0 -1
                if (!buf[i])
                        goto err_free_buf;
        }
--

2.21.0.392.gf8f6787159e-goog

--
Kees Cook

#17 lore raw

Re: [PATCH] crypto: testmgr - allocate buffers with __GFP_COMP

In reply to Kees Cook
Quoted 12 lines · Kees Cook

crypto/testmgr.c static int __testmgr_alloc_buf(char *buf[XBUFSIZE], int order) · line 160

Quoted 7 lines
crypto/testmgr.c +2 -1
@@ -156,7 +156,8 @@ static int __testmgr_alloc_buf(char *buf[XBUFSIZE], int order)
        int i;
 
        for (i = 0; i < XBUFSIZE; i++) {
-               buf[i] = (char *)__get_free_pages(GFP_KERNEL, order);
+               buf[i] = (char *)__get_free_pages(GFP_KERNEL | __GFP_COMP,
+                                                 order);

Is there a reason __GFP_COMP isn't automatically included in all page allocations? (Or rather, it seems like the exception is when things should NOT be considered part of the same allocation, so something like __GFP_SINGLE should exist?.)

The question is not whether or not things should be considered part of the same allocation. The question is whether the allocation is of a compound page or of N consecutive pages. Now you're asking what the difference is, and it's whether you need to be able to be able to call compound_head(), compound_order(), PageTail() or use a compound_dtor. If you don't, then you can save some time at allocation & free by not specifying __GFP_COMP.

I'll agree this is not documented well, and maybe most multi-page allocations do want __GFP_COMP and we should invert that bit, but __GFP_SINGLE doesn't seem like the right antonym to __GFP_COMP to me.

maintainer
#18 lore raw

Re: [PATCH] crypto: testmgr - allocate buffers with __GFP_COMP

Quoted 14 lines · Matthew Wilcox
Quoted 12 lines · Kees Cook

crypto/testmgr.c static int __testmgr_alloc_buf(char *buf[XBUFSIZE], int order) · line 160

Quoted 7 lines
crypto/testmgr.c +2 -1
@@ -156,7 +156,8 @@ static int __testmgr_alloc_buf(char *buf[XBUFSIZE], int order)
        int i;
 
        for (i = 0; i < XBUFSIZE; i++) {
-               buf[i] = (char *)__get_free_pages(GFP_KERNEL, order);
+               buf[i] = (char *)__get_free_pages(GFP_KERNEL | __GFP_COMP,
+                                                 order);

Is there a reason __GFP_COMP isn't automatically included in all page allocations? (Or rather, it seems like the exception is when things should NOT be considered part of the same allocation, so something like __GFP_SINGLE should exist?.)

Quoted 6 lines

The question is not whether or not things should be considered part of the same allocation. The question is whether the allocation is of a compound page or of N consecutive pages. Now you're asking what the difference is, and it's whether you need to be able to be able to call compound_head(), compound_order(), PageTail() or use a compound_dtor. If you don't, then you can save some time at allocation & free by not specifying __GFP_COMP.

Thanks for clarifying Matthew.

Eric, this means that we should not use __GFP_COMP here just to silent what is clearly a broken warning.

Cheers,

Signature · 3 lines
Email: Herbert Xu <[email protected]>
Home Page: http://gondor.apana.org.au/~herbert/
PGP Key: http://gondor.apana.org.au/~herbert/pubkey.txt
#19 lore raw

Re: [PATCH] crypto: testmgr - allocate buffers with __GFP_COMP

Quoted 22 lines · Herbert Xu
Quoted 14 lines · Matthew Wilcox
Quoted 12 lines · Kees Cook

crypto/testmgr.c static int __testmgr_alloc_buf(char *buf[XBUFSIZE], int order) · line 160

Quoted 7 lines
crypto/testmgr.c +2 -1
@@ -156,7 +156,8 @@ static int __testmgr_alloc_buf(char *buf[XBUFSIZE], int order)
        int i;
 
        for (i = 0; i < XBUFSIZE; i++) {
-               buf[i] = (char *)__get_free_pages(GFP_KERNEL, order);
+               buf[i] = (char *)__get_free_pages(GFP_KERNEL | __GFP_COMP,
+                                                 order);

Is there a reason __GFP_COMP isn't automatically included in all page allocations? (Or rather, it seems like the exception is when things should NOT be considered part of the same allocation, so something like __GFP_SINGLE should exist?.)

Quoted 6 lines

The question is not whether or not things should be considered part of the same allocation. The question is whether the allocation is of a compound page or of N consecutive pages. Now you're asking what the difference is, and it's whether you need to be able to be able to call compound_head(), compound_order(), PageTail() or use a compound_dtor. If you don't, then you can save some time at allocation & free by not specifying __GFP_COMP.

Quoted 4 lines

Thanks for clarifying Matthew.

Eric, this means that we should not use __GFP_COMP here just to silent what is clearly a broken warning.

I agree; if the crypto code is never going to try to go from the address of a byte in the allocation back to the head page, then there's no need to specify GFP_COMP.

But that leaves us in the awkward situation where HARDENED_USERCOPY_PAGESPAN does need to be able to figure out whether 'ptr + n - 1' lies within the same allocation as ptr. Without using a compound page, there's no indication in the VM structures that these two pages were allocated as part of the same allocation.

We could force all multi-page allocations to be compound pages if HARDENED_USERCOPY_PAGESPAN is enabled, but I worry that could break something. We could make it catch fewer problems by succeeding if the page is not compound. I don't know, these all seem like bad choices to me.

#20 lore raw

Re: [PATCH] crypto: testmgr - allocate buffers with __GFP_COMP

Quoted 10 lines · Matthew Wilcox

I agree; if the crypto code is never going to try to go from the address of a byte in the allocation back to the head page, then there's no need to specify GFP_COMP.

But that leaves us in the awkward situation where HARDENED_USERCOPY_PAGESPAN does need to be able to figure out whether 'ptr + n - 1' lies within the same allocation as ptr. Without using a compound page, there's no indication in the VM structures that these two pages were allocated as part of the same allocation.

Quoted 5 lines

We could force all multi-page allocations to be compound pages if HARDENED_USERCOPY_PAGESPAN is enabled, but I worry that could break something. We could make it catch fewer problems by succeeding if the page is not compound. I don't know, these all seem like bad choices to me.

If GFP_COMP is _not_ the correct signal about adjacent pages being part of the same allocation, then I agree: we need to drop this check entirely from PAGESPAN. Is there anything else that indicates this property? (Or where might we be able to store that info?)

There are other pagespan checks, though, so those could stay. But I'd really love to gain page allocator allocation size checking ...

Signature · 1 line
Kees Cook
#21 lore raw

Re: [PATCH] crypto: testmgr - allocate buffers with __GFP_COMP

Quoted 17 lines · Kees Cook
Quoted 10 lines · Matthew Wilcox

I agree; if the crypto code is never going to try to go from the address of a byte in the allocation back to the head page, then there's no need to specify GFP_COMP.

But that leaves us in the awkward situation where HARDENED_USERCOPY_PAGESPAN does need to be able to figure out whether 'ptr + n - 1' lies within the same allocation as ptr. Without using a compound page, there's no indication in the VM structures that these two pages were allocated as part of the same allocation.

Quoted 5 lines

We could force all multi-page allocations to be compound pages if HARDENED_USERCOPY_PAGESPAN is enabled, but I worry that could break something. We could make it catch fewer problems by succeeding if the page is not compound. I don't know, these all seem like bad choices to me.

Quoted 4 lines

If GFP_COMP is _not_ the correct signal about adjacent pages being part of the same allocation, then I agree: we need to drop this check entirely from PAGESPAN. Is there anything else that indicates this property? (Or where might we be able to store that info?)

As far as I know, the page allocator does not store size information anywhere, unless you use GFP_COMP. That's why you have to pass the 'order' to free_pages() and __free_pages(). It's also why alloc_pages_exact() works (follow all the way into split_page()).

Quoted 2 lines

There are other pagespan checks, though, so those could stay. But I'd really love to gain page allocator allocation size checking ...

I think that's a great idea, but I'm not sure how you'll be able to do that.

#22 lore raw

Re: [PATCH] crypto: testmgr - allocate buffers with __GFP_COMP

Quoted 28 lines · Matthew Wilcox
Quoted 17 lines · Kees Cook
Quoted 10 lines · Matthew Wilcox

I agree; if the crypto code is never going to try to go from the address of a byte in the allocation back to the head page, then there's no need to specify GFP_COMP.

But that leaves us in the awkward situation where HARDENED_USERCOPY_PAGESPAN does need to be able to figure out whether 'ptr + n - 1' lies within the same allocation as ptr. Without using a compound page, there's no indication in the VM structures that these two pages were allocated as part of the same allocation.

Quoted 5 lines

We could force all multi-page allocations to be compound pages if HARDENED_USERCOPY_PAGESPAN is enabled, but I worry that could break something. We could make it catch fewer problems by succeeding if the page is not compound. I don't know, these all seem like bad choices to me.

Quoted 4 lines

If GFP_COMP is _not_ the correct signal about adjacent pages being part of the same allocation, then I agree: we need to drop this check entirely from PAGESPAN. Is there anything else that indicates this property? (Or where might we be able to store that info?)

As far as I know, the page allocator does not store size information anywhere, unless you use GFP_COMP. That's why you have to pass the 'order' to free_pages() and __free_pages(). It's also why alloc_pages_exact() works (follow all the way into split_page()).

Quoted 5 lines
Quoted 2 lines

There are other pagespan checks, though, so those could stay. But I'd really love to gain page allocator allocation size checking ...

I think that's a great idea, but I'm not sure how you'll be able to do that.

However, we have had code (maybe historically now) that has allocated a higher order page and then handed back pages that it doesn't need - for example, when the code requires multiple contiguous pages but does not require a power-of-2 size of contiguous pages.

Signature · 3 lines
RMK's Patch system: https://www.armlinux.org.uk/developer/patches/
FTTC broadband for 0.8mile line in suburbia: sync at 12.1Mbps down 622kbps up
According to speedtest.net: 11.9Mbps down 500kbps up
#23 lore raw

Re: [PATCH] crypto: testmgr - allocate buffers with __GFP_COMP

Quoted 32 lines · Russell King - ARM Linux admin
Quoted 31 lines · Matthew Wilcox
Quoted 17 lines · Kees Cook
Quoted 10 lines · Matthew Wilcox

I agree; if the crypto code is never going to try to go from the address of a byte in the allocation back to the head page, then there's no need to specify GFP_COMP.

But that leaves us in the awkward situation where HARDENED_USERCOPY_PAGESPAN does need to be able to figure out whether 'ptr + n - 1' lies within the same allocation as ptr. Without using a compound page, there's no indication in the VM structures that these two pages were allocated as part of the same allocation.

Quoted 5 lines

We could force all multi-page allocations to be compound pages if HARDENED_USERCOPY_PAGESPAN is enabled, but I worry that could break something. We could make it catch fewer problems by succeeding if the page is not compound. I don't know, these all seem like bad choices to me.

Quoted 4 lines

If GFP_COMP is _not_ the correct signal about adjacent pages being part of the same allocation, then I agree: we need to drop this check entirely from PAGESPAN. Is there anything else that indicates this property? (Or where might we be able to store that info?)

As far as I know, the page allocator does not store size information anywhere, unless you use GFP_COMP. That's why you have to pass the 'order' to free_pages() and __free_pages(). It's also why alloc_pages_exact() works (follow all the way into split_page()).

Quoted 2 lines

There are other pagespan checks, though, so those could stay. But I'd really love to gain page allocator allocation size checking ...

Quoted 7 lines
Quoted 2 lines

I think that's a great idea, but I'm not sure how you'll be able to do that.

However, we have had code (maybe historically now) that has allocated a higher order page and then handed back pages that it doesn't need - for example, when the code requires multiple contiguous pages but does not require a power-of-2 size of contiguous pages.

'git grep alloc_pages_exact' suggests it's not historical yet...

Robin.

#24 lore raw
In reply to Eric Biggers
Quoted 2 lines · Eric Biggers

Well, I guess I'll just add __GFP_COMP so I at least don't get spammed with useless bug reports.

Thanks, I appreciate it.

Quoted 5 lines

But I don't think it's in any way acceptable to change the semantics of the kernel's page allocator but only under some obscure config option, don't document it anywhere, ignore the known problems for years, say that the option is broken anyway so it shouldn't be used, and have to exchange 15 emails to get anything resembling an explanation.

I understand what you mean, yeah. I'm sorry I wasn't clear about it earlier. What do you think might help the situation as far as documentation?

Signature · 1 line
Kees Cook
#25 lore raw
Quoted 12 lines · Kees Cook
Quoted 2 lines · Eric Biggers

Well, I guess I'll just add __GFP_COMP so I at least don't get spammed with useless bug reports.

Thanks, I appreciate it.

Quoted 5 lines

But I don't think it's in any way acceptable to change the semantics of the kernel's page allocator but only under some obscure config option, don't document it anywhere, ignore the known problems for years, say that the option is broken anyway so it shouldn't be used, and have to exchange 15 emails to get anything resembling an explanation.

Quoted 4 lines

I understand what you mean, yeah. I'm sorry I wasn't clear about it earlier. What do you think might help the situation as far as documentation?

Explanation in Documentation/core-api/memory-allocation.rst of when to use __GFP_COMP and why. Where "why" includes the real underlying reason why it's designed the way it is, not just "you now need to provide this flag in order to stop the hardened usercopy thing from crashing, even though previously it meant something else, because that's the way it is."

Also a brief, improved explanation of __GFP_COMP in include/linux/gfp.h.

Also get Documentation/security/self-protection.rst up to date with what's actually in the kernel. Currently it doesn't mention hardened usercopy at all, and it's unclear about what's supported now vs. what is future work.

And actually fix the known problems with the pagespan check, not ignore them for years. If not feasible, remove the option.

- Eric

_______________________________________________
linux-arm-kernel mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

#26 lore raw
In reply to Eric Biggers
Quoted 5 lines · Eric Biggers

You've explained *what* it does again, but not *why*. *Why* do you want
hardened usercopy to detect copies across page boundaries, when there is no
actual buffer overflow?

When some subsystem in the kernel allocates multiple pages without _GFP_COMP, there is no way afterwards to detect exactly how many pages it allocated.

In other words, there is no way to see how large the buffer is, nor whether the copy operation in question would overflow it.

Signature · 1 line
All Rights Reversed.