| Message ID | 20160914072415.26021-19-mic@digikod.net (mailing list archive) |
|---|---|
| State | New, archived |
| Headers | show |
On Wed, Sep 14, 2016 at 12:24 AM, Mickaël Salaün <mic@digikod.net> wrote: > Add a new flag CGRP_NO_NEW_PRIVS for each cgroup. This flag is initially > set for all cgroup except the root. The flag is clear when a new process > without the no_new_privs flags is attached to the cgroup. > > If a cgroup is landlocked, then any new attempt, from an unprivileged > process, to attach a process without no_new_privs to this cgroup will > be denied. Until and unless everyone can agree on a way to properly namespace, delegate, etc cgroups, I think that trying to add unprivileged semantics to cgroups is nuts. Given the big thread about cgroup v2, no-internal-tasks, etc, I just don't see how this approach can be viable. Can we try to make landlock work completely independently of cgroups so that it doesn't get stuck and so that programs can use it without worrying about cgroup v1 vs v2, interactions with cgroup managers, cgroup managers that (supposedly?) will start migrating processes around piecemeal and almost certainly blowing up landlock in the process, etc? I have no problem with looking at prototypes for how landlock + cgroups would work, but I can't imagine the result being mergeable.
On 14/09/2016 20:27, Andy Lutomirski wrote: > On Wed, Sep 14, 2016 at 12:24 AM, Mickaël Salaün <mic@digikod.net> wrote: >> Add a new flag CGRP_NO_NEW_PRIVS for each cgroup. This flag is initially >> set for all cgroup except the root. The flag is clear when a new process >> without the no_new_privs flags is attached to the cgroup. >> >> If a cgroup is landlocked, then any new attempt, from an unprivileged >> process, to attach a process without no_new_privs to this cgroup will >> be denied. > > Until and unless everyone can agree on a way to properly namespace, > delegate, etc cgroups, I think that trying to add unprivileged > semantics to cgroups is nuts. Given the big thread about cgroup v2, > no-internal-tasks, etc, I just don't see how this approach can be > viable. As far as I can tell, the no_new_privs flag of at task is not related to namespaces. The CGRP_NO_NEW_PRIVS flag is only a cache to quickly access the no_new_privs property of *tasks* in a cgroup. The semantic is unchanged. Using cgroup is optional, any task could use the seccomp-based landlocking instead. However, for those that want/need to manage a security policy in a more dynamic way, using cgroups may make sense. I though cgroup delegation was OK in the v2, isn't it the case? Do you have some links? > > Can we try to make landlock work completely independently of cgroups > so that it doesn't get stuck and so that programs can use it without > worrying about cgroup v1 vs v2, interactions with cgroup managers, > cgroup managers that (supposedly?) will start migrating processes > around piecemeal and almost certainly blowing up landlock in the > process, etc? This RFC handle both cgroup and seccomp approaches in a similar way. I don't see why building on top of cgroup v2 is a problem. Is there security issues with delegation? > > I have no problem with looking at prototypes for how landlock + > cgroups would work, but I can't imagine the result being mergeable. >
On Wed, Sep 14, 2016 at 3:11 PM, Mickaël Salaün <mic@digikod.net> wrote: > > On 14/09/2016 20:27, Andy Lutomirski wrote: >> On Wed, Sep 14, 2016 at 12:24 AM, Mickaël Salaün <mic@digikod.net> wrote: >>> Add a new flag CGRP_NO_NEW_PRIVS for each cgroup. This flag is initially >>> set for all cgroup except the root. The flag is clear when a new process >>> without the no_new_privs flags is attached to the cgroup. >>> >>> If a cgroup is landlocked, then any new attempt, from an unprivileged >>> process, to attach a process without no_new_privs to this cgroup will >>> be denied. >> >> Until and unless everyone can agree on a way to properly namespace, >> delegate, etc cgroups, I think that trying to add unprivileged >> semantics to cgroups is nuts. Given the big thread about cgroup v2, >> no-internal-tasks, etc, I just don't see how this approach can be >> viable. > > As far as I can tell, the no_new_privs flag of at task is not related to > namespaces. The CGRP_NO_NEW_PRIVS flag is only a cache to quickly access > the no_new_privs property of *tasks* in a cgroup. The semantic is unchanged. > > Using cgroup is optional, any task could use the seccomp-based > landlocking instead. However, for those that want/need to manage a > security policy in a more dynamic way, using cgroups may make sense. > > I though cgroup delegation was OK in the v2, isn't it the case? Do you > have some links? > >> >> Can we try to make landlock work completely independently of cgroups >> so that it doesn't get stuck and so that programs can use it without >> worrying about cgroup v1 vs v2, interactions with cgroup managers, >> cgroup managers that (supposedly?) will start migrating processes >> around piecemeal and almost certainly blowing up landlock in the >> process, etc? > > This RFC handle both cgroup and seccomp approaches in a similar way. I > don't see why building on top of cgroup v2 is a problem. Is there > security issues with delegation? What I mean is: cgroup v2 delegation has a functionality problem. Tejun says [1]: We haven't had to face this decision because cgroup has never properly supported delegating to applications and the in-use setups where this happens are custom configurations where there is no boundary between system and applications and adhoc trial-and-error is good enough a way to find a working solution. That wiggle room goes away once we officially open this up to individual applications. Unless and until that changes, I think that landlock should stay away from cgroups. Others could reasonably disagree with me. [1] https://lkml.kernel.org/g/<20160909225747.GA30105@mtj.duckdns.org
On Wed, Sep 14, 2016 at 06:25:07PM -0700, Andy Lutomirski wrote: > On Wed, Sep 14, 2016 at 3:11 PM, Mickaël Salaün <mic@digikod.net> wrote: > > > > On 14/09/2016 20:27, Andy Lutomirski wrote: > >> On Wed, Sep 14, 2016 at 12:24 AM, Mickaël Salaün <mic@digikod.net> wrote: > >>> Add a new flag CGRP_NO_NEW_PRIVS for each cgroup. This flag is initially > >>> set for all cgroup except the root. The flag is clear when a new process > >>> without the no_new_privs flags is attached to the cgroup. > >>> > >>> If a cgroup is landlocked, then any new attempt, from an unprivileged > >>> process, to attach a process without no_new_privs to this cgroup will > >>> be denied. > >> > >> Until and unless everyone can agree on a way to properly namespace, > >> delegate, etc cgroups, I think that trying to add unprivileged > >> semantics to cgroups is nuts. Given the big thread about cgroup v2, > >> no-internal-tasks, etc, I just don't see how this approach can be > >> viable. > > > > As far as I can tell, the no_new_privs flag of at task is not related to > > namespaces. The CGRP_NO_NEW_PRIVS flag is only a cache to quickly access > > the no_new_privs property of *tasks* in a cgroup. The semantic is unchanged. > > > > Using cgroup is optional, any task could use the seccomp-based > > landlocking instead. However, for those that want/need to manage a > > security policy in a more dynamic way, using cgroups may make sense. > > > > I though cgroup delegation was OK in the v2, isn't it the case? Do you > > have some links? > > > >> > >> Can we try to make landlock work completely independently of cgroups > >> so that it doesn't get stuck and so that programs can use it without > >> worrying about cgroup v1 vs v2, interactions with cgroup managers, > >> cgroup managers that (supposedly?) will start migrating processes > >> around piecemeal and almost certainly blowing up landlock in the > >> process, etc? > > > > This RFC handle both cgroup and seccomp approaches in a similar way. I > > don't see why building on top of cgroup v2 is a problem. Is there > > security issues with delegation? > > What I mean is: cgroup v2 delegation has a functionality problem. > Tejun says [1]: > > We haven't had to face this decision because cgroup has never properly > supported delegating to applications and the in-use setups where this > happens are custom configurations where there is no boundary between > system and applications and adhoc trial-and-error is good enough a way > to find a working solution. That wiggle room goes away once we > officially open this up to individual applications. > > Unless and until that changes, I think that landlock should stay away > from cgroups. Others could reasonably disagree with me. Ours and Sargun's use cases for cgroup+lsm+bpf is not for security and not for sandboxing. So the above doesn't matter in such contexts. lsm hooks + cgroups provide convenient scope and existing entry points. Please see checmate examples how it's used.
On Wed, Sep 14, 2016 at 7:19 PM, Alexei Starovoitov <alexei.starovoitov@gmail.com> wrote: > On Wed, Sep 14, 2016 at 06:25:07PM -0700, Andy Lutomirski wrote: >> On Wed, Sep 14, 2016 at 3:11 PM, Mickaël Salaün <mic@digikod.net> wrote: >> > >> > On 14/09/2016 20:27, Andy Lutomirski wrote: >> >> On Wed, Sep 14, 2016 at 12:24 AM, Mickaël Salaün <mic@digikod.net> wrote: >> >>> Add a new flag CGRP_NO_NEW_PRIVS for each cgroup. This flag is initially >> >>> set for all cgroup except the root. The flag is clear when a new process >> >>> without the no_new_privs flags is attached to the cgroup. >> >>> >> >>> If a cgroup is landlocked, then any new attempt, from an unprivileged >> >>> process, to attach a process without no_new_privs to this cgroup will >> >>> be denied. >> >> >> >> Until and unless everyone can agree on a way to properly namespace, >> >> delegate, etc cgroups, I think that trying to add unprivileged >> >> semantics to cgroups is nuts. Given the big thread about cgroup v2, >> >> no-internal-tasks, etc, I just don't see how this approach can be >> >> viable. >> > >> > As far as I can tell, the no_new_privs flag of at task is not related to >> > namespaces. The CGRP_NO_NEW_PRIVS flag is only a cache to quickly access >> > the no_new_privs property of *tasks* in a cgroup. The semantic is unchanged. >> > >> > Using cgroup is optional, any task could use the seccomp-based >> > landlocking instead. However, for those that want/need to manage a >> > security policy in a more dynamic way, using cgroups may make sense. >> > >> > I though cgroup delegation was OK in the v2, isn't it the case? Do you >> > have some links? >> > >> >> >> >> Can we try to make landlock work completely independently of cgroups >> >> so that it doesn't get stuck and so that programs can use it without >> >> worrying about cgroup v1 vs v2, interactions with cgroup managers, >> >> cgroup managers that (supposedly?) will start migrating processes >> >> around piecemeal and almost certainly blowing up landlock in the >> >> process, etc? >> > >> > This RFC handle both cgroup and seccomp approaches in a similar way. I >> > don't see why building on top of cgroup v2 is a problem. Is there >> > security issues with delegation? >> >> What I mean is: cgroup v2 delegation has a functionality problem. >> Tejun says [1]: >> >> We haven't had to face this decision because cgroup has never properly >> supported delegating to applications and the in-use setups where this >> happens are custom configurations where there is no boundary between >> system and applications and adhoc trial-and-error is good enough a way >> to find a working solution. That wiggle room goes away once we >> officially open this up to individual applications. >> >> Unless and until that changes, I think that landlock should stay away >> from cgroups. Others could reasonably disagree with me. > > Ours and Sargun's use cases for cgroup+lsm+bpf is not for security > and not for sandboxing. So the above doesn't matter in such contexts. > lsm hooks + cgroups provide convenient scope and existing entry points. > Please see checmate examples how it's used. > To be clear: I'm not arguing at all that there shouldn't be bpf+lsm+cgroup integration. I'm arguing that the unprivileged landlock interface shouldn't expose any cgroup integration, at least until the cgroup situation settles down a lot. --Andy
On Wed, Sep 14, 2016 at 07:27:08PM -0700, Andy Lutomirski wrote: > >> > > >> > This RFC handle both cgroup and seccomp approaches in a similar way. I > >> > don't see why building on top of cgroup v2 is a problem. Is there > >> > security issues with delegation? > >> > >> What I mean is: cgroup v2 delegation has a functionality problem. > >> Tejun says [1]: > >> > >> We haven't had to face this decision because cgroup has never properly > >> supported delegating to applications and the in-use setups where this > >> happens are custom configurations where there is no boundary between > >> system and applications and adhoc trial-and-error is good enough a way > >> to find a working solution. That wiggle room goes away once we > >> officially open this up to individual applications. > >> > >> Unless and until that changes, I think that landlock should stay away > >> from cgroups. Others could reasonably disagree with me. > > > > Ours and Sargun's use cases for cgroup+lsm+bpf is not for security > > and not for sandboxing. So the above doesn't matter in such contexts. > > lsm hooks + cgroups provide convenient scope and existing entry points. > > Please see checmate examples how it's used. > > > > To be clear: I'm not arguing at all that there shouldn't be > bpf+lsm+cgroup integration. I'm arguing that the unprivileged > landlock interface shouldn't expose any cgroup integration, at least > until the cgroup situation settles down a lot. ahh. yes. we're perfectly in agreement here. I'm suggesting that the next RFC shouldn't include unpriv and seccomp at all. Once bpf+lsm+cgroup is merged, we can argue about unpriv with cgroups and even unpriv as a whole, since it's not a given. Seccomp integration is also questionable. I'd rather not have seccomp as a gate keeper for this lsm. lsm and seccomp are orthogonal hook points. Syscalls and lsm hooks don't have one to one relationship, so mixing them up is only asking for trouble further down the road. If we really need to carry some information from seccomp to lsm+bpf, it's easier to add eBPF support to seccomp and let bpf side deal with passing whatever information.
On Wed, Sep 14, 2016 at 9:00 PM, Alexei Starovoitov <alexei.starovoitov@gmail.com> wrote: > On Wed, Sep 14, 2016 at 07:27:08PM -0700, Andy Lutomirski wrote: >> >> > >> >> > This RFC handle both cgroup and seccomp approaches in a similar way. I >> >> > don't see why building on top of cgroup v2 is a problem. Is there >> >> > security issues with delegation? >> >> >> >> What I mean is: cgroup v2 delegation has a functionality problem. >> >> Tejun says [1]: >> >> >> >> We haven't had to face this decision because cgroup has never properly >> >> supported delegating to applications and the in-use setups where this >> >> happens are custom configurations where there is no boundary between >> >> system and applications and adhoc trial-and-error is good enough a way >> >> to find a working solution. That wiggle room goes away once we >> >> officially open this up to individual applications. >> >> >> >> Unless and until that changes, I think that landlock should stay away >> >> from cgroups. Others could reasonably disagree with me. >> > >> > Ours and Sargun's use cases for cgroup+lsm+bpf is not for security >> > and not for sandboxing. So the above doesn't matter in such contexts. >> > lsm hooks + cgroups provide convenient scope and existing entry points. >> > Please see checmate examples how it's used. >> > >> >> To be clear: I'm not arguing at all that there shouldn't be >> bpf+lsm+cgroup integration. I'm arguing that the unprivileged >> landlock interface shouldn't expose any cgroup integration, at least >> until the cgroup situation settles down a lot. > > ahh. yes. we're perfectly in agreement here. > I'm suggesting that the next RFC shouldn't include unpriv > and seccomp at all. Once bpf+lsm+cgroup is merged, we can > argue about unpriv with cgroups and even unpriv as a whole, > since it's not a given. Seccomp integration is also questionable. > I'd rather not have seccomp as a gate keeper for this lsm. > lsm and seccomp are orthogonal hook points. Syscalls and lsm hooks > don't have one to one relationship, so mixing them up is only > asking for trouble further down the road. > If we really need to carry some information from seccomp to lsm+bpf, > it's easier to add eBPF support to seccomp and let bpf side deal > with passing whatever information. > As an argument for keeping seccomp (or an extended seccomp) as the interface for an unprivileged bpf+lsm: seccomp already checks off most of the boxes for safely letting unprivileged programs sandbox themselves. Furthermore, to the extent that there are use cases for unprivileged bpf+lsm that *aren't* expressible within the seccomp hierarchy, I suspect that syscall filters have exactly the same problem and that we should fix seccomp to cover it. If I ever add a "seccomp monitor", which is something I want to do eventually, I think it should work for lsm+bpf as well, which is another argument for keeping it in seccomp. --Andy
On Wed, Sep 14, 2016 at 09:08:57PM -0700, Andy Lutomirski wrote: > On Wed, Sep 14, 2016 at 9:00 PM, Alexei Starovoitov > <alexei.starovoitov@gmail.com> wrote: > > On Wed, Sep 14, 2016 at 07:27:08PM -0700, Andy Lutomirski wrote: > >> >> > > >> >> > This RFC handle both cgroup and seccomp approaches in a similar way. I > >> >> > don't see why building on top of cgroup v2 is a problem. Is there > >> >> > security issues with delegation? > >> >> > >> >> What I mean is: cgroup v2 delegation has a functionality problem. > >> >> Tejun says [1]: > >> >> > >> >> We haven't had to face this decision because cgroup has never properly > >> >> supported delegating to applications and the in-use setups where this > >> >> happens are custom configurations where there is no boundary between > >> >> system and applications and adhoc trial-and-error is good enough a way > >> >> to find a working solution. That wiggle room goes away once we > >> >> officially open this up to individual applications. > >> >> > >> >> Unless and until that changes, I think that landlock should stay away > >> >> from cgroups. Others could reasonably disagree with me. > >> > > >> > Ours and Sargun's use cases for cgroup+lsm+bpf is not for security > >> > and not for sandboxing. So the above doesn't matter in such contexts. > >> > lsm hooks + cgroups provide convenient scope and existing entry points. > >> > Please see checmate examples how it's used. > >> > > >> > >> To be clear: I'm not arguing at all that there shouldn't be > >> bpf+lsm+cgroup integration. I'm arguing that the unprivileged > >> landlock interface shouldn't expose any cgroup integration, at least > >> until the cgroup situation settles down a lot. > > > > ahh. yes. we're perfectly in agreement here. > > I'm suggesting that the next RFC shouldn't include unpriv > > and seccomp at all. Once bpf+lsm+cgroup is merged, we can > > argue about unpriv with cgroups and even unpriv as a whole, > > since it's not a given. Seccomp integration is also questionable. > > I'd rather not have seccomp as a gate keeper for this lsm. > > lsm and seccomp are orthogonal hook points. Syscalls and lsm hooks > > don't have one to one relationship, so mixing them up is only > > asking for trouble further down the road. > > If we really need to carry some information from seccomp to lsm+bpf, > > it's easier to add eBPF support to seccomp and let bpf side deal > > with passing whatever information. > > > > As an argument for keeping seccomp (or an extended seccomp) as the > interface for an unprivileged bpf+lsm: seccomp already checks off most > of the boxes for safely letting unprivileged programs sandbox > themselves. you mean the attach part of seccomp syscall that deals with no_new_priv? sure, that's reusable. > Furthermore, to the extent that there are use cases for > unprivileged bpf+lsm that *aren't* expressible within the seccomp > hierarchy, I suspect that syscall filters have exactly the same > problem and that we should fix seccomp to cover it. not sure what you mean by 'seccomp hierarchy'. The normal process hierarchy ? imo the main deficiency of secccomp is inability to look into arguments. One can argue that it's a blessing, since composite args are not yet copied into the kernel memory. But in a lot of cases the seccomp arguments are FDs pointing to kernel objects and if programs could examine those objects the sandboxing scope would be more precise. lsm+bpf solves that part and I'd still argue that it's orthogonal to seccomp's pass/reject flow. I mean if seccomp says 'ok' the syscall should continue executing as normal and whatever LSM hooks were triggered by it may have their own lsm+bpf verdicts. Furthermore in the process hierarchy different children should be able to set their own lsm+bpf filters that are not related to parallel seccomp+bpf hierarchy of programs. seccomp syscall can be an interface to attach programs to lsm hooks, but nothing more than that.
On Wed, Sep 14, 2016 at 9:31 PM, Alexei Starovoitov <alexei.starovoitov@gmail.com> wrote: > On Wed, Sep 14, 2016 at 09:08:57PM -0700, Andy Lutomirski wrote: >> On Wed, Sep 14, 2016 at 9:00 PM, Alexei Starovoitov >> <alexei.starovoitov@gmail.com> wrote: >> > On Wed, Sep 14, 2016 at 07:27:08PM -0700, Andy Lutomirski wrote: >> >> >> > >> >> >> > This RFC handle both cgroup and seccomp approaches in a similar way. I >> >> >> > don't see why building on top of cgroup v2 is a problem. Is there >> >> >> > security issues with delegation? >> >> >> >> >> >> What I mean is: cgroup v2 delegation has a functionality problem. >> >> >> Tejun says [1]: >> >> >> >> >> >> We haven't had to face this decision because cgroup has never properly >> >> >> supported delegating to applications and the in-use setups where this >> >> >> happens are custom configurations where there is no boundary between >> >> >> system and applications and adhoc trial-and-error is good enough a way >> >> >> to find a working solution. That wiggle room goes away once we >> >> >> officially open this up to individual applications. >> >> >> >> >> >> Unless and until that changes, I think that landlock should stay away >> >> >> from cgroups. Others could reasonably disagree with me. >> >> > >> >> > Ours and Sargun's use cases for cgroup+lsm+bpf is not for security >> >> > and not for sandboxing. So the above doesn't matter in such contexts. >> >> > lsm hooks + cgroups provide convenient scope and existing entry points. >> >> > Please see checmate examples how it's used. >> >> > >> >> >> >> To be clear: I'm not arguing at all that there shouldn't be >> >> bpf+lsm+cgroup integration. I'm arguing that the unprivileged >> >> landlock interface shouldn't expose any cgroup integration, at least >> >> until the cgroup situation settles down a lot. >> > >> > ahh. yes. we're perfectly in agreement here. >> > I'm suggesting that the next RFC shouldn't include unpriv >> > and seccomp at all. Once bpf+lsm+cgroup is merged, we can >> > argue about unpriv with cgroups and even unpriv as a whole, >> > since it's not a given. Seccomp integration is also questionable. >> > I'd rather not have seccomp as a gate keeper for this lsm. >> > lsm and seccomp are orthogonal hook points. Syscalls and lsm hooks >> > don't have one to one relationship, so mixing them up is only >> > asking for trouble further down the road. >> > If we really need to carry some information from seccomp to lsm+bpf, >> > it's easier to add eBPF support to seccomp and let bpf side deal >> > with passing whatever information. >> > >> >> As an argument for keeping seccomp (or an extended seccomp) as the >> interface for an unprivileged bpf+lsm: seccomp already checks off most >> of the boxes for safely letting unprivileged programs sandbox >> themselves. > > you mean the attach part of seccomp syscall that deals with no_new_priv? > sure, that's reusable. > >> Furthermore, to the extent that there are use cases for >> unprivileged bpf+lsm that *aren't* expressible within the seccomp >> hierarchy, I suspect that syscall filters have exactly the same >> problem and that we should fix seccomp to cover it. > > not sure what you mean by 'seccomp hierarchy'. The normal process > hierarchy ? Kind of. I mean the filter layers that are inherited across fork(), the TSYNC mechanism, etc. > imo the main deficiency of secccomp is inability to look into arguments. > One can argue that it's a blessing, since composite args > are not yet copied into the kernel memory. > But in a lot of cases the seccomp arguments are FDs pointing > to kernel objects and if programs could examine those objects > the sandboxing scope would be more precise. > lsm+bpf solves that part and I'd still argue that it's > orthogonal to seccomp's pass/reject flow. > I mean if seccomp says 'ok' the syscall should continue executing > as normal and whatever LSM hooks were triggered by it may have > their own lsm+bpf verdicts. I agree with all of this... > Furthermore in the process hierarchy different children > should be able to set their own lsm+bpf filters that are not > related to parallel seccomp+bpf hierarchy of programs. > seccomp syscall can be an interface to attach programs > to lsm hooks, but nothing more than that. I'm not sure what you mean. I mean that, logically, I think we should be able to do: seccomp(attach a syscall filter); fork(); child does seccomp(attach some lsm filters); I think that they *should* be related to the seccomp+bpf hierarchy of programs in that they are entries in the same logical list of filter layers installed. Some of those layers can be syscall filters and some of the layers can be lsm filters. If we subsequently add a way to attach a removable seccomp filter or a way to attach a seccomp filter that logs failures to some fd watched by an outside monitor, I think that should work for lsm, too, with more or less the same interface. If we need a way for a sandbox manager to opt different children into different subsets of fancy filters, then I think that syscall filters and lsm filters should use the same mechanism. I think we might be on the same page here and just saying it different ways.
On Wed, Sep 14, 2016 at 09:38:16PM -0700, Andy Lutomirski wrote: > On Wed, Sep 14, 2016 at 9:31 PM, Alexei Starovoitov > <alexei.starovoitov@gmail.com> wrote: > > On Wed, Sep 14, 2016 at 09:08:57PM -0700, Andy Lutomirski wrote: > >> On Wed, Sep 14, 2016 at 9:00 PM, Alexei Starovoitov > >> <alexei.starovoitov@gmail.com> wrote: > >> > On Wed, Sep 14, 2016 at 07:27:08PM -0700, Andy Lutomirski wrote: > >> >> >> > > >> >> >> > This RFC handle both cgroup and seccomp approaches in a similar way. I > >> >> >> > don't see why building on top of cgroup v2 is a problem. Is there > >> >> >> > security issues with delegation? > >> >> >> > >> >> >> What I mean is: cgroup v2 delegation has a functionality problem. > >> >> >> Tejun says [1]: > >> >> >> > >> >> >> We haven't had to face this decision because cgroup has never properly > >> >> >> supported delegating to applications and the in-use setups where this > >> >> >> happens are custom configurations where there is no boundary between > >> >> >> system and applications and adhoc trial-and-error is good enough a way > >> >> >> to find a working solution. That wiggle room goes away once we > >> >> >> officially open this up to individual applications. > >> >> >> > >> >> >> Unless and until that changes, I think that landlock should stay away > >> >> >> from cgroups. Others could reasonably disagree with me. > >> >> > > >> >> > Ours and Sargun's use cases for cgroup+lsm+bpf is not for security > >> >> > and not for sandboxing. So the above doesn't matter in such contexts. > >> >> > lsm hooks + cgroups provide convenient scope and existing entry points. > >> >> > Please see checmate examples how it's used. > >> >> > > >> >> > >> >> To be clear: I'm not arguing at all that there shouldn't be > >> >> bpf+lsm+cgroup integration. I'm arguing that the unprivileged > >> >> landlock interface shouldn't expose any cgroup integration, at least > >> >> until the cgroup situation settles down a lot. > >> > > >> > ahh. yes. we're perfectly in agreement here. > >> > I'm suggesting that the next RFC shouldn't include unpriv > >> > and seccomp at all. Once bpf+lsm+cgroup is merged, we can > >> > argue about unpriv with cgroups and even unpriv as a whole, > >> > since it's not a given. Seccomp integration is also questionable. > >> > I'd rather not have seccomp as a gate keeper for this lsm. > >> > lsm and seccomp are orthogonal hook points. Syscalls and lsm hooks > >> > don't have one to one relationship, so mixing them up is only > >> > asking for trouble further down the road. > >> > If we really need to carry some information from seccomp to lsm+bpf, > >> > it's easier to add eBPF support to seccomp and let bpf side deal > >> > with passing whatever information. > >> > > >> > >> As an argument for keeping seccomp (or an extended seccomp) as the > >> interface for an unprivileged bpf+lsm: seccomp already checks off most > >> of the boxes for safely letting unprivileged programs sandbox > >> themselves. > > > > you mean the attach part of seccomp syscall that deals with no_new_priv? > > sure, that's reusable. > > > >> Furthermore, to the extent that there are use cases for > >> unprivileged bpf+lsm that *aren't* expressible within the seccomp > >> hierarchy, I suspect that syscall filters have exactly the same > >> problem and that we should fix seccomp to cover it. > > > > not sure what you mean by 'seccomp hierarchy'. The normal process > > hierarchy ? > > Kind of. I mean the filter layers that are inherited across fork(), > the TSYNC mechanism, etc. > > > imo the main deficiency of secccomp is inability to look into arguments. > > One can argue that it's a blessing, since composite args > > are not yet copied into the kernel memory. > > But in a lot of cases the seccomp arguments are FDs pointing > > to kernel objects and if programs could examine those objects > > the sandboxing scope would be more precise. > > lsm+bpf solves that part and I'd still argue that it's > > orthogonal to seccomp's pass/reject flow. > > I mean if seccomp says 'ok' the syscall should continue executing > > as normal and whatever LSM hooks were triggered by it may have > > their own lsm+bpf verdicts. > > I agree with all of this... > > > Furthermore in the process hierarchy different children > > should be able to set their own lsm+bpf filters that are not > > related to parallel seccomp+bpf hierarchy of programs. > > seccomp syscall can be an interface to attach programs > > to lsm hooks, but nothing more than that. > > I'm not sure what you mean. I mean that, logically, I think we should > be able to do: > > seccomp(attach a syscall filter); > fork(); > child does seccomp(attach some lsm filters); > > I think that they *should* be related to the seccomp+bpf hierarchy of > programs in that they are entries in the same logical list of filter > layers installed. Some of those layers can be syscall filters and > some of the layers can be lsm filters. If we subsequently add a way > to attach a removable seccomp filter or a way to attach a seccomp > filter that logs failures to some fd watched by an outside monitor, I > think that should work for lsm, too, with more or less the same > interface. > > If we need a way for a sandbox manager to opt different children into > different subsets of fancy filters, then I think that syscall filters > and lsm filters should use the same mechanism. > > I think we might be on the same page here and just saying it different ways. Sounds like it :) All of the above makes sense to me. The 'orthogonal' part is that the user should be able to use this seccomp-managed hierarchy without actually enabling TIF_SECCOMP for the task and syscalls should still go through fast path and all the way till lsm hooks as normal. I don't want to pay _any_ performance penalty for this feature for lsm hooks (and all syscalls) that don't have bpf programs attached.
On 15/09/2016 03:25, Andy Lutomirski wrote: > On Wed, Sep 14, 2016 at 3:11 PM, Mickaël Salaün <mic@digikod.net> wrote: >> >> On 14/09/2016 20:27, Andy Lutomirski wrote: >>> On Wed, Sep 14, 2016 at 12:24 AM, Mickaël Salaün <mic@digikod.net> wrote: >>>> Add a new flag CGRP_NO_NEW_PRIVS for each cgroup. This flag is initially >>>> set for all cgroup except the root. The flag is clear when a new process >>>> without the no_new_privs flags is attached to the cgroup. >>>> >>>> If a cgroup is landlocked, then any new attempt, from an unprivileged >>>> process, to attach a process without no_new_privs to this cgroup will >>>> be denied. >>> >>> Until and unless everyone can agree on a way to properly namespace, >>> delegate, etc cgroups, I think that trying to add unprivileged >>> semantics to cgroups is nuts. Given the big thread about cgroup v2, >>> no-internal-tasks, etc, I just don't see how this approach can be >>> viable. >> >> As far as I can tell, the no_new_privs flag of at task is not related to >> namespaces. The CGRP_NO_NEW_PRIVS flag is only a cache to quickly access >> the no_new_privs property of *tasks* in a cgroup. The semantic is unchanged. >> >> Using cgroup is optional, any task could use the seccomp-based >> landlocking instead. However, for those that want/need to manage a >> security policy in a more dynamic way, using cgroups may make sense. >> >> I though cgroup delegation was OK in the v2, isn't it the case? Do you >> have some links? >> >>> >>> Can we try to make landlock work completely independently of cgroups >>> so that it doesn't get stuck and so that programs can use it without >>> worrying about cgroup v1 vs v2, interactions with cgroup managers, >>> cgroup managers that (supposedly?) will start migrating processes >>> around piecemeal and almost certainly blowing up landlock in the >>> process, etc? >> >> This RFC handle both cgroup and seccomp approaches in a similar way. I >> don't see why building on top of cgroup v2 is a problem. Is there >> security issues with delegation? > > What I mean is: cgroup v2 delegation has a functionality problem. > Tejun says [1]: > > We haven't had to face this decision because cgroup has never properly > supported delegating to applications and the in-use setups where this > happens are custom configurations where there is no boundary between > system and applications and adhoc trial-and-error is good enough a way > to find a working solution. That wiggle room goes away once we > officially open this up to individual applications. > > Unless and until that changes, I think that landlock should stay away > from cgroups. Others could reasonably disagree with me. > > [1] https://lkml.kernel.org/r/20160909225747.GA30105@mtj.duckdns.org > I don't get the same echo here: https://lkml.kernel.org/r/20160826155026.GD16906@mtj.duckdns.org On 26/08/2016 17:50, Tejun Heo wrote: > Please refer to "2-5. Delegation" of Documentation/cgroup-v2.txt. > Delegation on v1 is broken on both core and specific controller > behaviors and thus discouraged. On v2, delegation should work just > fine. Tejun, could you please clarify if there is still a problem with cgroup v2 delegation? This patch only implement a cache mechanism with the CGRP_NO_NEW_PRIVS flag. If cgroups can group processes correctly, I don't see any (security) issue here. It's the administrator choice to delegate a part of the cgroup management. It's then the delegatee responsibility to correctly put processes in cgroups. This is comparable to a process which is responsible to correctly call seccomp(2). Mickaël
On 15/09/2016 06:48, Alexei Starovoitov wrote: > On Wed, Sep 14, 2016 at 09:38:16PM -0700, Andy Lutomirski wrote: >> On Wed, Sep 14, 2016 at 9:31 PM, Alexei Starovoitov >> <alexei.starovoitov@gmail.com> wrote: >>> On Wed, Sep 14, 2016 at 09:08:57PM -0700, Andy Lutomirski wrote: >>>> On Wed, Sep 14, 2016 at 9:00 PM, Alexei Starovoitov >>>> <alexei.starovoitov@gmail.com> wrote: >>>>> On Wed, Sep 14, 2016 at 07:27:08PM -0700, Andy Lutomirski wrote: >>>>>>>>> >>>>>>>>> This RFC handle both cgroup and seccomp approaches in a similar way. I >>>>>>>>> don't see why building on top of cgroup v2 is a problem. Is there >>>>>>>>> security issues with delegation? >>>>>>>> >>>>>>>> What I mean is: cgroup v2 delegation has a functionality problem. >>>>>>>> Tejun says [1]: >>>>>>>> >>>>>>>> We haven't had to face this decision because cgroup has never properly >>>>>>>> supported delegating to applications and the in-use setups where this >>>>>>>> happens are custom configurations where there is no boundary between >>>>>>>> system and applications and adhoc trial-and-error is good enough a way >>>>>>>> to find a working solution. That wiggle room goes away once we >>>>>>>> officially open this up to individual applications. >>>>>>>> >>>>>>>> Unless and until that changes, I think that landlock should stay away >>>>>>>> from cgroups. Others could reasonably disagree with me. >>>>>>> >>>>>>> Ours and Sargun's use cases for cgroup+lsm+bpf is not for security >>>>>>> and not for sandboxing. So the above doesn't matter in such contexts. >>>>>>> lsm hooks + cgroups provide convenient scope and existing entry points. >>>>>>> Please see checmate examples how it's used. >>>>>>> >>>>>> >>>>>> To be clear: I'm not arguing at all that there shouldn't be >>>>>> bpf+lsm+cgroup integration. I'm arguing that the unprivileged >>>>>> landlock interface shouldn't expose any cgroup integration, at least >>>>>> until the cgroup situation settles down a lot. >>>>> >>>>> ahh. yes. we're perfectly in agreement here. >>>>> I'm suggesting that the next RFC shouldn't include unpriv >>>>> and seccomp at all. Once bpf+lsm+cgroup is merged, we can >>>>> argue about unpriv with cgroups and even unpriv as a whole, >>>>> since it's not a given. Seccomp integration is also questionable. >>>>> I'd rather not have seccomp as a gate keeper for this lsm. >>>>> lsm and seccomp are orthogonal hook points. Syscalls and lsm hooks >>>>> don't have one to one relationship, so mixing them up is only >>>>> asking for trouble further down the road. >>>>> If we really need to carry some information from seccomp to lsm+bpf, >>>>> it's easier to add eBPF support to seccomp and let bpf side deal >>>>> with passing whatever information. >>>>> >>>> >>>> As an argument for keeping seccomp (or an extended seccomp) as the >>>> interface for an unprivileged bpf+lsm: seccomp already checks off most >>>> of the boxes for safely letting unprivileged programs sandbox >>>> themselves. >>> >>> you mean the attach part of seccomp syscall that deals with no_new_priv? >>> sure, that's reusable. >>> >>>> Furthermore, to the extent that there are use cases for >>>> unprivileged bpf+lsm that *aren't* expressible within the seccomp >>>> hierarchy, I suspect that syscall filters have exactly the same >>>> problem and that we should fix seccomp to cover it. >>> >>> not sure what you mean by 'seccomp hierarchy'. The normal process >>> hierarchy ? >> >> Kind of. I mean the filter layers that are inherited across fork(), >> the TSYNC mechanism, etc. >> >>> imo the main deficiency of secccomp is inability to look into arguments. >>> One can argue that it's a blessing, since composite args >>> are not yet copied into the kernel memory. >>> But in a lot of cases the seccomp arguments are FDs pointing >>> to kernel objects and if programs could examine those objects >>> the sandboxing scope would be more precise. >>> lsm+bpf solves that part and I'd still argue that it's >>> orthogonal to seccomp's pass/reject flow. >>> I mean if seccomp says 'ok' the syscall should continue executing >>> as normal and whatever LSM hooks were triggered by it may have >>> their own lsm+bpf verdicts. >> >> I agree with all of this... >> >>> Furthermore in the process hierarchy different children >>> should be able to set their own lsm+bpf filters that are not >>> related to parallel seccomp+bpf hierarchy of programs. >>> seccomp syscall can be an interface to attach programs >>> to lsm hooks, but nothing more than that. >> >> I'm not sure what you mean. I mean that, logically, I think we should >> be able to do: >> >> seccomp(attach a syscall filter); >> fork(); >> child does seccomp(attach some lsm filters); >> >> I think that they *should* be related to the seccomp+bpf hierarchy of >> programs in that they are entries in the same logical list of filter >> layers installed. Some of those layers can be syscall filters and >> some of the layers can be lsm filters. If we subsequently add a way >> to attach a removable seccomp filter or a way to attach a seccomp >> filter that logs failures to some fd watched by an outside monitor, I >> think that should work for lsm, too, with more or less the same >> interface. >> >> If we need a way for a sandbox manager to opt different children into >> different subsets of fancy filters, then I think that syscall filters >> and lsm filters should use the same mechanism. >> >> I think we might be on the same page here and just saying it different ways. > > Sounds like it :) > All of the above makes sense to me. > The 'orthogonal' part is that the user should be able to use > this seccomp-managed hierarchy without actually enabling > TIF_SECCOMP for the task and syscalls should still go through > fast path and all the way till lsm hooks as normal. > I don't want to pay _any_ performance penalty for this feature > for lsm hooks (and all syscalls) that don't have bpf programs attached. Yes, it seems that we are all on the same page here, and that match this RFC implementation. So, using the seccomp(2) *interface* to attach Landlock programs to a process hierarchy is still on track. :)
On Thu, Sep 15, 2016 at 09:41:33PM +0200, Mickaël Salaün wrote: > > On 15/09/2016 06:48, Alexei Starovoitov wrote: > > On Wed, Sep 14, 2016 at 09:38:16PM -0700, Andy Lutomirski wrote: > >> On Wed, Sep 14, 2016 at 9:31 PM, Alexei Starovoitov > >> <alexei.starovoitov@gmail.com> wrote: > >>> On Wed, Sep 14, 2016 at 09:08:57PM -0700, Andy Lutomirski wrote: > >>>> On Wed, Sep 14, 2016 at 9:00 PM, Alexei Starovoitov > >>>> <alexei.starovoitov@gmail.com> wrote: > >>>>> On Wed, Sep 14, 2016 at 07:27:08PM -0700, Andy Lutomirski wrote: > >>>>>>>>> > >>>>>>>>> This RFC handle both cgroup and seccomp approaches in a similar way. I > >>>>>>>>> don't see why building on top of cgroup v2 is a problem. Is there > >>>>>>>>> security issues with delegation? > >>>>>>>> > >>>>>>>> What I mean is: cgroup v2 delegation has a functionality problem. > >>>>>>>> Tejun says [1]: > >>>>>>>> > >>>>>>>> We haven't had to face this decision because cgroup has never properly > >>>>>>>> supported delegating to applications and the in-use setups where this > >>>>>>>> happens are custom configurations where there is no boundary between > >>>>>>>> system and applications and adhoc trial-and-error is good enough a way > >>>>>>>> to find a working solution. That wiggle room goes away once we > >>>>>>>> officially open this up to individual applications. > >>>>>>>> > >>>>>>>> Unless and until that changes, I think that landlock should stay away > >>>>>>>> from cgroups. Others could reasonably disagree with me. > >>>>>>> > >>>>>>> Ours and Sargun's use cases for cgroup+lsm+bpf is not for security > >>>>>>> and not for sandboxing. So the above doesn't matter in such contexts. > >>>>>>> lsm hooks + cgroups provide convenient scope and existing entry points. > >>>>>>> Please see checmate examples how it's used. > >>>>>>> > >>>>>> > >>>>>> To be clear: I'm not arguing at all that there shouldn't be > >>>>>> bpf+lsm+cgroup integration. I'm arguing that the unprivileged > >>>>>> landlock interface shouldn't expose any cgroup integration, at least > >>>>>> until the cgroup situation settles down a lot. > >>>>> > >>>>> ahh. yes. we're perfectly in agreement here. > >>>>> I'm suggesting that the next RFC shouldn't include unpriv > >>>>> and seccomp at all. Once bpf+lsm+cgroup is merged, we can > >>>>> argue about unpriv with cgroups and even unpriv as a whole, > >>>>> since it's not a given. Seccomp integration is also questionable. > >>>>> I'd rather not have seccomp as a gate keeper for this lsm. > >>>>> lsm and seccomp are orthogonal hook points. Syscalls and lsm hooks > >>>>> don't have one to one relationship, so mixing them up is only > >>>>> asking for trouble further down the road. > >>>>> If we really need to carry some information from seccomp to lsm+bpf, > >>>>> it's easier to add eBPF support to seccomp and let bpf side deal > >>>>> with passing whatever information. > >>>>> > >>>> > >>>> As an argument for keeping seccomp (or an extended seccomp) as the > >>>> interface for an unprivileged bpf+lsm: seccomp already checks off most > >>>> of the boxes for safely letting unprivileged programs sandbox > >>>> themselves. > >>> > >>> you mean the attach part of seccomp syscall that deals with no_new_priv? > >>> sure, that's reusable. > >>> > >>>> Furthermore, to the extent that there are use cases for > >>>> unprivileged bpf+lsm that *aren't* expressible within the seccomp > >>>> hierarchy, I suspect that syscall filters have exactly the same > >>>> problem and that we should fix seccomp to cover it. > >>> > >>> not sure what you mean by 'seccomp hierarchy'. The normal process > >>> hierarchy ? > >> > >> Kind of. I mean the filter layers that are inherited across fork(), > >> the TSYNC mechanism, etc. > >> > >>> imo the main deficiency of secccomp is inability to look into arguments. > >>> One can argue that it's a blessing, since composite args > >>> are not yet copied into the kernel memory. > >>> But in a lot of cases the seccomp arguments are FDs pointing > >>> to kernel objects and if programs could examine those objects > >>> the sandboxing scope would be more precise. > >>> lsm+bpf solves that part and I'd still argue that it's > >>> orthogonal to seccomp's pass/reject flow. > >>> I mean if seccomp says 'ok' the syscall should continue executing > >>> as normal and whatever LSM hooks were triggered by it may have > >>> their own lsm+bpf verdicts. > >> > >> I agree with all of this... > >> > >>> Furthermore in the process hierarchy different children > >>> should be able to set their own lsm+bpf filters that are not > >>> related to parallel seccomp+bpf hierarchy of programs. > >>> seccomp syscall can be an interface to attach programs > >>> to lsm hooks, but nothing more than that. > >> > >> I'm not sure what you mean. I mean that, logically, I think we should > >> be able to do: > >> > >> seccomp(attach a syscall filter); > >> fork(); > >> child does seccomp(attach some lsm filters); > >> > >> I think that they *should* be related to the seccomp+bpf hierarchy of > >> programs in that they are entries in the same logical list of filter > >> layers installed. Some of those layers can be syscall filters and > >> some of the layers can be lsm filters. If we subsequently add a way > >> to attach a removable seccomp filter or a way to attach a seccomp > >> filter that logs failures to some fd watched by an outside monitor, I > >> think that should work for lsm, too, with more or less the same > >> interface. > >> > >> If we need a way for a sandbox manager to opt different children into > >> different subsets of fancy filters, then I think that syscall filters > >> and lsm filters should use the same mechanism. > >> > >> I think we might be on the same page here and just saying it different ways. > > > > Sounds like it :) > > All of the above makes sense to me. > > The 'orthogonal' part is that the user should be able to use > > this seccomp-managed hierarchy without actually enabling > > TIF_SECCOMP for the task and syscalls should still go through > > fast path and all the way till lsm hooks as normal. > > I don't want to pay _any_ performance penalty for this feature > > for lsm hooks (and all syscalls) that don't have bpf programs attached. > > Yes, it seems that we are all on the same page here, and that match this > RFC implementation. So, using the seccomp(2) *interface* to attach > Landlock programs to a process hierarchy is still on track. :) > So, I'm catching up on this after a little while away. I really like the simplicity of the approach Daniel took with his patches. I began to have difficulty reading your patchset once you got into using seccomp + unprivileged mode. I would love to see a separate patchset that only have the verifier, and lsm hook changes. Do you think you could decompose your patchset into an MVP?
On 20/09/2016 06:37, Sargun Dhillon wrote: > On Thu, Sep 15, 2016 at 09:41:33PM +0200, Mickaël Salaün wrote: >> >> On 15/09/2016 06:48, Alexei Starovoitov wrote: >>> On Wed, Sep 14, 2016 at 09:38:16PM -0700, Andy Lutomirski wrote: >>>> On Wed, Sep 14, 2016 at 9:31 PM, Alexei Starovoitov >>>> <alexei.starovoitov@gmail.com> wrote: >>>>> On Wed, Sep 14, 2016 at 09:08:57PM -0700, Andy Lutomirski wrote: >>>>>> On Wed, Sep 14, 2016 at 9:00 PM, Alexei Starovoitov >>>>>> <alexei.starovoitov@gmail.com> wrote: >>>>>>> On Wed, Sep 14, 2016 at 07:27:08PM -0700, Andy Lutomirski wrote: >>>>>>>>>>> >>>>>>>>>>> This RFC handle both cgroup and seccomp approaches in a similar way. I >>>>>>>>>>> don't see why building on top of cgroup v2 is a problem. Is there >>>>>>>>>>> security issues with delegation? >>>>>>>>>> >>>>>>>>>> What I mean is: cgroup v2 delegation has a functionality problem. >>>>>>>>>> Tejun says [1]: >>>>>>>>>> >>>>>>>>>> We haven't had to face this decision because cgroup has never properly >>>>>>>>>> supported delegating to applications and the in-use setups where this >>>>>>>>>> happens are custom configurations where there is no boundary between >>>>>>>>>> system and applications and adhoc trial-and-error is good enough a way >>>>>>>>>> to find a working solution. That wiggle room goes away once we >>>>>>>>>> officially open this up to individual applications. >>>>>>>>>> >>>>>>>>>> Unless and until that changes, I think that landlock should stay away >>>>>>>>>> from cgroups. Others could reasonably disagree with me. >>>>>>>>> >>>>>>>>> Ours and Sargun's use cases for cgroup+lsm+bpf is not for security >>>>>>>>> and not for sandboxing. So the above doesn't matter in such contexts. >>>>>>>>> lsm hooks + cgroups provide convenient scope and existing entry points. >>>>>>>>> Please see checmate examples how it's used. >>>>>>>>> >>>>>>>> >>>>>>>> To be clear: I'm not arguing at all that there shouldn't be >>>>>>>> bpf+lsm+cgroup integration. I'm arguing that the unprivileged >>>>>>>> landlock interface shouldn't expose any cgroup integration, at least >>>>>>>> until the cgroup situation settles down a lot. >>>>>>> >>>>>>> ahh. yes. we're perfectly in agreement here. >>>>>>> I'm suggesting that the next RFC shouldn't include unpriv >>>>>>> and seccomp at all. Once bpf+lsm+cgroup is merged, we can >>>>>>> argue about unpriv with cgroups and even unpriv as a whole, >>>>>>> since it's not a given. Seccomp integration is also questionable. >>>>>>> I'd rather not have seccomp as a gate keeper for this lsm. >>>>>>> lsm and seccomp are orthogonal hook points. Syscalls and lsm hooks >>>>>>> don't have one to one relationship, so mixing them up is only >>>>>>> asking for trouble further down the road. >>>>>>> If we really need to carry some information from seccomp to lsm+bpf, >>>>>>> it's easier to add eBPF support to seccomp and let bpf side deal >>>>>>> with passing whatever information. >>>>>>> >>>>>> >>>>>> As an argument for keeping seccomp (or an extended seccomp) as the >>>>>> interface for an unprivileged bpf+lsm: seccomp already checks off most >>>>>> of the boxes for safely letting unprivileged programs sandbox >>>>>> themselves. >>>>> >>>>> you mean the attach part of seccomp syscall that deals with no_new_priv? >>>>> sure, that's reusable. >>>>> >>>>>> Furthermore, to the extent that there are use cases for >>>>>> unprivileged bpf+lsm that *aren't* expressible within the seccomp >>>>>> hierarchy, I suspect that syscall filters have exactly the same >>>>>> problem and that we should fix seccomp to cover it. >>>>> >>>>> not sure what you mean by 'seccomp hierarchy'. The normal process >>>>> hierarchy ? >>>> >>>> Kind of. I mean the filter layers that are inherited across fork(), >>>> the TSYNC mechanism, etc. >>>> >>>>> imo the main deficiency of secccomp is inability to look into arguments. >>>>> One can argue that it's a blessing, since composite args >>>>> are not yet copied into the kernel memory. >>>>> But in a lot of cases the seccomp arguments are FDs pointing >>>>> to kernel objects and if programs could examine those objects >>>>> the sandboxing scope would be more precise. >>>>> lsm+bpf solves that part and I'd still argue that it's >>>>> orthogonal to seccomp's pass/reject flow. >>>>> I mean if seccomp says 'ok' the syscall should continue executing >>>>> as normal and whatever LSM hooks were triggered by it may have >>>>> their own lsm+bpf verdicts. >>>> >>>> I agree with all of this... >>>> >>>>> Furthermore in the process hierarchy different children >>>>> should be able to set their own lsm+bpf filters that are not >>>>> related to parallel seccomp+bpf hierarchy of programs. >>>>> seccomp syscall can be an interface to attach programs >>>>> to lsm hooks, but nothing more than that. >>>> >>>> I'm not sure what you mean. I mean that, logically, I think we should >>>> be able to do: >>>> >>>> seccomp(attach a syscall filter); >>>> fork(); >>>> child does seccomp(attach some lsm filters); >>>> >>>> I think that they *should* be related to the seccomp+bpf hierarchy of >>>> programs in that they are entries in the same logical list of filter >>>> layers installed. Some of those layers can be syscall filters and >>>> some of the layers can be lsm filters. If we subsequently add a way >>>> to attach a removable seccomp filter or a way to attach a seccomp >>>> filter that logs failures to some fd watched by an outside monitor, I >>>> think that should work for lsm, too, with more or less the same >>>> interface. >>>> >>>> If we need a way for a sandbox manager to opt different children into >>>> different subsets of fancy filters, then I think that syscall filters >>>> and lsm filters should use the same mechanism. >>>> >>>> I think we might be on the same page here and just saying it different ways. >>> >>> Sounds like it :) >>> All of the above makes sense to me. >>> The 'orthogonal' part is that the user should be able to use >>> this seccomp-managed hierarchy without actually enabling >>> TIF_SECCOMP for the task and syscalls should still go through >>> fast path and all the way till lsm hooks as normal. >>> I don't want to pay _any_ performance penalty for this feature >>> for lsm hooks (and all syscalls) that don't have bpf programs attached. >> >> Yes, it seems that we are all on the same page here, and that match this >> RFC implementation. So, using the seccomp(2) *interface* to attach >> Landlock programs to a process hierarchy is still on track. :) >> > > So, I'm catching up on this after a little while away. I really like the > simplicity of the approach Daniel took with his patches. I began to have > difficulty reading your patchset once you got into using seccomp + unprivileged > mode. I would love to see a separate patchset that only have the verifier, and > lsm hook changes. Do you think you could decompose your patchset into an MVP? > OK, I'll try to split the common parts from the seccomp part, but there is already a dedicated patch for the LSM hooks [06/22].
diff --git a/include/linux/cgroup-defs.h b/include/linux/cgroup-defs.h index fe1023bf7b9d..ce0e4c90ae7d 100644 --- a/include/linux/cgroup-defs.h +++ b/include/linux/cgroup-defs.h @@ -59,6 +59,13 @@ enum { * specified at mount time and thus is implemented here. */ CGRP_CPUSET_CLONE_CHILDREN, + /* + * Keep track of the no_new_privs property of processes in the cgroup. + * This is useful to quickly check if all processes in the cgroup have + * their no_new_privs bit on. This flag is initially set to true but + * ANDed with every processes coming in the cgroup. + */ + CGRP_NO_NEW_PRIVS, }; /* cgroup_root->flags */ diff --git a/kernel/bpf/syscall.c b/kernel/bpf/syscall.c index f90225dbbb59..ff8b53a8a2a0 100644 --- a/kernel/bpf/syscall.c +++ b/kernel/bpf/syscall.c @@ -849,9 +849,10 @@ static int bpf_prog_attach(const union bpf_attr *attr) case BPF_CGROUP_LANDLOCK: #ifdef CONFIG_SECURITY_LANDLOCK - if (!capable(CAP_SYS_ADMIN)) - return -EPERM; - + /* + * security/capability check done in landlock_cgroup_set_hook() + * called by cgroup_bpf_update() + */ prog = bpf_prog_get_type(attr->attach_bpf_fd, BPF_PROG_TYPE_LANDLOCK); break; diff --git a/kernel/cgroup.c b/kernel/cgroup.c index 3bbaf3f02ed2..913e2d3b6d55 100644 --- a/kernel/cgroup.c +++ b/kernel/cgroup.c @@ -62,6 +62,7 @@ #include <linux/proc_ns.h> #include <linux/nsproxy.h> #include <linux/file.h> +#include <linux/bitops.h> #include <net/sock.h> #define CREATE_TRACE_POINTS @@ -1985,6 +1986,7 @@ static void init_cgroup_root(struct cgroup_root *root, strcpy(root->name, opts->name); if (opts->cpuset_clone_children) set_bit(CGRP_CPUSET_CLONE_CHILDREN, &root->cgrp.flags); + /* no CGRP_NO_NEW_PRIVS flag for the root */ } static int cgroup_setup_root(struct cgroup_root *root, u16 ss_mask) @@ -2812,14 +2814,35 @@ static int cgroup_attach_task(struct cgroup *dst_cgrp, LIST_HEAD(preloaded_csets); struct task_struct *task; int ret; +#if defined(CONFIG_CGROUP_BPF) && defined(CONFIG_SECURITY_LANDLOCK) + bool no_new_privs; +#endif /* CONFIG_CGROUP_BPF && CONFIG_SECURITY_LANDLOCK */ if (!cgroup_may_migrate_to(dst_cgrp)) return -EBUSY; + task = leader; +#if defined(CONFIG_CGROUP_BPF) && defined(CONFIG_SECURITY_LANDLOCK) + no_new_privs = !!(dst_cgrp->flags & BIT_ULL(CGRP_NO_NEW_PRIVS)); + do { + no_new_privs = no_new_privs && task_no_new_privs(task); + if (!no_new_privs) { + if (dst_cgrp->bpf.pinned[BPF_CGROUP_LANDLOCK].hooks && + security_capable_noaudit(current_cred(), + current_user_ns(), + CAP_SYS_ADMIN) != 0) + return -EPERM; + clear_bit(CGRP_NO_NEW_PRIVS, &dst_cgrp->flags); + break; + } + if (!threadgroup) + break; + } while_each_thread(leader, task); +#endif /* CONFIG_CGROUP_BPF && CONFIG_SECURITY_LANDLOCK */ + /* look up all src csets */ spin_lock_irq(&css_set_lock); rcu_read_lock(); - task = leader; do { cgroup_migrate_add_src(task_css_set(task), dst_cgrp, &preloaded_csets); @@ -4345,9 +4368,22 @@ int cgroup_transfer_tasks(struct cgroup *to, struct cgroup *from) return -EBUSY; mutex_lock(&cgroup_mutex); - percpu_down_write(&cgroup_threadgroup_rwsem); +#if defined(CONFIG_CGROUP_BPF) && defined(CONFIG_SECURITY_LANDLOCK) + if (!(from->flags & BIT_ULL(CGRP_NO_NEW_PRIVS))) { + if (to->bpf.pinned[BPF_CGROUP_LANDLOCK].hooks && + security_capable_noaudit(current_cred(), + current_user_ns(), CAP_SYS_ADMIN) != 0) { + pr_warn("%s: EPERM\n", __func__); + ret = -EPERM; + goto out_unlock; + } + pr_warn("%s: no EPERM\n", __func__); + clear_bit(CGRP_NO_NEW_PRIVS, &to->flags); + } +#endif /* CONFIG_CGROUP_BPF && CONFIG_SECURITY_LANDLOCK */ + /* all tasks in @from are being moved, all csets are source */ spin_lock_irq(&css_set_lock); list_for_each_entry(link, &from->cset_links, cset_link) @@ -4378,6 +4414,7 @@ int cgroup_transfer_tasks(struct cgroup *to, struct cgroup *from) } while (task && !ret); out_err: cgroup_migrate_finish(&preloaded_csets); +out_unlock: percpu_up_write(&cgroup_threadgroup_rwsem); mutex_unlock(&cgroup_mutex); return ret; @@ -5241,6 +5278,9 @@ static struct cgroup *cgroup_create(struct cgroup *parent) if (test_bit(CGRP_CPUSET_CLONE_CHILDREN, &parent->flags)) set_bit(CGRP_CPUSET_CLONE_CHILDREN, &cgrp->flags); +#if defined(CONFIG_CGROUP_BPF) && defined(CONFIG_SECURITY_LANDLOCK) + set_bit(CGRP_NO_NEW_PRIVS, &cgrp->flags); +#endif /* CONFIG_CGROUP_BPF && CONFIG_SECURITY_LANDLOCK */ cgrp->self.serial_nr = css_serial_nr_next++; diff --git a/security/landlock/manager.c b/security/landlock/manager.c index 50aa1305d0d1..479f6990aeff 100644 --- a/security/landlock/manager.c +++ b/security/landlock/manager.c @@ -11,6 +11,7 @@ #include <asm/atomic.h> /* atomic_*() */ #include <asm/page.h> /* PAGE_SIZE */ #include <asm/uaccess.h> /* copy_from_user() */ +#include <linux/bitops.h> /* BIT_ULL() */ #include <linux/bpf.h> /* bpf_prog_put() */ #include <linux/filter.h> /* struct bpf_prog */ #include <linux/kernel.h> /* round_up() */ @@ -267,6 +268,12 @@ struct landlock_hooks *landlock_cgroup_set_hook(struct cgroup *cgrp, if (!prog) return ERR_PTR(-EINVAL); + /* check no_new_privs for tasks in the cgroup */ + if (!(cgrp->flags & BIT_ULL(CGRP_NO_NEW_PRIVS)) && + security_capable_noaudit(current_cred(), + current_user_ns(), CAP_SYS_ADMIN) != 0) + return ERR_PTR(-EPERM); + /* copy the inherited hooks and append a new one */ return landlock_set_hook(cgrp->bpf.effective[BPF_CGROUP_LANDLOCK].hooks, prog, NULL);
Add a new flag CGRP_NO_NEW_PRIVS for each cgroup. This flag is initially set for all cgroup except the root. The flag is clear when a new process without the no_new_privs flags is attached to the cgroup. If a cgroup is landlocked, then any new attempt, from an unprivileged process, to attach a process without no_new_privs to this cgroup will be denied. This allows to safely manage Landlock rules with cgroup delegation as with seccomp. Signed-off-by: Mickaël Salaün <mic@digikod.net> Cc: Alexei Starovoitov <ast@kernel.org> Cc: Andy Lutomirski <luto@amacapital.net> Cc: Daniel Borkmann <daniel@iogearbox.net> Cc: Daniel Mack <daniel@zonque.org> Cc: David S. Miller <davem@davemloft.net> Cc: Kees Cook <keescook@chromium.org> Cc: Tejun Heo <tj@kernel.org> --- include/linux/cgroup-defs.h | 7 +++++++ kernel/bpf/syscall.c | 7 ++++--- kernel/cgroup.c | 44 ++++++++++++++++++++++++++++++++++++++++++-- security/landlock/manager.c | 7 +++++++ 4 files changed, 60 insertions(+), 5 deletions(-)