lkml.org 
[lkml]   [2019]   [May]   [31]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
/
Date
From
SubjectRe: [PATCH 4.19 079/276] x86/modules: Avoid breaking W^X while loading modules
Hi!

> [ Upstream commit f2c65fb3221adc6b73b0549fc7ba892022db9797 ]
>
> When modules and BPF filters are loaded, there is a time window in
> which some memory is both writable and executable. An attacker that has
> already found another vulnerability (e.g., a dangling pointer) might be
> able to exploit this behavior to overwrite kernel code. Prevent having
> writable executable PTEs in this stage.
>
> In addition, avoiding having W+X mappings can also slightly simplify the
> patching of modules code on initialization (e.g., by alternatives and
> static-key), as would be done in the next patch. This was actually the
> main motivation for this patch.
>
> To avoid having W+X mappings, set them initially as RW (NX) and after
> they are set as RO set them as X as well. Setting them as executable is
> done as a separate step to avoid one core in which the old PTE is cached
> (hence writable), and another which sees the updated PTE (executable),
> which would break the W^X protection.

First, is this stable material? Yes, it changes something.

But if you assume attacker can write into kernel memory during module
load, what prevents him to change the module as he sees fit while it
is not executable, simply waiting for system to execute it?

I don't see security benefit here.

> +++ b/arch/x86/kernel/alternative.c
> @@ -662,15 +662,29 @@ void __init alternative_instructions(void)
> * handlers seeing an inconsistent instruction while you patch.
> */
> void *__init_or_module text_poke_early(void *addr, const void *opcode,
> - size_t len)
> + size_t len)
> {
> unsigned long flags;
> - local_irq_save(flags);
> - memcpy(addr, opcode, len);
> - local_irq_restore(flags);
> - sync_core();
> - /* Could also do a CLFLUSH here to speed up CPU recovery; but
> - that causes hangs on some VIA CPUs. */
> +
> + if (boot_cpu_has(X86_FEATURE_NX) &&
> + is_module_text_address((unsigned long)addr)) {
> + /*
> + * Modules text is marked initially as non-executable, so the
> + * code cannot be running and speculative code-fetches are
> + * prevented. Just change the code.
> + */
> + memcpy(addr, opcode, len);
> + } else {
> + local_irq_save(flags);
> + memcpy(addr, opcode, len);
> + local_irq_restore(flags);
> + sync_core();
> +
> + /*
> + * Could also do a CLFLUSH here to speed up CPU recovery; but
> + * that causes hangs on some VIA CPUs.
> + */

I don't get it. If code can not be running here, it can not be running
in the !NX case, either, and we are free to just change
it. Speculative execution should not be a problem, either, as CPUs are
supposed to mask it, and there are no known bugs in that area. (Plus,
I'd not be surprise if speculative execution ignored NX... just saying
:-) )


Pavel
--
(english) http://www.livejournal.com/~pavelmachek
(cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
[unhandled content-type:application/pgp-signature]
\
 
 \ /
  Last update: 2019-05-31 12:37    [W:0.648 / U:7.000 seconds]
©2003-2018 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site