RFC: fsyscall
I was thinking a bit about the problem of allowing another process to perform a subset of what your process can perform, and it occured to me there might be something conceptually simple we can do.
Have a system call fsyscall that takes a file descriptor the system call number and the parameters to that system call as arguments. AKA long fsyscall(int fd, long number, ...); AKA syscall with a file desciptor argument.
The fd would hold a struct cred, and a filter that limits what system calls and which parameters may be passed.
The implementation of fsyscall would be something like:
old = override_creds(f->f_cred);
/* Perform filtered syscallf */
revert_creds(old);Then we have another system call call it fsyscall_create(...) that takes a bpf filter and returns a file descriptor, that can be used with fsyscall.
I'm not certain that bpf is the best way to create such a filter but it seems plausible, and we already have the infrastructure in place, so if nothing else there would be synergy in syscall filtering.
My two concerns with bpf are (a) it seems a little complex for the simplest use cases. (b) I think there cases like inspecting the data passed into write, or send, or the structure passed into ioctl that it doesn't handle well yet.
Andy does a fsyscall system call sound like something that would be not be too bad to implement? (You have just been through all of the x86 system call paths recently).
Eric
Quoted 26 lines · Eric W. Biederman
I was thinking a bit about the problem of allowing another process to perform a subset of what your process can perform, and it occured to me there might be something conceptually simple we can do.
Have a system call fsyscall that takes a file descriptor the system call number and the parameters to that system call as arguments. AKA long
fsyscall(int fd, long number, ...); AKA syscall with a file desciptor argument.The fd would hold a struct cred, and a filter that limits what system calls and which parameters may be passed.
The implementation of fsyscall would be something like:
old = override_creds(f->f_cred); /* Perform filtered syscallf */ revert_creds(old);Then we have another system call call it
fsyscall_create(...)that takes a bpf filter and returns a file descriptor, that can be used with fsyscall.I'm not certain that bpf is the best way to create such a filter but it seems plausible, and we already have the infrastructure in place, so if nothing else there would be synergy in syscall filtering.
Quoted 8 lines
My two concerns with bpf are (a) it seems a little complex for the simplest use cases. (b) I think there cases like inspecting the data passed into write, or send, or the structure passed into ioctl that it doesn't handle well yet.
Andy does a fsyscall system call sound like something that would be not be too bad to implement? (You have just been through all of the x86 system call paths recently).
It's not possible yet due to nasty calling convention issues. (Entries in the x86 syscall table aren't actually functions callable using the C ABI right now.) My pending monster patchset will make it possible to implement for 32-bit syscalls (native and compat). I'm planning on addressing 64-bit, and I want to do almost the reverse of what you're proposing: have a way that one task can trap into a special mode in which another process can do syscalls on its behalf.
There are some syscalls for which this simply makes no sense. Setresuid, capset, and similar come to mind. Clone and friends may screw up impressively if you try this. fsyscall should not be allowed to call itself. If you call write(2) like this and it has any meaningful effect, something's wrong. keyctl(2) does really awful things wrt struct cred, and I don't really want to think about what happens if you try calling it like this.
override_creds is IMO awful. Serge and I had an old discussion on how to maybe fix it.
Honestly, I think the way to go might be to get Capsicum, or at least Capsicum's fd model, merged and to add a mode in which the *at operations on a specially marked fd use the passed fd's f_cred instead of the caller's. (Cc: David Drysdale -- that feature might be really nice.)
--Andy
Quoted 36 lines · Andy Lutomirski
Quoted 26 lines · Eric W. Biederman
I was thinking a bit about the problem of allowing another process to perform a subset of what your process can perform, and it occured to me there might be something conceptually simple we can do.
Have a system call fsyscall that takes a file descriptor the system call number and the parameters to that system call as arguments. AKA long
fsyscall(int fd, long number, ...); AKA syscall with a file desciptor argument.The fd would hold a struct cred, and a filter that limits what system calls and which parameters may be passed.
The implementation of fsyscall would be something like:
old = override_creds(f->f_cred); /* Perform filtered syscallf */ revert_creds(old);Then we have another system call call it
fsyscall_create(...)that takes a bpf filter and returns a file descriptor, that can be used with fsyscall.I'm not certain that bpf is the best way to create such a filter but it seems plausible, and we already have the infrastructure in place, so if nothing else there would be synergy in syscall filtering.
Quoted 8 lines
My two concerns with bpf are (a) it seems a little complex for the simplest use cases. (b) I think there cases like inspecting the data passed into write, or send, or the structure passed into ioctl that it doesn't handle well yet.
Andy does a fsyscall system call sound like something that would be not be too bad to implement? (You have just been through all of the x86 system call paths recently).
Quoted 7 lines
It's not possible yet due to nasty calling convention issues. (Entries in the x86 syscall table aren't actually functions callable using the C ABI right now.) My pending monster patchset will make it possible to implement for 32-bit syscalls (native and compat). I'm planning on addressing 64-bit, and I want to do almost the reverse of what you're proposing: have a way that one task can trap into a special mode in which another process can do syscalls on its behalf.
Hmm. That seems comparatively dangerous to me.
Quoted 5 lines
There are some syscalls for which this simply makes no sense. Setresuid, capset, and similar come to mind. Clone and friends may screw up impressively if you try this. fsyscall should not be allowed to call itself. If you call write(2) like this and it has any meaningful effect, something's wrong.
If you peak into the data that is being written it can be meaningful on write(2).
Hmm. But yes for file descriptor based system calls this is much less interesting. Having some kind of wrapper that embeds one file descriptor in another and does the filtering that way seems more interesting, for the file descriptor based methods.
Quoted 4 lines
keyctl(2) does really awful
things wrt struct cred, and I don't really want to think about what happens if you try calling it like this.
Quoted 8 lines
override_credsis IMO awful. Serge and I had an old discussion on how to maybe fix it.Honestly, I think the way to go might be to get Capsicum, or at least Capsicum's fd model, merged and to add a mode in which the *at operations on a specially marked fd use the passed fd's
f_credinstead of the caller's. (Cc: David Drysdale -- that feature might be really nice.)
Perhaps I had missed it but I don't recall capsicum being able to wrap things like reboot(2).
Which really describes what I am trying to tackle. How do we create an object that we can pass between processes that limits what we can do in the case of the oddball syscalls that require special privileges.
At the same time I still want the caller to be able to pass in data to the system calls being called such as REBOOT_CMD_POWER_OFF versus REBOOT_CMD_HALT, while being able to filter it and say you may not pass REBOOT_CMD_CAD_OFF.
Eric
Quoted 69 lines · Eric W. Biederman
Quoted 36 lines · Andy Lutomirski
Quoted 26 lines · Eric W. Biederman
I was thinking a bit about the problem of allowing another process to perform a subset of what your process can perform, and it occured to me there might be something conceptually simple we can do.
Have a system call fsyscall that takes a file descriptor the system call number and the parameters to that system call as arguments. AKA long
fsyscall(int fd, long number, ...); AKA syscall with a file desciptor argument.The fd would hold a struct cred, and a filter that limits what system calls and which parameters may be passed.
The implementation of fsyscall would be something like:
old = override_creds(f->f_cred); /* Perform filtered syscallf */ revert_creds(old);Then we have another system call call it
fsyscall_create(...)that takes a bpf filter and returns a file descriptor, that can be used with fsyscall.I'm not certain that bpf is the best way to create such a filter but it seems plausible, and we already have the infrastructure in place, so if nothing else there would be synergy in syscall filtering.
Quoted 8 lines
My two concerns with bpf are (a) it seems a little complex for the simplest use cases. (b) I think there cases like inspecting the data passed into write, or send, or the structure passed into ioctl that it doesn't handle well yet.
Andy does a fsyscall system call sound like something that would be not be too bad to implement? (You have just been through all of the x86 system call paths recently).
Quoted 7 lines
It's not possible yet due to nasty calling convention issues. (Entries in the x86 syscall table aren't actually functions callable using the C ABI right now.) My pending monster patchset will make it possible to implement for 32-bit syscalls (native and compat). I'm planning on addressing 64-bit, and I want to do almost the reverse of what you're proposing: have a way that one task can trap into a special mode in which another process can do syscalls on its behalf.
Hmm. That seems comparatively dangerous to me.
Quoted 5 lines
There are some syscalls for which this simply makes no sense. Setresuid, capset, and similar come to mind. Clone and friends may screw up impressively if you try this. fsyscall should not be allowed to call itself. If you call write(2) like this and it has any meaningful effect, something's wrong.
If you peak into the data that is being written it can be meaningful on write(2).
Hmm. But yes for file descriptor based system calls this is much less interesting. Having some kind of wrapper that embeds one file descriptor in another and does the filtering that way seems more interesting, for the file descriptor based methods.
Quoted 7 lines
keyctl(2) does really awful
things wrt struct cred, and I don't really want to think about what happens if you try calling it like this.
override_credsis IMO awful. Serge and I had an old discussion on how to maybe fix it.
Quoted 9 lines
Quoted 5 lines
Honestly, I think the way to go might be to get Capsicum, or at least Capsicum's fd model, merged and to add a mode in which the *at operations on a specially marked fd use the passed fd's
f_credinstead of the caller's. (Cc: David Drysdale -- that feature might be really nice.)Perhaps I had missed it but I don't recall capsicum being able to wrap things like reboot(2).
Ah, so you want to be able to grant BPF-defined capabilities :)
Off the top of my head, I think that doing this using a nice IPC mechanism (which barely exists in Linux, but which seL4 and binder (!) can do very cleanly) would be simpler and more general, if less self-contained.
(Aside: how on earth does anyone think that replacing binder with kdbus makes any sense? Binder can pass capabilities, and kdbus can't. OTOH, maybe Android doesn't use the capability-passing ability.)
Quoted 9 lines
Which really describes what I am trying to tackle. How do we create an object that we can pass between processes that limits what we can do in the case of the oddball syscalls that require special privileges.
At the same time I still want the caller to be able to pass in data to the system calls being called such as
REBOOT_CMD_POWER_OFFversusREBOOT_CMD_HALT, while being able to filter it and say you may not passREBOOT_CMD_CAD_OFF.
We could have a conservative whitelist of syscalls for which we allow this usage. I'm a bit worried that there will be very limited use cases, given that a lot of use cases will want to follow pointers, which has TOCTOU problems.
--Andy
Quoted 7 lines · Andy Lutomirski
Quoted 3 lines · Eric W. Biederman
Perhaps I had missed it but I don't recall capsicum being able to wrap things like reboot(2).
Ah, so you want to be able to grant BPF-defined capabilities :)
Pretty much.
Where I am focusing is turning Posix capabilities into real capabilities. I would not mind if the functionality was a bit more general. Say to be able to handle things like security labels, or anywhere else you might reasonably be asked can you do X?
But I would be happy if we just managed to wrap the Posix capabilities and turned them into real capablilities.
Quoted 4 lines
Off the top of my head, I think that doing this using a nice IPC mechanism (which barely exists in Linux, but which seL4 and binder (!) can do very cleanly) would be simpler and more general, if less self-contained.
Less self-contained becomes a problem when you want to pass them between processes written at different times between different people. If there is something conceptually simple we can implement in the kernel it becomes worth it because that becomes the standard which everyone knows to code to.
Quoted 3 lines
(Aside: how on earth does anyone think that replacing binder with kdbus makes any sense? Binder can pass capabilities, and kdbus can't. OTOH, maybe Android doesn't use the capability-passing ability.)
kdbus has file descriptor passing. Beyond that no comment.
Quoted 10 lines
Quoted 9 lines
Which really describes what I am trying to tackle. How do we create an object that we can pass between processes that limits what we can do in the case of the oddball syscalls that require special privileges.
At the same time I still want the caller to be able to pass in data to the system calls being called such as
REBOOT_CMD_POWER_OFFversusREBOOT_CMD_HALT, while being able to filter it and say you may not passREBOOT_CMD_CAD_OFF.
Quoted 4 lines
We could have a conservative whitelist of syscalls for which we allow this usage. I'm a bit worried that there will be very limited use cases, given that a lot of use cases will want to follow pointers, which has TOCTOU problems.
Time of check to time of use problems. Interesting point.
TOCTOU seems to make filtering of system calls in general much less viable then I had hoped or imagined, and seems to be one of the better arguments I have heard against ioctls.
I think the cases I care about are much less likely to have TOCTOU problems than system calls in general, so I still may be ok.
However it does seem like past a certain point for good filtering the entire syscall ABI needs to be turned into well defined IPC. Ick!
Sigh. I guess it is about time I dig up the places we call capable. Ugh 1696 places in the kernel.. Even filtering out CAP_SYS_ADMIN and CAP_NET_ADMIN the list is longer than I can easily look at.
Still reboot isn't a problem ;)
Thinking abou the TOCTOU problems with system call filtering the only general solution I can see is to handle it like the compat syscalls but instead of copying things into a temporary on buffer in userspace we copy the data into a temporary in-kernel buffer (filter the system call)
fs = get_fs(); set_fs(get_ds()); /* Call the system call */ set_fs(fs);
I don't like the whole set_fs() thing (especially if there is any data we did not manage to copy). But it seems like a good conceptual start.
Eric
Quoted 11 lines · Eric W. Biederman
Quoted 7 lines · Andy Lutomirski
Quoted 3 lines · Eric W. Biederman
Perhaps I had missed it but I don't recall capsicum being able to wrap things like reboot(2).
Ah, so you want to be able to grant BPF-defined capabilities :)
Pretty much.
Quoted 7 lines
Where I am focusing is turning Posix capabilities into real capabilities. I would not mind if the functionality was a bit more general. Say to be able to handle things like security labels, or anywhere else you might reasonably be asked can you do X?
But I would be happy if we just managed to wrap the Posix capabilities and turned them into real capablilities.
Interesting idea! So kind of like the "object" in question is the root role, and the different rights for the corresponding object-capability (the file descriptor) are the POSIX capabilities (in the simple case at least).
And yes, Capsicum doesn't generally interact with things like reboot(2); its checks are on top of any DAC policies rather than instead of them, as it's a hybrid rather than a pure object-capability system.
Quoted 32 lines
Quoted 4 lines
Off the top of my head, I think that doing this using a nice IPC mechanism (which barely exists in Linux, but which seL4 and binder (!) can do very cleanly) would be simpler and more general, if less self-contained.
Less self-contained becomes a problem when you want to pass them between processes written at different times between different people. If there is something conceptually simple we can implement in the kernel it becomes worth it because that becomes the standard which everyone knows to code to.
Quoted 3 lines
(Aside: how on earth does anyone think that replacing binder with kdbus makes any sense? Binder can pass capabilities, and kdbus can't. OTOH, maybe Android doesn't use the capability-passing ability.)
kdbus has file descriptor passing. Beyond that no comment.
Quoted 10 lines
Quoted 9 lines
Which really describes what I am trying to tackle. How do we create an object that we can pass between processes that limits what we can do in the case of the oddball syscalls that require special privileges.
At the same time I still want the caller to be able to pass in data to the system calls being called such as
REBOOT_CMD_POWER_OFFversusREBOOT_CMD_HALT, while being able to filter it and say you may not passREBOOT_CMD_CAD_OFF.Quoted 4 lines
We could have a conservative whitelist of syscalls for which we allow this usage. I'm a bit worried that there will be very limited use cases, given that a lot of use cases will want to follow pointers, which has TOCTOU problems.
Quoted 5 lines
Time of check to time of use problems. Interesting point.
TOCTOU seems to make filtering of system calls in general much less viable then I had hoped or imagined, and seems to be one of the better arguments I have heard against ioctls.
By the way, Robert Watson (one of the progenitors of Capsicum, as it happens) has a nice paper about TOCTOU attacks on syscall interposition layers that's a good read:
http://www.watson.org/~robert/2007woot/
(From this perspective, the limitation that seccomp-bpf programs only have access to syscall arguments by-value is actually a help -- the filter can't look into user memory, so can't be fooled by having memory contents changed underneath it. Of course, if the eBPF stuff ever changes that we should watch out...)
Quoted 5 lines
I think the cases I care about are much less likely to have TOCTOU problems than system calls in general, so I still may be ok.
However it does seem like past a certain point for good filtering the entire syscall ABI needs to be turned into well defined IPC. Ick!
That's roughly one of Robert's suggestions (section 8.2).
Quoted 10 lines
Sigh. I guess it is about time I dig up the places we call capable. Ugh 1696 places in the kernel.. Even filtering out
CAP_SYS_ADMINandCAP_NET_ADMINthe list is longer than I can easily look at.Still reboot isn't a problem ;)
Thinking abou the TOCTOU problems with system call filtering the only general solution I can see is to handle it like the compat syscalls but instead of copying things into a temporary on buffer in userspace we copy the data into a temporary in-kernel buffer (filter the system call)
Quoted 7 lines
fs = get_fs(); set_fs(get_ds()); /* Call the system call */ set_fs(fs);I don't like the whole
set_fs()thing (especially if there is any data we did not manage to copy). But it seems like a good conceptual start.
Doing the copies sounds like it would involve understanding & reproducing the memory layouts for every syscall pointer argument, which would be a lot of code. Or am I misunderstanding something?
Quoted 101 lines · David Drysdale
Quoted 11 lines · Eric W. Biederman
Quoted 7 lines · Andy Lutomirski
Quoted 3 lines · Eric W. Biederman
Perhaps I had missed it but I don't recall capsicum being able to wrap things like reboot(2).
Ah, so you want to be able to grant BPF-defined capabilities :)
Pretty much.
Quoted 7 lines
Where I am focusing is turning Posix capabilities into real capabilities. I would not mind if the functionality was a bit more general. Say to be able to handle things like security labels, or anywhere else you might reasonably be asked can you do X?
But I would be happy if we just managed to wrap the Posix capabilities and turned them into real capablilities.
Interesting idea! So kind of like the "object" in question is the root role, and the different rights for the corresponding object-capability (the file descriptor) are the POSIX capabilities (in the simple case at least).
And yes, Capsicum doesn't generally interact with things like reboot(2); its checks are on top of any DAC policies rather than instead of them, as it's a hybrid rather than a pure object-capability system.
Quoted 32 lines
Quoted 4 lines
Off the top of my head, I think that doing this using a nice IPC mechanism (which barely exists in Linux, but which seL4 and binder (!) can do very cleanly) would be simpler and more general, if less self-contained.
Less self-contained becomes a problem when you want to pass them between processes written at different times between different people. If there is something conceptually simple we can implement in the kernel it becomes worth it because that becomes the standard which everyone knows to code to.
Quoted 3 lines
(Aside: how on earth does anyone think that replacing binder with kdbus makes any sense? Binder can pass capabilities, and kdbus can't. OTOH, maybe Android doesn't use the capability-passing ability.)
kdbus has file descriptor passing. Beyond that no comment.
Quoted 10 lines
Quoted 9 lines
Which really describes what I am trying to tackle. How do we create an object that we can pass between processes that limits what we can do in the case of the oddball syscalls that require special privileges.
At the same time I still want the caller to be able to pass in data to the system calls being called such as
REBOOT_CMD_POWER_OFFversusREBOOT_CMD_HALT, while being able to filter it and say you may not passREBOOT_CMD_CAD_OFF.Quoted 4 lines
We could have a conservative whitelist of syscalls for which we allow this usage. I'm a bit worried that there will be very limited use cases, given that a lot of use cases will want to follow pointers, which has TOCTOU problems.
Quoted 5 lines
Time of check to time of use problems. Interesting point.
TOCTOU seems to make filtering of system calls in general much less viable then I had hoped or imagined, and seems to be one of the better arguments I have heard against ioctls.
By the way, Robert Watson (one of the progenitors of Capsicum, as it happens) has a nice paper about TOCTOU attacks on syscall interposition layers that's a good read:
http://www.watson.org/~robert/2007woot/(From this perspective, the limitation that seccomp-bpf programs only have access to syscall arguments by-value is actually a help -- the filter can't look into user memory, so can't be fooled by having memory contents changed underneath it. Of course, if the eBPF stuff ever changes that we should watch out...)
Quoted 5 lines
I think the cases I care about are much less likely to have TOCTOU problems than system calls in general, so I still may be ok.
However it does seem like past a certain point for good filtering the entire syscall ABI needs to be turned into well defined IPC. Ick!
That's roughly one of Robert's suggestions (section 8.2).
Quoted 15 lines
Sigh. I guess it is about time I dig up the places we call capable. Ugh 1696 places in the kernel.. Even filtering out
CAP_SYS_ADMINandCAP_NET_ADMINthe list is longer than I can easily look at.Still reboot isn't a problem ;)
Thinking abou the TOCTOU problems with system call filtering the only general solution I can see is to handle it like the compat syscalls but instead of copying things into a temporary on buffer in userspace we copy the data into a temporary in-kernel buffer (filter the system call)
fs = get_fs(); set_fs(get_ds()); /* Call the system call */ set_fs(fs);
Quoted 6 lines
Quoted 2 lines
I don't like the whole
set_fs()thing (especially if there is any data we did not manage to copy). But it seems like a good conceptual start.Doing the copies sounds like it would involve understanding & reproducing the memory layouts for every syscall pointer argument, which would be a lot of code. Or am I misunderstanding something?
Which is what we have for ioctls and some of the system calls in the compat case. So it is something that has been done before. However I am going to leave the TOCTOU mess to another time.
If I assume that anything file descriptor based will need another mechanism to filter what is allowed on a file descriptor, and as such will need a different mechanism (capsicum perhaps?). That handily reduces the problem space, and removes almost all cases where reading data from userspace is interesting as I am talking about pure system calls.
The list of system calls which are not file descriptor based are listed below. Most of those don't take weird parameter structures that would be interesting to filter. So I think my fsyscall idea is conceptually
reasonable. It is not a complete solution for passing someone a well
defined subset you are allowed to do but it is interesting.
Eric
open
stat
lstat
mprotect
munmap
brkrt_sigactionrt_sigprocmaskrt_sigreturn
access
pipesched_yield
mremap
msync
mincore
madvise
shmget
shmat
shmctl
pause
nanosleep
getitimer
alarm
setitimer
getpid
socket
socketpair
clone
fork
vfork
execve
exit
wait4
kill
uname
semget
semop
semctl
shmdt
msgget
msgsnd
msgrcv
msgctl
truncate
getcwd
chdir
rename
mkdir
rmdir
creat
link
unlink
symlink
readlink
chmod
chown
lchown
umask
gettimeofday
getrlimit
getrusage
sysinfo
times
ptrace
getuid
syslog
getgid
setuid
setgid
geteuid
getegid
setpgid
getppid
getpgrp
setsid
setreuid
setregid
getgroups
setgroups
setresuid
getresuid
setresgid
getresgid
getpgid
setfsuid
setfsgid
getsid
capget
capsetrt_sigpendingrt_sigtimedwaitrt_sigqueueinfort_sigsuspend
sigaltstack
utime
mknod
uselib
personality
ustat
statfs
sysfs
getpriority
setprioritysched_setparamsched_getparamsched_setschedulersched_getschedulersched_get_priority_maxsched_get_priority_minsched_rr_get_interval
mlock
munlock
mlockall
munlockall
vhangupmodify_ldtpivot_root_sysctl
prctlarch_prctl
adjtimex
setrlimit
chroot
sync
acct
settimeofday
mount
umount2
swapon
swapoff
reboot
sethostname
setdomainname
iopl
iopermcreate_moduleinit_moduledelete_moduleget_kernel_symsquery_module
quotactl
nfsservctl
gettid
setxattr
lsetxattr
getxattr
lgetxattr
listxattr
llistxattr
removexattr
lremovexattr
tkill
time
futexsched_setaffinitysched_getaffinityset_thread_areaio_setupio_destroyio_geteventsio_submitio_cancelget_thread_arealookup_dcookieepoll_createepoll_ctl_oldepoll_wait_oldremap_file_pagesset_tid_addressrestart_syscall
semtimedoptimer_createtimer_settimetimer_gettimetimer_getoverruntimer_deleteclock_settimeclock_gettimeclock_getresclock_nanosleepexit_groupepoll_waitepoll_ctl
tgkill
utimes
vserver
mbindset_mempolicyget_mempolicymq_openmq_unlinkmq_timedsendmq_timedreceivemq_notifymq_getsetattrkexec_load
waitidadd_keyrequest_key
keyctlioprio_setioprio_getinotify_initinotify_add_watchinotify_rm_watchmigrate_pages
unshareset_robust_listget_robust_list
splice
teesync_file_range
vmsplicemove_pages
utimensatepoll_pwait
signalfdtimerfd_create
eventfd
fallocate
signalfd4
eventfd2epoll_create1
pipe2inotify_init1rt_tgsigqueueinfoperf_event_openfanotify_init
prlimit64clock_adjtime
getcpuprocess_vm_readvprocess_vm_writev
kcmpsched_setattrsched_getattr
seccomp
getrandommemfd_create
bpf
On Wed, Sep 09, 2015 at 02:33:14PM -0500, Eric W. Biederman wrote:
...
Quoted 11 lines
If I assume that anything file descriptor based will need another mechanism to filter what is allowed on a file descriptor, and as such will need a different mechanism (capsicum perhaps?). That handily reduces the problem space, and removes almost all cases where reading data from userspace is interesting as I am talking about pure system calls.
The list of system calls which are not file descriptor based are listed below. Most of those don't take weird parameter structures that would be interesting to filter. So I think my fsyscall idea is conceptually
reasonable. It is not a complete solution for passing someone a well
defined subset you are allowed to do but it is interesting.
...
Quoted 1 line
creat
Taking this as a specific example, I'm somewhat fond of the idea of saying that we can support openat() as fd-based (let's say capsicum-based as we know that can work), and therefore we don't need open() or creat(). If you're designing an app so that you can fork a task with a subset of your capabilities, then you're writing it now anyway, so there is no reason for supporting open and creat. Since these are specifically very subject to TOCTTOU, saying "you must use openat()" seems ok.
-serge
Quoted 9 lines · David Drysdale
Quoted 2 lines · Eric W. Biederman
Quoted 1 line · Andy Lutomirski
On Tue, Sep 8, 2015 at 4:07 PM, Eric W. Biederman <[email protected]> wrote:
(From this perspective, the limitation that seccomp-bpf programs only have access to syscall arguments by-value is actually a help -- the filter can't look into user memory, so can't be fooled by having memory contents changed underneath it. Of course, if the eBPF stuff ever changes that we should watch out...)
Yup and I'm quite sure I've seen that raised as a reason to refuse supporting exactly that.
Quoted 12 lines · Eric W. Biederman
Quoted 7 lines · Andy Lutomirski
Quoted 3 lines · Eric W. Biederman
Perhaps I had missed it but I don't recall capsicum being able to wrap things like reboot(2).
Ah, so you want to be able to grant BPF-defined capabilities :)
Pretty much.
Quoted 7 lines
Where I am focusing is turning Posix capabilities into real capabilities. I would not mind if the functionality was a bit more general. Say to be able to handle things like security labels, or anywhere else you might reasonably be asked can you do X?
But I would be happy if we just managed to wrap the Posix capabilities and turned them into real capablilities.
If there were a clever way to exec an open fd, then you could do this by passing an fd to a copy of /bin/reboot which has fP=CAP_SYS_BOOT, or prefereably fI=CAP_SYS_BOOT,fE=1 and leave pI=CAP_SYS_BOOT in the task.
A cleaner way to do this is to have a service which can reboot, which looks at unix socket peercreds to determine whether the granter may reboot, then passes it an fd which the granter may pass to a grantee. Then the grantee passes the fd to the service, which recognizes it and reboots.
-serge
Quoted 18 lines · Serge E. Hallyn
Quoted 17 lines · Eric W. Biederman
Quoted 7 lines · Andy Lutomirski
Quoted 3 lines · Eric W. Biederman
Perhaps I had missed it but I don't recall capsicum being able to wrap things like reboot(2).
Ah, so you want to be able to grant BPF-defined capabilities :)
Pretty much.
Where I am focusing is turning Posix capabilities into real capabilities. I would not mind if the functionality was a bit more general. Say to be able to handle things like security labels, or anywhere else you might reasonably be asked can you do X?
Quoted 4 lines
Quoted 2 lines
But I would be happy if we just managed to wrap the Posix capabilities and turned them into real capablilities.
If there were a clever way to exec an open fd, then you could do this
execveat(fd, "", argv, envp, AT_EMPTY_PATH) ?
Quoted 11 lines
by passing an fd to a copy of
/bin/rebootwhich has fP=CAP_SYS_BOOT, or prefereably fI=CAP_SYS_BOOT,fE=1 and leave pI=CAP_SYS_BOOT in the task.A cleaner way to do this is to have a service which can reboot, which looks at unix socket peercreds to determine whether the granter may reboot, then passes it an fd which the granter may pass to a grantee. Then the grantee passes the fd to the service, which recognizes it and reboots.
-serge
Quoted 19 lines · David Drysdale
Quoted 18 lines · Serge E. Hallyn
Quoted 17 lines · Eric W. Biederman
Quoted 7 lines · Andy Lutomirski
Quoted 3 lines · Eric W. Biederman
Perhaps I had missed it but I don't recall capsicum being able to wrap things like reboot(2).
Ah, so you want to be able to grant BPF-defined capabilities :)
Pretty much.
Where I am focusing is turning Posix capabilities into real capabilities. I would not mind if the functionality was a bit more general. Say to be able to handle things like security labels, or anywhere else you might reasonably be asked can you do X?
Quoted 6 lines
Quoted 4 lines
Quoted 2 lines
But I would be happy if we just managed to wrap the Posix capabilities and turned them into real capablilities.
If there were a clever way to exec an open fd, then you could do this
execveat(fd, "", argv, envp, AT_EMPTY_PATH)?
??? I looked for it but I don't have a manpage for it. I see it at man7.org though. Thanks :)
Quoted 11 lines
Quoted 11 lines
by passing an fd to a copy of
/bin/rebootwhich has fP=CAP_SYS_BOOT, or prefereably fI=CAP_SYS_BOOT,fE=1 and leave pI=CAP_SYS_BOOT in the task.A cleaner way to do this is to have a service which can reboot, which looks at unix socket peercreds to determine whether the granter may reboot, then passes it an fd which the granter may pass to a grantee. Then the grantee passes the fd to the service, which recognizes it and reboots.
-serge
Quoted 23 lines · Serge E. Hallyn
Quoted 22 lines · David Drysdale
Quoted 21 lines · Serge E. Hallyn
Quoted 19 lines · Eric W. Biederman
Quoted 7 lines · Andy Lutomirski
Quoted 3 lines · Eric W. Biederman
Perhaps I had missed it but I don't recall capsicum being able to wrap things like reboot(2).
Ah, so you want to be able to grant BPF-defined capabilities :)
Pretty much.
Where I am focusing is turning Posix capabilities into real capabilities. I would not mind if the functionality was a bit more general. Say to be able to handle things like security labels, or anywhere else you might reasonably be asked can you do X?
But I would be happy if we just managed to wrap the Posix capabilities and turned them into real capablilities.
Quoted 6 lines
Quoted 3 lines
Quoted 1 line
If there were a clever way to exec an open fd, then you could do this
execveat(fd, "", argv, envp, AT_EMPTY_PATH)???? I looked for it but I don't have a manpage for it. I see it at man7.org though. Thanks :)
But this isn't quite what I was suggesting. I was suggesting a call which would exec the fd, not exec a file inside the dirfd.
Quoted 26 lines · Serge E. Hallyn
Quoted 25 lines · Serge E. Hallyn
Quoted 24 lines · David Drysdale
Quoted 22 lines · Serge E. Hallyn
Quoted 12 lines · Eric W. Biederman
Quoted 7 lines · Andy Lutomirski
Quoted 3 lines · Eric W. Biederman
Perhaps I had missed it but I don't recall capsicum being able to wrap things like reboot(2).
Ah, so you want to be able to grant BPF-defined capabilities :)
Pretty much.
Quoted 7 lines
Where I am focusing is turning Posix capabilities into real capabilities. I would not mind if the functionality was a bit more general. Say to be able to handle things like security labels, or anywhere else you might reasonably be asked can you do X?
But I would be happy if we just managed to wrap the Posix capabilities and turned them into real capablilities.
If there were a clever way to exec an open fd, then you could do this
Quoted 7 lines
Quoted 4 lines
Quoted 1 line
execveat(fd, "", argv, envp, AT_EMPTY_PATH)???? I looked for it but I don't have a manpage for it. I see it at man7.org though. Thanks :)
But this isn't quite what I was suggesting. I was suggesting a call which would exec the fd, not exec a file inside the dirfd.
Oh, which it does:
If pathname is an empty string and the AT_EMPTY_PATH flag is
specified, then the file descriptor dirfd specifies the file to be executed (i.e., dirfd refers to an executable file, rather than a directory).
well that's spiffy