Kernel-hardening archive on lore.kernel.org
 help / color / Atom feed
From: "Reshetova, Elena" <elena.reshetova@intel.com>
To: "Perla, Enrico" <enrico.perla@intel.com>,
	Andy Lutomirski <luto@amacapital.net>,
	"keescook@chromium.org" <keescook@chromium.org>,
	Jann Horn <jannh@google.com>
Cc: Andy Lutomirski <luto@kernel.org>,
	Peter Zijlstra <peterz@infradead.org>,
	"kernel-hardening@lists.openwall.com"
	<kernel-hardening@lists.openwall.com>,
	"tglx@linutronix.de" <tglx@linutronix.de>,
	"mingo@redhat.com" <mingo@redhat.com>,
	"bp@alien8.de" <bp@alien8.de>, "tytso@mit.edu" <tytso@mit.edu>
Subject: RE: [RFC PATCH] x86/entry/64: randomize kernel stack offset upon system call
Date: Thu, 14 Feb 2019 07:52:07 +0000
Message-ID: <2236FBA76BA1254E88B949DDB74E612BA4BC57C1@IRSMSX102.ger.corp.intel.com> (raw)
In-Reply-To: <5E269FBC3009974381A340959F3135C95C8F78E5@hasmsx108.ger.corp.intel.com>

After some thinking and discussions, let me try to summarize the options and the
security benefits of each approach based on everyone else feedback before
going any further with work. We all want only useful things in kernel, so merging
smth that provides a subtle/almost non-existing benefit is clearly not a priority. 

So, first about the protection methods. We can do randomization in two ways:

1. stack top itself (and location of pt_regs) 
2. relative stack positioning (offset from pt_regs).

In addition to randomization we can do some fixup on exit, like Andy proposed:

3. Make sure CS always points to user on exit (for example by regs->cs |= 3),
potentially smth else can be fixed up similarly, if needed

Here are *known* (at least to me, please shout if you know more!) possible
attacks vectors and implications on them by doing 1), 2) or 3)

a) attacker's goal is to store some user-controlled data in pt_regs to reference it later
  1) pt_regs is not predictable, but can be discovered in ptrace-style scenario or cache-probing.
     If discovered, then attack succeeds as of now.
  2) nothing changed for this type of attack, attack succeeds as of now
  3) nothing changed for this type of attack, attack succeeds as of now

b) attacker's goal is to return to userland from a syscall with CS pointing to kernel
 1) pt_regs is not predictable, but can be discovered in ptrace-style scenario or cache-probing.
     If discovered, then attack succeeds as of now.
 2) nothing changed for this type of attack, attack succeeds as of now
 3) CS changed explicitly on exit, so impossible to have this attack, *given* that the
    change is done late enough and no races, sleeps, etc. are possible

c) attacker's goal is to perform some kind of stack overflow into parts of adjusted stack 
  memory via some method. Here the main unknown is the "method".
This vector of attack is the challenge for the current exploit writers: I guess if you can do
it now with all the current protections for stack enabled, you get a nice defcon talk at least :) 
VLA used to be an easy way of doing it, hopefully they are gone from the main source now
(out of tree drivers is a different story). 
Uninitialized locals might be other way, but there is work ongoing to close this (see Kees's
patches on stackinit).
Smth else we don’t yet know? 
Now back to our proposed countermeasures given that attacker has found a way to do
a crafted overflow and overwrite:

  1) pt_regs is not predictable, but can be discovered in ptrace-style scenario or cache-probing.
     If discovered, then attack succeeds as of now. 
  2) relative stack offset is not predictable and randomized, cannot be probed very easily via 
      cache or ptrace. So, this is an additional hurdle on the attacker's way since stack is non-
      deterministic now.
  3) nothing changed for this type of attack, given that attacker's goal is not to overwrite CS
      in adjusted pt_regs. If it is his goal, then it helps with that. 


Now summary:

It would seem to me that:

- regs->cs |= 3 on exit is a thing worth doing anyway, just because it is cheap, as Andy said, and it 
might make a positive difference in two out of three attack scenarios. Objections?

- randomization of stack top is only worth doing in ptrace-blocked scenario. 
Do we have such scenarios left that people care about? 
Because if we do, then we know that there is a real attack vector that we close this way, otherwise not. 
This is actually interesting, because we need to remember to take ptrace into our overall
kernel hardening threat model (smth that at least I haven't quite realized before) and evaluate every new
feature (especially randomization ones) being robust against ptrace probing. 

- randomization after pt_regs only would make a difference in attack scenario "c", for which 
  we don't yet have a proof of concept exploit or technique that would work (does not guarantee that
attackers don't have the exploits ready through :( ). 
So, if we implement this, the "justification part" for the feature would be smth like "to make it
harder for future possible stack-based exploits that utilize overflows", if/when someone find a new
'ala VLA' way of doing the controlled overflow. 
How do people feel about it? Is it worth having? I can work on the POC for this in direction that Andy 
outlined and can provide performance impact/etc., but it is good that we understand that we cannot
provide a better justification for this feature at the moment unless someone is ready to share some
new exploit technique with us. 

Best Regards,
Elena.



  reply index

Thread overview: 34+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2019-02-08 12:15 [RFC PATCH] Early version of thread stack randomization Elena Reshetova
2019-02-08 12:15 ` [RFC PATCH] x86/entry/64: randomize kernel stack offset upon system call Elena Reshetova
2019-02-08 13:05   ` Peter Zijlstra
2019-02-08 13:20     ` Reshetova, Elena
2019-02-08 14:26       ` Peter Zijlstra
2019-02-09 11:13         ` Reshetova, Elena
2019-02-09 18:25           ` Andy Lutomirski
2019-02-11  6:39             ` Reshetova, Elena
2019-02-11 15:54               ` Andy Lutomirski
2019-02-12 10:16                 ` Perla, Enrico
2019-02-14  7:52                   ` Reshetova, Elena [this message]
2019-02-19 14:47                     ` Jann Horn
2019-02-20 22:20                     ` Kees Cook
2019-02-21  6:37                       ` Andy Lutomirski
2019-02-21 13:20                         ` Jann Horn
2019-02-21 15:49                           ` Andy Lutomirski
2019-02-20 22:15                   ` Kees Cook
2019-02-20 22:53                     ` Kees Cook
2019-02-21 23:29                       ` Kees Cook
2019-02-27 11:03                         ` Reshetova, Elena
2019-02-21  9:35                     ` Perla, Enrico
2019-02-21 17:23                       ` Kees Cook
2019-02-21 17:48                         ` Perla, Enrico
2019-02-21 19:18                           ` Kees Cook
2019-02-20 21:51         ` Kees Cook
2019-02-08 15:15       ` Peter Zijlstra
2019-02-09 11:38         ` Reshetova, Elena
2019-02-09 12:09           ` Greg KH
2019-02-11  6:05             ` Reshetova, Elena
2019-02-08 16:34   ` Andy Lutomirski
2019-02-20 22:03     ` Kees Cook
2019-02-08 21:28   ` Kees Cook
2019-02-11 12:47     ` Reshetova, Elena
2019-02-20 22:04   ` Kees Cook

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=2236FBA76BA1254E88B949DDB74E612BA4BC57C1@IRSMSX102.ger.corp.intel.com \
    --to=elena.reshetova@intel.com \
    --cc=bp@alien8.de \
    --cc=enrico.perla@intel.com \
    --cc=jannh@google.com \
    --cc=keescook@chromium.org \
    --cc=kernel-hardening@lists.openwall.com \
    --cc=luto@amacapital.net \
    --cc=luto@kernel.org \
    --cc=mingo@redhat.com \
    --cc=peterz@infradead.org \
    --cc=tglx@linutronix.de \
    --cc=tytso@mit.edu \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link

Kernel-hardening archive on lore.kernel.org

Archives are clonable:
	git clone --mirror https://lore.kernel.org/kernel-hardening/0 kernel-hardening/git/0.git

	# If you have public-inbox 1.1+ installed, you may
	# initialize and index your mirror using the following commands:
	public-inbox-init -V2 kernel-hardening kernel-hardening/ https://lore.kernel.org/kernel-hardening \
		kernel-hardening@lists.openwall.com
	public-inbox-index kernel-hardening

Example config snippet for mirrors

Newsgroup available over NNTP:
	nntp://nntp.lore.kernel.org/com.openwall.lists.kernel-hardening


AGPL code for this site: git clone https://public-inbox.org/public-inbox.git