{"id":1494,"date":"2021-02-08T16:47:47","date_gmt":"2021-02-09T00:47:47","guid":{"rendered":"https:\/\/outflux.net\/blog\/?p=1494"},"modified":"2022-04-04T15:50:02","modified_gmt":"2022-04-04T22:50:02","slug":"security-things-in-linux-v5-8","status":"publish","type":"post","link":"https:\/\/outflux.net\/blog\/archives\/2021\/02\/08\/security-things-in-linux-v5-8\/","title":{"rendered":"security things in Linux v5.8"},"content":{"rendered":"

Previously: v5.7<\/a><\/p>\n

Linux v5.8 was released in August, 2020<\/a>. Here\u2019s my summary of various security things that caught my attention:<\/p>\n

arm64 Branch Target Identification<\/strong>
\nDave Martin added support for ARMv8.5’s Branch Target Instructions<\/a> (BTI<\/a>), which are enabled in userspace at execve()<\/a> time, and all the time in the kernel<\/a> (which required manually marking up a lot of non-C code, like assembly and JIT code<\/a>).<\/p>\n

With this in place, Jump-Oriented Programming (JOP, where code gadgets are chained together with jumps and calls) is no longer available to the attacker. An attacker’s code must make direct function calls. This basically reduces the “usable” code available to an attacker from every word in the kernel text to only function entries (or jump targets). This is a “low granularity” forward-edge Control Flow Integrity (CFI) feature, which is important (since it greatly reduces the potential targets that can be used in an attack) and cheap (implemented in hardware). It’s a good first step to strong CFI, but (as we’ve seen with things like CFG) it isn’t usually strong enough to stop a motivated attacker. “High granularity” CFI (which uses a more specific branch-target characteristic, like function prototypes, to track expected call sites) is not yet a hardware supported feature, but the software version will be coming in the future by way of Clang’s CFI implementation<\/a>.<\/p>\n

arm64 Shadow Call Stack<\/strong>
\nSami Tolvanen landed the kernel implementation of Clang’s Shadow Call Stack<\/a> (SCS<\/a>), which protects the kernel against Return-Oriented Programming (ROP) attacks (where code gadgets are chained together with returns). This backward-edge CFI protection is implemented by keeping a second dedicated stack pointer register (x18<\/code>) and keeping a copy of the return addresses stored in a separate “shadow stack”. In this way, manipulating the regular stack’s return addresses will have no effect. (And since a copy of the return address continues to live in the regular stack, no changes are needed for back trace dumps, etc.)<\/p>\n

It’s worth noting that unlike BTI (which is hardware based), this is a software defense that relies on the location of the Shadow Stack (i.e. the value of x18<\/code>) staying secret, since the memory could be written to directly. Intel’s hardware ROP defense (CET) uses a hardware shadow stack that isn’t directly writable. ARM’s hardware defense against ROP is PAC<\/a> (which is actually designed as an arbitrary CFI defense — it can be used for forward-edge too), but that depends on having ARMv8.3 hardware. The expectation is that SCS will be used until PAC is available.<\/p>\n

Kernel Concurrency Sanitizer infrastructure added<\/strong>
\nMarco Elver landed support for the Kernel Concurrency Sanitizer<\/a>, which is a new debugging infrastructure to find data races in the kernel, via CONFIG_KCSAN<\/code>. This immediately found real bugs, with some fixes having already<\/a> landed<\/a> too. For more details, see the KCSAN documentation<\/a>.<\/p>\n

new capabilities<\/strong>
\nAlexey Budankov added CAP_PERFMON<\/code><\/a>, which is designed to allow access to perf()<\/code>. The idea is that this capability gives a process access to only read aspects of the running kernel and system. No longer will access be needed through the much more powerful abilities of CAP_SYS_ADMIN<\/code>, which has many ways to change kernel internals. This allows for a split between controls over the confidentiality (read access via CAP_PERFMON) of the kernel vs control over integrity (write access via CAP_SYS_ADMIN).<\/p>\n

Alexei Starovoitov added CAP_BPF<\/code><\/a>, which is designed to separate BPF access from the all-powerful CAP_SYS_ADMIN<\/code>. It is designed to be used in combination with CAP_PERFMON<\/code> for tracing-like activities and CAP_NET_ADMIN<\/code> for networking-related activities. For things that could change kernel integrity (i.e. write access), CAP_SYS_ADMIN<\/code> is still required.<\/p>\n

network random number generator improvements<\/strong>
\nWilly Tarreau made the network code’s random number generator less predictable<\/a>. This will further frustrate any attacker’s attempts to recover the state of the RNG externally, which might lead to the ability to hijack network sessions (by correctly guessing packet states).<\/p>\n

fix various kernel address exposures to non-CAP_SYSLOG<\/code><\/strong>
\nI fixed several situations where kernel addresses were still being exposed to unprivileged (i.e. non-CAP_SYSLOG<\/code>) users, though usually only through odd corner cases. After refactoring how capabilities were being checked<\/a> for files in \/sys<\/code> and \/proc<\/code>, the kernel modules sections<\/a>, kprobes<\/a>, and BPF<\/a> exposures got fixed. (Though in doing so, I briefly made things much worse before getting it properly fixed<\/a>. Yikes!)<\/p>\n

RISCV W^X detection<\/strong>
\nFollowing up on his recent work to enable strict kernel memory protections on RISCV<\/a>, Zong Li has now added support for CONFIG_DEBUG_WX<\/code><\/a> as seen for other architectures. Any writable and executable memory regions in the kernel (which are lovely targets for attackers) will be loudly noted at boot so they can get corrected.<\/p>\n

execve()<\/code> refactoring continues<\/strong>
\nEric W. Biederman continued working on execve()<\/code> refactoring<\/a>, including getting rid of the frequently problematic recursion<\/a> used to locate binary handlers. I used the opportunity to dust off some old binfmt_script<\/code> regression tests<\/a> and get them into the kernel selftests.<\/p>\n

multiple \/proc<\/code> instances<\/strong>
\nAlexey Gladkov modernized \/proc<\/code> internals and provided a way to have multiple \/proc<\/code> instances<\/a> mounted in the same PID namespace. This allows for having multiple views of \/proc<\/code>, with different features enabled. (Including the newly added hidepid=4<\/a> and subset=pid<\/a> mount options<\/a>.)<\/p>\n

set_fs()<\/code> removal continues<\/strong>
\nChristoph Hellwig, with Eric W. Biederman, Arnd Bergmann, and others, have been diligently working to entirely remove the kernel’s set_fs()<\/code> interface, which has long been a source of security flaws due to weird confusions about which address space the kernel thought it should be accessing. Beyond things like the lower-level per-architecture signal handling<\/a> code, this has needed to touch various parts<\/a> of the ELF<\/a> loader, and networking<\/a> code too.<\/p>\n

READ_IMPLIES_EXEC<\/code> is no more for native 64-bit<\/strong>
\nThe READ_IMPLIES_EXEC<\/code> flag was a work-around for dealing with the addition of non-executable (NX) memory when x86_64 was introduced. It was designed as a way to mark a memory region as “well, since we don’t know if this memory region was expected to be executable, we must assume that if we need to read it, we need to be allowed to execute it too”. It was designed mostly for stack memory (where trampoline code might live), but it would carry over into all mmap()<\/code> allocations, which would mean sometimes exposing a large attack surface to an attacker looking to find executable memory. While normally this didn’t cause problems on modern systems that correctly marked their ELF sections as NX, there were still some awkward corner-cases. I fixed this by splitting READ_IMPLIES_EXEC<\/code> from the ELF PT_GNU_STACK<\/code> marking on x86<\/a> and arm\/arm64<\/a>, and declaring that a native 64-bit process would never gain READ_IMPLIES_EXEC<\/code> on x86_64<\/a> and arm64<\/a>, which matches the behavior of other native 64-bit architectures that correctly didn’t ever implement READ_IMPLIES_EXEC<\/code> in the first place.<\/p>\n

array index bounds checking continues<\/strong>
\nAs part of the ongoing work to use modern flexible arrays in the kernel, Gustavo A. R. Silva added the flex_array_size()<\/code> helper<\/a> (as a cousin to struct_size()<\/code>). The zero\/one-member into flex array conversions<\/a> continue with over a hundred commits as we slowly get closer to being able to build with -Warray-bounds<\/code>.<\/p>\n

scnprintf()<\/code> replacement continues<\/strong>
\nChen Zhou joined Takashi Iwai in continuing<\/a> to replace potentially unsafe uses of sprintf()<\/code> with scnprintf()<\/code>. Fixing all of these will make sure the kernel avoids nasty buffer concatenation surprises.<\/p>\n

That’s it for now! Let me know if there is anything else you think I should mention here. Next up: Linux v5.9<\/a>.<\/p>\n

© 2021 – 2022, Kees Cook<\/a>. This work is licensed under a Creative Commons Attribution-ShareAlike 4.0 License<\/a>.
\"CC<\/a> <\/p>\n","protected":false},"excerpt":{"rendered":"

Previously: v5.7 Linux v5.8 was released in August, 2020. Here\u2019s my summary of various security things that caught my attention: arm64 Branch Target Identification Dave Martin added support for ARMv8.5’s Branch Target Instructions (BTI), which are enabled in userspace at execve() time, and all the time in the kernel (which required manually marking up a […]<\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[5,20,18,21,6,14,19],"tags":[],"_links":{"self":[{"href":"https:\/\/outflux.net\/blog\/wp-json\/wp\/v2\/posts\/1494"}],"collection":[{"href":"https:\/\/outflux.net\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/outflux.net\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/outflux.net\/blog\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/outflux.net\/blog\/wp-json\/wp\/v2\/comments?post=1494"}],"version-history":[{"count":35,"href":"https:\/\/outflux.net\/blog\/wp-json\/wp\/v2\/posts\/1494\/revisions"}],"predecessor-version":[{"id":1573,"href":"https:\/\/outflux.net\/blog\/wp-json\/wp\/v2\/posts\/1494\/revisions\/1573"}],"wp:attachment":[{"href":"https:\/\/outflux.net\/blog\/wp-json\/wp\/v2\/media?parent=1494"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/outflux.net\/blog\/wp-json\/wp\/v2\/categories?post=1494"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/outflux.net\/blog\/wp-json\/wp\/v2\/tags?post=1494"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}