From: Andy Lutomirski <luto@kernel.org>
To: Kees Cook <keescook@chromium.org>
Cc: Andy Lutomirski <luto@kernel.org>,
Paul Gofman <gofmanp@gmail.com>,
Gabriel Krisman Bertazi <krisman@collabora.com>,
Linux-MM <linux-mm@kvack.org>,
LKML <linux-kernel@vger.kernel.org>,
kernel@collabora.com, Thomas Gleixner <tglx@linutronix.de>,
Will Drewry <wad@chromium.org>, "H . Peter Anvin" <hpa@zytor.com>,
Zebediah Figura <zfigura@codeweavers.com>
Subject: Re: [PATCH RFC] seccomp: Implement syscall isolation based on memory areas
Date: Mon, 1 Jun 2020 16:18:27 -0700 [thread overview]
Message-ID: <CALCETrW9R7YyxkervbsH2NZDUtYzag23ewD=--poeH54nc-yiQ@mail.gmail.com> (raw)
In-Reply-To: <202006011306.2E31FDED@keescook>
On Mon, Jun 1, 2020 at 1:08 PM Kees Cook <keescook@chromium.org> wrote:
>
> On Sun, May 31, 2020 at 02:03:48PM -0700, Andy Lutomirski wrote:
> > On Sun, May 31, 2020 at 11:57 AM Andy Lutomirski <luto@kernel.org> wrote:
> > >
> > >
> > > What if there was a special filter type that ran a BPF program on each
> > > syscall, and the program was allowed to access user memory to make its
> > > decisions, e.g. to look at some list of memory addresses. But this
> > > would explicitly *not* be a security feature -- execve() would remove
> > > the filter, and the filter's outcome would be one of redirecting
> > > execution or allowing the syscall. If the "allow" outcome occurs,
> > > then regular seccomp filters run. Obviously the exact semantics here
> > > would need some care.
> >
> > Let me try to flesh this out a little.
> >
> > A task could install a syscall emulation filter (maybe using the
> > seccomp() syscall, maybe using something else). There would be at
> > most one such filter per process. Upon doing a syscall, the kernel
> > will first do initial syscall fixups (e.g. SYSENTER/SYSCALL32 magic
> > argument translation) and would then invoke the filter. The filter is
> > an eBPF program (sorry Kees) and, as input, it gets access to the
>
> FWIW, I agree: something like this needs to use eBPF -- this isn't
> being designed as a security boundary. It's more like eBPF ptrace.
On a bit more consideration, I think that I have the model a bit
wrong. We shouldn't think of this as a *syscall* filter but as a
filter for architectural privilege transitions in general. After all,
there is no particular guarantee that any given emulated program has a
syscall ABI that is even remotely compatible with Linux. So maybe the
filter is fed events like SYSCALL64, SYSCALL32, SYSENTER, #GP, #PF
(the bad kind that would otherwise get a signal), #UD, etc. And the
filter can examine process state and take some reasonable action.
Think if it as a personality scheme that's programmable by user code.
I imagine that even schemes like NaCl could make some use of this.
This allows all kinds of interesting things. For example, it should
give Wine a much nicer emulation of Windows SEH and vectored signals.
And maybe it could finally allow Linux userspace to have some sensible
equivalent of those Windows features -- being able to write library
code that could sanely handle, say, math errors would be quite handy.
This could be mocked up with cBPF, but I think a cBPF version will
struggle to be a performant solution for Wine because it will have a
hard time distinguishing between Windows and Linux syscalls.
--Andy
next prev parent reply other threads:[~2020-06-01 23:18 UTC|newest]
Thread overview: 32+ messages / expand[flat|nested] mbox.gz Atom feed top
2020-05-30 5:59 [PATCH RFC] seccomp: Implement syscall isolation based on memory areas Gabriel Krisman Bertazi
2020-05-30 17:30 ` Kees Cook
2020-05-31 5:56 ` Gabriel Krisman Bertazi
2020-05-31 12:39 ` Paul Gofman
2020-05-31 16:49 ` Matthew Wilcox
2020-05-31 17:10 ` Paul Gofman
2020-05-31 17:31 ` Matthew Wilcox
2020-05-31 18:01 ` Paul Gofman
2020-06-01 17:54 ` Gabriel Krisman Bertazi
2020-06-01 17:53 ` Gabriel Krisman Bertazi
2020-05-30 22:09 ` Andy Lutomirski
2020-05-31 0:26 ` Gabriel Krisman Bertazi
2020-05-31 0:59 ` Andy Lutomirski
2020-05-31 12:56 ` Paul Gofman
2020-05-31 18:10 ` Andy Lutomirski
2020-05-31 18:36 ` Paul Gofman
2020-05-31 18:57 ` Andy Lutomirski
2020-05-31 19:37 ` Paul Gofman
2020-05-31 21:03 ` Andy Lutomirski
2020-06-01 18:06 ` Gabriel Krisman Bertazi
2020-06-01 20:08 ` Kees Cook
2020-06-01 23:18 ` Andy Lutomirski [this message]
2020-06-11 19:38 ` Gabriel Krisman Bertazi
2020-05-31 23:33 ` Brendan Shanks
2020-06-01 1:51 ` Andy Lutomirski
2020-06-25 23:14 ` Robert O'Callahan
2020-06-25 23:48 ` Gabriel Krisman Bertazi
2020-06-26 1:03 ` Robert O'Callahan
2020-06-05 6:06 ` Sargun Dhillon
2020-06-01 9:23 Billy Laws
2020-06-01 13:59 ` Andy Lutomirski
2020-06-01 17:48 ` hpa
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='CALCETrW9R7YyxkervbsH2NZDUtYzag23ewD=--poeH54nc-yiQ@mail.gmail.com' \
--to=luto@kernel.org \
--cc=gofmanp@gmail.com \
--cc=hpa@zytor.com \
--cc=keescook@chromium.org \
--cc=kernel@collabora.com \
--cc=krisman@collabora.com \
--cc=linux-kernel@vger.kernel.org \
--cc=linux-mm@kvack.org \
--cc=tglx@linutronix.de \
--cc=wad@chromium.org \
--cc=zfigura@codeweavers.com \
/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
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).