| Message ID | 20250502184421.1424368-1-bboscaccy@linux.microsoft.com |
|---|---|
| Headers | show |
| Series | Introducing Hornet LSM | expand |
> This patch series introduces the Hornet LSM. The goal of Hornet is to provide > a signature verification mechanism for eBPF programs. > [...] > > References: [1] > https://lore.kernel.org/bpf/20220209054315.73833-1-alexei.starovoitov@gmail.com/ > [2] > https://lore.kernel.org/bpf/CAADnVQ+wPK1KKZhCgb-Nnf0Xfjk8M1UpX5fnXC=cBzdEYbv_kg@mail.gmail.com/ > > Change list: - v2 -> v3 - Remove any and all usage of proprietary bpf APIs BPF APIs are not proprietary, but you cannot implement BPF program signing for BPF users without aligning with the BPF maintainers and the community. Signed programs are a UAPI and a key part of how developers experience BPF and this is not how we would like signing to be experienced by BPF users. Some more feedback (which should be pretty obvious) but explicitly: * Hacks like if (current->pid == 1) return 0; also break your threat model about root being untrusted. This is all the more reason I think signing should be integrated into other LSMs, only a proper LSM policy can breathe life into the root / kernel boundary. * You also did not take the feedback into account: new = map->ops->map_lookup_elem(map, &key); This is not okay without having the BPF maintainers aligned, the same way as https://patchwork.kernel.org/project/netdevbpf/patch/20240629084331.3807368-4-kpsingh@kernel.org/#25928981 was not okay. Let's not have double standards. * And you copy pasted tools/testing/selftests/hornet/frozen_skel.h which is what you expect users to do? Not acceptable either. So for this approach, it's a: Nacked-by: KP Singh <kpsingh@kernel.org> Now if you really care about the use-case and want to work with the maintainers and implement signing for the community, here's how we think it should be done: * The core signing logic and the tooling stays in BPF, something that the users are already using. No new tooling. * The policy decision on the effect of signing can be built into various existing LSMs. I don't think we need a new LSM for it. * A simple UAPI (emphasis on UAPI!) change to union bpf_attr in uapi/bpf.h in the BPF_PROG_LOAD command: __aligned_u64 signature; __u32 signature_size;
On Fri, May 2, 2025 at 2:44 PM Blaise Boscaccy <bboscaccy@linux.microsoft.com> wrote: > > This adds the Hornet Linux Security Module which provides signature > verification of eBPF programs. This allows users to continue to > maintain an invariant that all code running inside of the kernel has > been signed. > > The primary target for signature verification is light-skeleton based > eBPF programs which was introduced here: > https://lore.kernel.org/bpf/20220209054315.73833-1-alexei.starovoitov@gmail.com/ > > eBPF programs, before loading, undergo a complex set of operations > which transform pseudo-values within the immediate operands of > instructions into concrete values based on the running > system. Typically, this is done by libbpf in > userspace. Light-skeletons were introduced in order to support > preloading of bpf programs and user-mode-drivers by removing the > dependency on libbpf and userspace-based operations. > > Userpace modifications, which may change every time a program gets > loaded or runs on a slightly different kernel, break known signature > verification algorithms. A method is needed for passing unadulterated > binary buffers into the kernel in-order to use existing signature > verification algorithms. Light-skeleton loaders with their support of > only in-kernel relocations fit that constraint. > > Hornet employs a signature verification scheme similar to that of > kernel modules. A signature is appended to the end of an > executable file. During an invocation of the BPF_PROG_LOAD subcommand, > a signature is extracted from the current task's executable file. That > signature is used to verify the integrity of the bpf instructions and > maps which were passed into the kernel. Additionally, Hornet > implicitly trusts any programs which were loaded from inside kernel > rather than userspace, which allows BPF_PRELOAD programs along with > outputs for BPF_SYSCALL programs to run. > > The validation check consists of checking a PKCS#7 formatted signature > against a data buffer containing the raw instructions of an eBPF > program, followed by the initial values of any maps used by the > program. Maps are verified to be frozen before signature verification > checking to stop TOCTOU attacks. > > Signed-off-by: Blaise Boscaccy <bboscaccy@linux.microsoft.com> > --- > Documentation/admin-guide/LSM/Hornet.rst | 65 ++++++ > Documentation/admin-guide/LSM/index.rst | 1 + > MAINTAINERS | 9 + > crypto/asymmetric_keys/pkcs7_verify.c | 10 + > include/linux/kernel_read_file.h | 1 + > include/linux/verification.h | 1 + > include/uapi/linux/lsm.h | 1 + > security/Kconfig | 3 +- > security/Makefile | 1 + > security/hornet/Kconfig | 24 +++ > security/hornet/Makefile | 4 + > security/hornet/hornet_lsm.c | 250 +++++++++++++++++++++++ > security/selinux/hooks.c | 12 +- > security/selinux/include/classmap.h | 2 +- > 14 files changed, 380 insertions(+), 4 deletions(-) > create mode 100644 Documentation/admin-guide/LSM/Hornet.rst > create mode 100644 security/hornet/Kconfig > create mode 100644 security/hornet/Makefile > create mode 100644 security/hornet/hornet_lsm.c ... > +Configuration Options > +===================== > + > +Hornet provides a kconfig knob > +CONFIG_SECURITY_HORNET_WHITELIST_PID_ONE. Enabling this will allow > +bpf programs to be loaded from pid 1 without undergoing a signature > +verification check. This option is not recommened for production > +systems. ... > +config SECURITY_HORNET_WHITELIST_PID_ONE > + bool "Whiltelist unsigned eBPF programs from PID 1" > + depends on SECURITY_HORNET > + default n > + help > + Selecting this will configure Hornet to allow eBPF loaded from pid 1 > + to load without a verification check. > + Further information can be found in > + Documentation/admin-guide/LSM/Hornet.rst. > + > + If you are unsure how to answer this question, answer N. ... > +static int hornet_bpf_prog_load(struct bpf_prog *prog, union bpf_attr *attr, > + struct bpf_token *token, bool is_kernel) > +{ > + if (is_kernel) > + return 0; > +#ifdef CONFIG_SECURITY_HORNET_WHITELIST_PID_ONE > + if (current->pid == 1) > + return 0; > +#endif Two quick comments on the build-time conditional above. First, unless there is some subtle reason why you only want the exception above to apply to a single thread in the init process, I would suggest using task_tgid_nr() instead of current->pid as I believe you want the init exception to apply to all threads running within the init process. Second, I think it would be helpful to rename the Kconfig knob to CONFIG_SECURITY_HORNET_PIDONE_TRANSITION, or similar, to help indicate that this is a transitional configuration option designed to make it easier for developers to move to a system with signed BPF programs without excessive warnings/errors from systemd in the beginning. I would highlight the transitory intent of this Kconfig knob both in the Kconfig description as well as the Hornet.rst doc, a brief explanation of the drawback for enabling this long term or on "production" systems in the Hornet.rst section would also be a good idea.
On Fri, May 2, 2025 at 5:00 PM KP Singh <kpsingh@kernel.org> wrote: > > > This patch series introduces the Hornet LSM. The goal of Hornet is to provide > > a signature verification mechanism for eBPF programs. > > > > [...] > > > > > References: [1] > > https://lore.kernel.org/bpf/20220209054315.73833-1-alexei.starovoitov@gmail.com/ > > [2] > > https://lore.kernel.org/bpf/CAADnVQ+wPK1KKZhCgb-Nnf0Xfjk8M1UpX5fnXC=cBzdEYbv_kg@mail.gmail.com/ > > > > Change list: - v2 -> v3 - Remove any and all usage of proprietary bpf APIs > > BPF APIs are not proprietary, but you cannot implement BPF program signing > for BPF users without aligning with the BPF maintainers and the community. > Signed programs are a UAPI and a key part of how developers experience BPF > and this is not how we would like signing to be experienced by BPF users. > > Some more feedback (which should be pretty obvious) but explicitly: > > * Hacks like if (current->pid == 1) return 0; also break your threat model > about root being untrusted. Speaking with Blaise off-list when that change was discussed, I believe the intent behind that Kconfig option was simply for development/transition purposes, and not for any long term usage. My understanding is that this is why it was a separate build time configuration and not something that could be toggled at runtime, e.g. sysctl or similar. > * You also did not take the feedback into account: > > new = map->ops->map_lookup_elem(map, &key); > > This is not okay without having the BPF maintainers aligned, the same way as > > https://patchwork.kernel.org/project/netdevbpf/patch/20240629084331.3807368-4-kpsingh@kernel.org/#25928981 > > was not okay. Let's not have double standards.
On Sun, May 4, 2025 at 7:36 PM Paul Moore <paul@paul-moore.com> wrote: > > On Fri, May 2, 2025 at 5:00 PM KP Singh <kpsingh@kernel.org> wrote: > > > > > This patch series introduces the Hornet LSM. The goal of Hornet is to provide > > > a signature verification mechanism for eBPF programs. > > > > > > > [...] > > > > > > > > References: [1] > > > https://lore.kernel.org/bpf/20220209054315.73833-1-alexei.starovoitov@gmail.com/ > > > [2] > > > https://lore.kernel.org/bpf/CAADnVQ+wPK1KKZhCgb-Nnf0Xfjk8M1UpX5fnXC=cBzdEYbv_kg@mail.gmail.com/ > > > > > > Change list: - v2 -> v3 - Remove any and all usage of proprietary bpf APIs > > > > BPF APIs are not proprietary, but you cannot implement BPF program signing > > for BPF users without aligning with the BPF maintainers and the community. > > Signed programs are a UAPI and a key part of how developers experience BPF > > and this is not how we would like signing to be experienced by BPF users. > > > > Some more feedback (which should be pretty obvious) but explicitly: > > > > * Hacks like if (current->pid == 1) return 0; also break your threat model > > about root being untrusted. > > Speaking with Blaise off-list when that change was discussed, I > believe the intent behind that Kconfig option was simply for > development/transition purposes, and not for any long term usage. My > understanding is that this is why it was a separate build time > configuration and not something that could be toggled at runtime, e.g. > sysctl or similar. > > > * You also did not take the feedback into account: > > > > new = map->ops->map_lookup_elem(map, &key); > > > > This is not okay without having the BPF maintainers aligned, the same way as [...] > > From what I've seen in Blaise's efforts to implement BPF signature > validation in the upstream kernel he has been working in good faith > and has been trying to work with the greater BPF community at each > step along the way. He attempted to learn from previously rejected > attempts with his first patchset, however, that too was rejected, but > with feedback on how he might proceed. Blaise took that feedback and > implemented Hornet, traveling to LSFMMBPF to present his idea to the > BPF community, as well as the usual mailing list postings. When there > was feedback that certain APIs would not be permitted, despite being > EXPORT_SYMBOL'd, Blaise made some adjustments and came back to the > lists with an updated version. You are obviously free to object to > portions of Hornet, but I don't believe you can claim Blaise isn't > trying to work with the BPF community on this effort. Calling map->ops->map_lookup_elem wax objected to by Alexei. This feedback was not incorporated. > > > So for this approach, it's a: > > > > Nacked-by: KP Singh <kpsingh@kernel.org> > > Noted. > > > Now if you really care about the use-case and want to work with the maintainers > > and implement signing for the community, here's how we think it should be done: > > > > * The core signing logic and the tooling stays in BPF, something that the users > > are already using. No new tooling. > > I think we need a more detailed explanation of this approach on-list. > There has been a lot of vague guidance on BPF signature validation > from the BPF community which I believe has partly led us into the > situation we are in now. If you are going to require yet another > approach, I think we all need to see a few paragraphs on-list > outlining the basic design. Definitely, happy to share design / code. - KP > > > * The policy decision on the effect of signing can be built into various > > existing LSMs. I don't think we need a new LSM for it. > > * A simple UAPI (emphasis on UAPI!) change to union bpf_attr in uapi/bpf.h in > > the BPF_PROG_LOAD command: > > > > __aligned_u64 signature; > > __u32 signature_size; > > -- > paul-moore.com
On 5/4/25 7:36 PM, Paul Moore wrote: > On Fri, May 2, 2025 at 5:00 PM KP Singh <kpsingh@kernel.org> wrote: [...] > From what I've seen in Blaise's efforts to implement BPF signature > validation in the upstream kernel he has been working in good faith > and has been trying to work with the greater BPF community at each > step along the way. He attempted to learn from previously rejected > attempts with his first patchset, however, that too was rejected, but > with feedback on how he might proceed. Blaise took that feedback and > implemented Hornet, traveling to LSFMMBPF to present his idea to the > BPF community, as well as the usual mailing list postings. When there > was feedback that certain APIs would not be permitted, despite being > EXPORT_SYMBOL'd, Blaise made some adjustments and came back to the > lists with an updated version. You are obviously free to object to > portions of Hornet, but I don't believe you can claim Blaise isn't > trying to work with the BPF community on this effort. We also discussed at LSFMMBPF that the current approach taken addresses only a tiny fraction of BPF programs out there, meaning it will not be applicable to 99% of projects utilizing BPF (e.g. for a OSS listing see https://ebpf.io/applications/). What guidance would you provide to these projects once this is set in place? "Please do a full rewrite (iff even feasible) or accept user space breakage if some distro sets this generally in place (wrongly assuming this provides a generic solution for all BPF)?" In the presentation it was mentioned that you need something like Hornet for your Azure Smart NICs in order to utilize BPF for livesite investigation which is fine ofc, but given this only addresses a *tiny niche* of use cases, the guidance given at the LSFMMBPF conference was to go via BPF LSM route and implement it this way instead which Blaise agreed to look into. Given this is a niche use case it is exactly the fit for BPF LSM. >> So for this approach, it's a: >> >> Nacked-by: KP Singh <kpsingh@kernel.org> > > Noted. Nacked-by: Daniel Borkmann <daniel@iogearbox.net>
On Sun, May 4, 2025 at 7:25 PM KP Singh <kpsingh@kernel.org> wrote: > On Sun, May 4, 2025 at 7:36 PM Paul Moore <paul@paul-moore.com> wrote: > > On Fri, May 2, 2025 at 5:00 PM KP Singh <kpsingh@kernel.org> wrote: ... > > > ... here's how we think it should be done: > > > > > > * The core signing logic and the tooling stays in BPF, something that the users > > > are already using. No new tooling. > > > > I think we need a more detailed explanation of this approach on-list. > > There has been a lot of vague guidance on BPF signature validation > > from the BPF community which I believe has partly led us into the > > situation we are in now. If you are going to require yet another > > approach, I think we all need to see a few paragraphs on-list > > outlining the basic design. > > Definitely, happy to share design / code. At this point I think a quick paragraph or two on how you believe the design should work would be a good start, I don't think code is necessary unless you happen to already have something written.
KP Singh <kpsingh@kernel.org> writes: [...] > Now if you really care about the use-case and want to work with the maintainers > and implement signing for the community, here's how we think it should be done: > > * The core signing logic and the tooling stays in BPF, something that the users > are already using. No new tooling. > * The policy decision on the effect of signing can be built into various > existing LSMs. I don't think we need a new LSM for it. > * A simple UAPI (emphasis on UAPI!) change to union bpf_attr in uapi/bpf.h in > the BPF_PROG_LOAD command: > > __aligned_u64 signature; > __u32 signature_size; I think having some actual details on the various parties' requirements here would be helpful. KP, I do look forward to seeing your design; however, having code signing proposals where the capabilities are dictated from above and any dissent is dismissed as "you're doing it wrong" isn't going to be helpful to anyone that needs to use this in practice. Also, I don't think anyone actually cares, at least I don't, who calls verify_pkcs7_signature or whatnot. Verifying signed binary blobs with a private key is a solved problem and isn't really interesting. Our requirements for code signing are just an extension of secure boot and module signing logic: * Prove all code running in ring zero has been signed * Not trivially defeatable by root * Ultimately, no trusted userspace components * Secure from and not vulnerable to TOCTOU attacks * Shouldn't be overly vulnerable to supply-chain attacks * The signature checking logic and control paths should be human-readable * Work easily and be backportable to stable kernels * There should be a simple kconfig option to turn this on or off * This solution needs to be in the mainline kernel Hornet was implemented to meet those requirements, living in the LSM subsystem, written in C. As of today, one cannot accomplish those requirements via BPF-LSM, which is why C was chosen. One can easily realize there is absolutely no way to have a single one-size-fits-all signing solution for everything listed in https://ebpf.io/applications/. If you want to go the UAPI route, I would wholeheartedly recommend making it extensible and having this data be available to the policy LSMs. enum bpf_signature_type { /* x509 signature check against program instructions only */ BPF_SIGNATURE_PROG_ONLY = 0, /* x509 combined signature check against program instructions and used maps */ BPF_SIGNATURE_PROG_USED_MAPS = 1, /* more of these to be determined via usage */ ... }; _aligned_u64 signature; __u32 signature_size; __u32 signature_type; The other option for solving this in the general is in-kernel loaders. That's gotten pushback as well. -blaise
On Mon, May 5, 2025 at 7:30 PM Blaise Boscaccy <bboscaccy@linux.microsoft.com> wrote: > > KP Singh <kpsingh@kernel.org> writes: > > [...] > > > Now if you really care about the use-case and want to work with the maintainers > > and implement signing for the community, here's how we think it should be done: > > > > * The core signing logic and the tooling stays in BPF, something that the users > > are already using. No new tooling. > > * The policy decision on the effect of signing can be built into various > > existing LSMs. I don't think we need a new LSM for it. > > * A simple UAPI (emphasis on UAPI!) change to union bpf_attr in uapi/bpf.h in > > the BPF_PROG_LOAD command: > > > > __aligned_u64 signature; > > __u32 signature_size; > > I think having some actual details on the various parties' requirements > here would be helpful. KP, I do look forward to seeing your design; > however, having code signing proposals where the capabilities are > dictated from above and any dissent is dismissed as "you're doing it > wrong" isn't going to be helpful to anyone that needs to use this in > practice. Please don't misrepresent the facts, you got feedback from Alexei in various threads, but you chose to argue on the points that were convenient for you (i.e. usage of BPF internal APIs) and yet you claim to "work with the BPF community and maintainers" by arguing instead of collaborating and paying attention to the feedback given to you. 1. https://lore.kernel.org/bpf/CAADnVQKF+B_YYwOCFsPBbrTBGKe4b22WVJFb8C0PHGmRAjbusQ@mail.gmail.com/ Your solution to address the ELF loader specific issue was to just allow list systemd? You totally ignored the part about loaders in golang and Rust that do not use ELF. How is this "directive from above?" 2. Alexei suggested to you in https://lore.kernel.org/bpf/87plhhjwqy.fsf@microsoft.com/ "A signature for the map plus a signature for the prog that is tied to a map might be a better option. At map creation time the contents can be checked, the map is frozen, and then the verifier can proceed with prog's signature checking." You never replied to this. 3. To signing the attachment points, you replied > That statement is quite questionable. Yes, IIRC you brought that up. And > again, runtime policy enforcement has nothing to do with proving code > provenance. They are completely independent concerns. The place where the BPF program is attached is a key part of the provenance of the BPF program and its security (and other) effects can vary greatly based on that. (e.g. imagine a reject all LSM program that is attached to the wrong LSM hook). This is why it's not the same as module loading. 4. https://lore.kernel.org/bpf/CAADnVQKF+B_YYwOCFsPBbrTBGKe4b22WVJFb8C0PHGmRAjbusQ@mail.gmail.com/ Programs can still access maps, now if you combine the issue of ELF-less loaders and that maps are writeable from other programs as freezing only affects userspace (i.e. when a binary gets an FD to a map and tries to modify it with syscalls) your implementation fails. The reply there about trusted user-space still needs to come with better guarantees from the kernel, and the kernel can indeed give better guarantees, which we will share. The reason for this is that your trusted binary is not immune to attacks, and once an attacker gains code execution as this trusted binary, there is no containing the compromise. - KP > > Also, I don't think anyone actually cares, at least I don't, who calls > verify_pkcs7_signature or whatnot. Verifying signed binary blobs with a > private key is a solved problem and isn't really interesting. > > Our requirements for code signing are just an extension of secure boot > and module signing logic: > > * Prove all code running in ring zero has been signed > * Not trivially defeatable by root > * Ultimately, no trusted userspace components > * Secure from and not vulnerable to TOCTOU attacks > * Shouldn't be overly vulnerable to supply-chain attacks > * The signature checking logic and control paths should be human-readable > * Work easily and be backportable to stable kernels > * There should be a simple kconfig option to turn this on or off > * This solution needs to be in the mainline kernel > > Hornet was implemented to meet those requirements, living in the LSM > subsystem, written in C. As of today, one cannot accomplish those > requirements via BPF-LSM, which is why C was chosen. > > One can easily realize there is absolutely no way to have a single > one-size-fits-all signing solution for everything listed in > https://ebpf.io/applications/. > > If you want to go the UAPI route, I would wholeheartedly recommend > making it extensible and having this data be available to the policy > LSMs. > > enum bpf_signature_type { > /* x509 signature check against program instructions only */ > BPF_SIGNATURE_PROG_ONLY = 0, > /* x509 combined signature check against program instructions and used maps */ > BPF_SIGNATURE_PROG_USED_MAPS = 1, > /* more of these to be determined via usage */ > ... > }; > > _aligned_u64 signature; > __u32 signature_size; > __u32 signature_type; > > The other option for solving this in the general is in-kernel > loaders. That's gotten pushback as well. > > -blaise > > > > >
On Mon, May 5, 2025 at 4:41 PM KP Singh <kpsingh@kernel.org> wrote: > On Mon, May 5, 2025 at 7:30 PM Blaise Boscaccy > <bboscaccy@linux.microsoft.com> wrote: > > > > KP Singh <kpsingh@kernel.org> writes: > > > > [...] > > > > > Now if you really care about the use-case and want to work with the maintainers > > > and implement signing for the community, here's how we think it should be done: > > > > > > * The core signing logic and the tooling stays in BPF, something that the users > > > are already using. No new tooling. > > > * The policy decision on the effect of signing can be built into various > > > existing LSMs. I don't think we need a new LSM for it. > > > * A simple UAPI (emphasis on UAPI!) change to union bpf_attr in uapi/bpf.h in > > > the BPF_PROG_LOAD command: > > > > > > __aligned_u64 signature; > > > __u32 signature_size; > > > > I think having some actual details on the various parties' requirements > > here would be helpful. KP, I do look forward to seeing your design; > > however, having code signing proposals where the capabilities are > > dictated from above and any dissent is dismissed as "you're doing it > > wrong" isn't going to be helpful to anyone that needs to use this in > > practice. > > Please don't misrepresent the facts ... KP, I believe the most constructive thing at this point is to share your design idea with this thread as previously requested so everyone can review it. We can continue to argue about how we got to where we are at if you like, but that isn't likely to help us move towards a solution. If you are unable to share your design idea, either in a couple of paragraphs or in some form of PoC, please let us know.
On Mon, 2025-05-05 at 22:41 +0200, KP Singh wrote: > On Mon, May 5, 2025 at 7:30 PM Blaise Boscaccy > <bboscaccy@linux.microsoft.com> wrote: > > > > KP Singh <kpsingh@kernel.org> writes: > > > > [...] > > > > > Now if you really care about the use-case and want to work with > > > the maintainers and implement signing for the community, here's > > > how we think it should be done: > > > > > > * The core signing logic and the tooling stays in BPF, something > > > that the users are already using. No new tooling. > > > * The policy decision on the effect of signing can be built into > > > various existing LSMs. I don't think we need a new LSM for it. > > > * A simple UAPI (emphasis on UAPI!) change to union bpf_attr in > > > uapi/bpf.h in the BPF_PROG_LOAD command: > > > > > > __aligned_u64 signature; > > > __u32 signature_size; > > > > I think having some actual details on the various parties' > > requirements here would be helpful. KP, I do look forward to seeing > > your design; however, having code signing proposals where the > > capabilities are dictated from above and any dissent is dismissed > > as "you're doing it wrong" isn't going to be helpful to anyone that > > needs to use this in practice. > > Please don't misrepresent the facts, you got feedback from Alexei in > various threads, but you chose to argue on the points that were > convenient for you (i.e. usage of BPF internal APIs) and yet you > claim to "work with the BPF community and maintainers" by arguing > instead of collaborating and paying attention to the feedback given > to you. I'm with Paul on this: if you could share your design ideas more fully than you have above that would help make this debate way more technical. However, I will try to respond to the other technical points from a general security point of view if it helps but I've made some guesses about what will work for you. [...] > 2. Alexei suggested to you in > https://lore.kernel.org/bpf/87plhhjwqy.fsf@microsoft.com/ > > "A signature for the map plus a signature for the prog > that is tied to a map might be a better option. > At map creation time the contents can be checked, > the map is frozen, and then the verifier can proceed > with prog's signature checking." > > You never replied to this.
On Wed, May 7, 2025 at 1:48 PM James Bottomley <James.Bottomley@hansenpartnership.com> wrote: > > I'm with Paul on this: if you could share your design ideas more fully > than you have above that would help make this debate way more > technical. I think it would also help some of us, at the very least me, put your objections into context. I believe the more durable solutions that end up in Linus' tree are combinations of designs created out of compromise, and right now we are missing the context and detail of your ideal solution to be able to do that compromise and get to a design and implementation we can all begrudgingly accept. In the absence of a detailed alternate design, and considering that BPF signature validation efforts have sputtered along for years without any real success, we'll continue to push forward on-list with refinements to the current proposal in an effort to drive this to some form of resolution. > I also get the impression that there might be a disagreement over > scope: what seems to be coming out of BPF is that every signing problem > and scenario must be solved before signing can be considered > acceptable; however, I think it's not unreasonable to attempt to cover > a portion of the use cases and allow for future additions of things > like policy so we can get some forward motion to allow others to play > with it and produce patches based on their use cases. Beyond any potential future updates to Hornet, I just wanted to make it clear that the Hornet LSM approach, like any LSM, can be disabled both at compile time for those users who build their own kernels, as well as at kernel boot time using the "lsm=" command line option for those who are limited to pre-built kernels, e.g. distro kernels. Users can always disable Hornet and replace it with another LSM, either a BPF LSM or a native/C LSM, of their choosing; the LSM framework is intentionally flexible to allow for this substitution and replacement, with plenty of existing examples already.
On Wed, May 7, 2025 at 4:24 PM Paul Moore <paul@paul-moore.com> wrote: > > On Wed, May 7, 2025 at 1:48 PM James Bottomley > <James.Bottomley@hansenpartnership.com> wrote: > > > > I'm with Paul on this: if you could share your design ideas more fully > > than you have above that would help make this debate way more > > technical. > > I think it would also help some of us, at the very least me, put your > objections into context. I believe the more durable solutions that > end up in Linus' tree are combinations of designs created out of > compromise, and right now we are missing the context and detail of > your ideal solution to be able to do that compromise and get to a > design and implementation we can all begrudgingly accept. In the > absence of a detailed alternate design, and considering that BPF > signature validation efforts have sputtered along for years without > any real success, we'll continue to push forward on-list with > refinements to the current proposal in an effort to drive this to some > form of resolution. It sounds like you're asking for Linus's opinion. This 'hornet' LSM attempts to implement signed bpf programs by hacking into bpf internals: https://lore.kernel.org/bpf/20250502184421.1424368-2-bboscaccy@linux.microsoft.com/ It got 3 Nacks from bpf maintainers. Let me recap our objections: 1. Your definition of attack surface says that root is untrusted. Yet this "hornet" LSM allowlists systemd as trusted. Allegedly, it's an intermediate solution. What it really means that as presented the security is broken, since an untrusted root can poke into systemd and make it load whatever bpf programs it wants. 2. you propose to mangle every binary in the system that needs to load bpf programs with an extra "signature" at the end of the binary that breaks ELF format. I already explained earlier that such an approach was a border line acceptable solution for kernel modules, but certainly not ok as a general approach for all binaries. The kernel modules are consumed by the kernel and user space doesn't touch them. It's not ok to mangle general purpose binaries. The user space tooling relies on well formed ELF files. 'perf record' and any profiling tool will parse various ELF binaries to symbolize addresses. If ELF is corrupted such tools may crash. So far you've been lucky that ld-linux.so was able to interpret such corrupted ELF. It's not something to rely on. 3. To read this mangled ELF you do: file = get_task_exe_file(current); buf_sz = kernel_read_file(file, 0, &buf, INT_MAX, &sz, READING_EBPF); A malicious user can give you a multi gigabyte file and your LSM will happily read it into the kernel memory. It's an obvious DoS vector. 4. I said multiple times it's not ok to do bpf_map->ops->map_lookup_elem() outside of the bpf subsystem. You did 'git grep' and argued that something in the net/ directory is doing that. Well, ./scripts/get_maintainer.pl `git grep -l -- '->map_lookup_elem' net/` is your answer. net/core/filter.c is a part of the bpf subsystem. The bpf originated in networking. Also, do build 'hornet' LSM with LOCKDEP and see how many bpf map lifetime rules you violated with that map_lookup_elem() call. 5. I also explained that map->frozen == true doesn't guarantee that the map is immutable. It only freezes the map from user space writes. You argued that when all bpf programs are signed then the non-signed attacker cannot mangle the map. That's broken for two reasons: - you allow systemd to load bpf without signatures - even when all bpf progs are signed, the program actions are not controlled after loading, so signed bpf prog that uses map-in-map is subject to an attack where a malicious root can add loader-map as inner map-in-map and an unsuspecting program will mangle it. 6. Though bpf instructions have standardized format LSMs shouldn't not be in the business of parsing them. New instructions are being added. We don't need a headache that an LSM will start crashing/misbehaving when a new instruction is added or extended. bpf instruction parsing belongs in the bpf subsystem. 7. You do: copy_from_bpfptr_offset(&map_fd, ...) then proceed with content extraction, but this is a user controlled address. It's an obvious TOCTOU bug. The user can replace that map_fd after your LSM read it and before bpf verifier reads it. So the signature checking from LSM is fundamentally broken. I already explained that the signature check has to be done within a bpf subsystem. In the last kernel release we added 'bool kernel' parameter to security_bpf_prog_load() LSM hook assuming that you're going to work with us on actual solution for signed bpf programs, but so far you ignored our feedback and accused us of artificially delaying a solution to signed programs, though we told you that the "light skeleton" (that you incorrectly attempt to use here) was designed specifically as a building block towards signed bpf programs: See the cover letter from 2021: https://lore.kernel.org/bpf/20210514003623.28033-1-alexei.starovoitov@gmail.com/ " This is a first step towards signed bpf programs and the third approach of that kind. ... Future steps: - support CO-RE in the kernel - generate light skeleton for kernel - finally do the signing of the loader program " Later in 2022-23 we implemented "CORE in the kernel" and "light skel for kernel" steps. There are a few more steps to do that we didn't anticipate back in 2021. Like the exclusive map <-> prog relationship and error propagation through the loading process. When Blaise volunteered to work on signed progs we pointed him to light skeleton assuming that you're going to work with us to finish this complex task. Instead you went with this broken LSM and now argue that your insecure approach somehow should be accepted by upstream and microsoft users. Sorry, but users deserve better than this. The only path forward here is to: - stop pushing broken code - internalize the feedback - work with the bpf community The problem is difficult and a truly secure solution will take time. You cannot short circuit this path.
On Thu, May 8, 2025 at 1:45 PM Alexei Starovoitov <alexei.starovoitov@gmail.com> wrote: > On Wed, May 7, 2025 at 4:24 PM Paul Moore <paul@paul-moore.com> wrote: > > On Wed, May 7, 2025 at 1:48 PM James Bottomley > > <James.Bottomley@hansenpartnership.com> wrote: > > > > > > I'm with Paul on this: if you could share your design ideas more fully > > > than you have above that would help make this debate way more > > > technical. > > > > I think it would also help some of us, at the very least me, put your > > objections into context. I believe the more durable solutions that > > end up in Linus' tree are combinations of designs created out of > > compromise, and right now we are missing the context and detail of > > your ideal solution to be able to do that compromise and get to a > > design and implementation we can all begrudgingly accept. In the > > absence of a detailed alternate design, and considering that BPF > > signature validation efforts have sputtered along for years without > > any real success, we'll continue to push forward on-list with > > refinements to the current proposal in an effort to drive this to some > > form of resolution. > > It sounds like you're asking for Linus's opinion. At this point no, although of course he is welcome to comment if he likes. What we've been asking for is some detail on your preferred solution; all we've seen on the various threads thus far has been a small number of short sentences that leave far too much ambiguity around important parts of the design. Without any clear direction on your ideal solution, Blaise has been continuing forward with proposals that we believe solve at least one use case and can be extended in the future to support others. Blaise started this most recent effort by attempting to address the concerns brought up in previous efforts, you and others rejected this first attempt and directed Blaise towards a light skeleton and LSM based approach, which is where he is at with Hornet. Once again, you reject this approach with minimal guidance on what would be acceptable, and our response is to ask for clarification on your preferred design. We're not asking for a full working solution, simply a couple of paragraphs outlining the design with enough detail to put forward a working solution that isn't immediately NACK'd. We've made this request multiple times in the past, most recently this past weekend, where KP replied that he would be "happy" to share designs/code. Unfortunately, since then all we've received from either you or KP since then has been effectively just a list of your objections on repeat; surely typing out a couple of paragraphs outlining a design would have been quicker, easier, and more constructive then your latest reply? > This 'hornet' LSM attempts to implement signed bpf programs by > hacking into bpf internals: > https://lore.kernel.org/bpf/20250502184421.1424368-2-bboscaccy@linux.microsoft.com/ I guess there are always two sides to every story, but "hacking into bpf internals" is not how I would characterize the Hornet approach. Hornet reads the light skeleton BPF loader and the associated BPF maps (the original BPF program) passed in from userspace into a buffer in order to verify a signature across the two BPF programs (loader + original). Hornet does this to verify the provenance and load time integrity of BPF programs, two very basic security goals that people have wanted for BPF programs for years, Blaise is simply the most recent person to try and get something into Linus' tree. > It got 3 Nacks from bpf maintainers. > Let me recap our objections: > > 1. Your definition of attack surface says that root is untrusted. > Yet this "hornet" LSM allowlists systemd as trusted. Allegedly, > it's an intermediate solution ... The Hornet proposal is not the first thing to implement a transition mechanism, but if that is really the blocker you want to go with I'm sure Blaise would be happy to back out the change. My understanding is that it is really about reducing warnings from systemd and nothing more. > 2. you propose to mangle every binary in the system that needs to load > bpf programs with an extra "signature" at the end of the binary that > breaks ELF format. I already explained earlier that such an approach > was a border line acceptable solution for kernel modules, but > certainly not ok as a general approach for all binaries. Let's just ignore the "borderline" comment on kernel module signing; the fact is that kernel module signing has been an accepted part of the upstream Linux kernel for years now, which is part of why Blaise used that as a starting point for the Hornet approach: keep things simple and build on something that works. This is especially important as we are still largely guessing about the details of your ideal solution. Based on some of the vague feedback from you and KP, this week Blaise has been experimenting with passing a signature via the bpf_attr struct, but until you provide more detail on-list it is still a guessing game as to what you might accept. The kmod inspired signature-on-ELF approach has the advantage of being much more self-contained, which is the reason we saw it as a good starting point that could be augmented with additional schemes in the future if/when needed. > 3. To read this mangled ELF you do: > file = get_task_exe_file(current); > buf_sz = kernel_read_file(file, 0, &buf, INT_MAX, &sz, READING_EBPF); > A malicious user can give you a multi gigabyte file and your LSM will > happily read it into the kernel memory. It's an obvious DoS vector. The LSM hook used by Hornet happens well after all of the BPF based capability and access control checks. If anything, the ability of a malicious user to tamper with the BPF program being loaded helps highlight the importance of validating signatures on BPF programs. In the worst case, if the kernel can't allocate a buffer the kernel_read_file() will fail and an error will be returned to userspace. > 4. I said multiple times it's not ok to do > bpf_map->ops->map_lookup_elem() outside of the bpf subsystem. > You did 'git grep' and argued that something in the net/ directory > is doing that. Well, > ./scripts/get_maintainer.pl `git grep -l -- '->map_lookup_elem' net/` > is your answer. net/core/filter.c is a part of the bpf subsystem. > The bpf originated in networking. Yet BPF was extracted out as a standalone mechanism that has grown well beyond its initial use as a socket data filter. From my perspective either BPF is a standalone entity and the map_lookup_elem() API is necessary for at least one current user, the socket fitler, or map_lookup_elem() isn't an API in which case BPF isn't the general purpose tool that everyone claims. This touches on another issue that I've brought up before in this thread which is important. The LSM subsystem doesn't care about how the LSM is implemented; C, BPF, and Rust (work is obviously still very early on the Rust side) are all valid implementation languages, and we make it clear that if you can do something in one language, you should be able to do it another. While I don't believe you or KP have explicitly stated that your objection to the Hornet approach is largely due to it being written in C, Daniel did make a comment that Hornet should be written as a BPF LSM. From the perspective of the LSM, something is either "legal" to do in a LSM, or it isn't; we don't qualify that determination based on the source language of the implementation. > Also, do build 'hornet' LSM with LOCKDEP and see how many bpf map > lifetime rules you violated with that map_lookup_elem() call. I'm sure Blaise will look into that. I'm sure that if you, KP, Daniel, or anyone else in BPF land wanted to provide an alternate API for map access I'm sure Blaise would be happy to rework his code. As we've stated multiple times, don't just say "no" say "no" with a good description about how to move forward. > 5. I also explained that map->frozen == true doesn't guarantee that > the map is immutable. It only freezes the map from user space writes. For this initial use case, we believe that is sufficient and is inline with kernel module loading, which is a good analogy. The most critical part as far as we are concerned is that userspace can not tamper with the BPF map once the signature has been verified. Yes, another in-kernel component might be able to tamper with the BPF map, but in-kernel components can do a number of bad things; this is yet one more reason why validating code that executes in kernel context is important. > 6. Though bpf instructions have standardized format LSMs shouldn't not > be in the business of parsing them. New instructions are being added. > We don't need a headache that an LSM will start crashing/misbehaving > when a new instruction is added or extended. > bpf instruction parsing belongs in the bpf subsystem. The current Hornet implementation ignores things it doesn't know about, sticking to parts of the BPF instruction set that is currently defined. Who knows what Hornet might look like in another few revisions, or if it is replaced with another approach, but if it becomes part of Linus' tree it should be trivial to update it along with BPF. There is precedence for this with other LSMs and other kernel subsystems. > 7. You do: copy_from_bpfptr_offset(&map_fd, ...) then proceed with > content extraction, but this is a user controlled address. It's an > obvious TOCTOU bug. The user can replace that map_fd after your LSM > read it and before bpf verifier reads it. So the signature checking > from LSM is fundamentally broken. I already explained that the > signature check has to be done within a bpf subsystem. As mentioned *many* times before, please provide more information on this. To start, where *exactly* in the BPF subsystem would you accept a signature check. > In the last kernel release we added 'bool kernel' parameter to > security_bpf_prog_load() LSM hook assuming that you're going to work > with us on actual solution for signed bpf programs, but so far you > ignored our feedback and accused us of artificially delaying a > solution to signed programs, though we told you that the "light > skeleton" (that you incorrectly attempt to use here) was designed > specifically as a building block towards signed bpf programs: > > See the cover letter from 2021: > https://lore.kernel.org/bpf/20210514003623.28033-1-alexei.starovoitov@gmail.com/ ... > When Blaise volunteered to work on signed progs we pointed him to > light skeleton assuming that you're going to work with us to finish > this complex task. In order to work effectively we need a more detailed explanation of what you want to see with respect to BPF signing. Thus far we've only seen rejections with very hand-wavy explanations on how to proceed. KP indicated almost a week ago that he is happy to share a couple of paragraphs on a preferred BPF signing approach, but we're still left waiting with the only feedback being a repeat of previous rejections and more vitrol.
> > I think we need a more detailed explanation of this approach on-list. > > There has been a lot of vague guidance on BPF signature validation > > from the BPF community which I believe has partly led us into the > > situation we are in now. If you are going to require yet another > > approach, I think we all need to see a few paragraphs on-list > > outlining the basic design. > > Definitely, happy to share design / code. Here’s the design that Alexei and I have been discussing. It's extensible, independent of ELF formats, handles all identified use-cases, paves the way for signed unprivileged eBPF, and meets the requirements of anyone who wants to run signed eBPF programs. # Trusted Hash Chain The key idea of the design is to use a signing algorithm that allows us to integrity-protect a number of future payloads, including their order, by creating a chain of trust. Consider that Alice needs to send messages M_1, M_2, ..., M_n to Bob. We define blocks of data such that: B_n = M_n || H(termination_marker) (Each block contains its corresponding message and the hash of the *next* block in the chain.) B_{n-1} = M_{n-1} || H(B_n) B_{n-2} = M_{n-2} || H(B_{n-1}) ... B_2 = M_2 || H(B_3) B_1 = M_1 || H(B_2) Alice does the following (e.g., on a build system where all payloads are available): * Assembles the blocks B_1, B_2, ..., B_n. * Calculates H(B_1) and signs it, yielding Sig(H(B_1)). Alice sends the following to Bob: M_1, H(B_2), Sig(H(B_1)) Bob receives this payload and does the following: * Reconstructs B_1 as B_1' using the received M_1 and H(B_2) (i.e., B_1' = M_1 || H(B_2)). * Recomputes H(B_1') and verifies the signature against the received Sig(H(B_1)). * If the signature verifies, it establishes the integrity of M_1 and H(B_2) (and transitively, the integrity of the entire chain). Bob now stores the verified H(B_2) until it receives the next message. * When Bob receives M_2 (and H(B_3) if n > 2), it reconstructs B_2' (e.g., B_2' = M_2 || H(B_3), or if n=2, B_2' = M_2 || H(termination_marker)). Bob then computes H(B_2') and compares it against the stored H(B_2) that was verified in the previous step. This process continues until the last block is received and verified. Now, applying this to the BPF signing use-case, we simplify to two messages: M_1 = I_loader (the instructions of the loader program) M_2 = M_metadata (the metadata for the loader program, passed in a map, which includes the programs to be loaded and other context) For this specific BPF case, we will directly sign a composite of the first message and the hash of the second. Let H_meta = H(M_metadata). The block to be signed is effectively: B_signed = I_loader || H_meta The signature generated is Sig(B_signed). The process then follows a similar pattern to the Alice and Bob model, where the kernel (Bob) verifies I_loader and H_meta using the signature. Then, the trusted I_loader is responsible for verifying M_metadata against the trusted H_meta.
On Wed, May 14, 2025 at 5:39 PM James Bottomley <James.Bottomley@hansenpartnership.com> wrote: > > On Sun, 2025-05-11 at 04:01 +0200, KP Singh wrote: > [...] > > > > > For this specific BPF case, we will directly sign a composite of the > > first message and the hash of the second. Let H_meta = H(M_metadata). > > The block to be signed is effectively: > > > > B_signed = I_loader || H_meta > > > > The signature generated is Sig(B_signed). > > > > The process then follows a similar pattern to the Alice and Bob > > model, > > where the kernel (Bob) verifies I_loader and H_meta using the > > signature. Then, the trusted I_loader is responsible for verifying > > M_metadata against the trusted H_meta. > > > > From an implementation standpoint: > > > > # Build > > > > bpftool (or some other tool in the user's build environment) knows > > about the metadata (M_metadata) and the loader program (I_loader). It > > first calculates H_meta = H(M_metadata). Then it constructs the > > object > > to be signed and computes the signature: > > > > Sig(I_loader || H_meta) > > > > # Loader > > > > bpftool generates the loader program. The initial instructions of > > this loader program are designed to verify the SHA256 hash of the > > metadata (M_metadata) that will be passed in a map. These > > instructions effectively embed the precomputed H_meta as immediate > > values. > > > > ld_imm64 r1, const_ptr_to_map // insn[0].src_reg == > > BPF_PSEUDO_MAP_IDX > > r2 = *(u64 *)(r1 + 0); > > ld_imm64 r3, sha256_of_map_part1 // constant precomputed by > > bpftool (part of H_meta) > > if r2 != r3 goto out; > > > > r2 = *(u64 *)(r1 + 8); > > ld_imm64 r3, sha256_of_map_part2 // (part of H_meta) > > if r2 != r3 goto out; > > > > r2 = *(u64 *)(r1 + 16); > > ld_imm64 r3, sha256_of_map_part3 // (part of H_meta) > > if r2 != r3 goto out; > > > > r2 = *(u64 *)(r1 + 24); > > ld_imm64 r3, sha256_of_map_part4 // (part of H_meta) > > if r2 != r3 goto out; > > ... > > > > This implicitly makes the payload equivalent to the signed block > > (B_signed) > > > > I_loader || H_meta > > > > bpftool then generates the signature of this I_loader payload (which > > now contains the expected H_meta) using a key (system or user) with > > new flags that work in combination with bpftool -L > > Could I just push back a bit on this. The theory of hash chains (which > I've cut to shorten) is about pure data structures. The reason for > that is that the entire hash chain is supposed to be easily > independently verifiable in any environment because anything can > compute the hashes of the blocks and links. This independent > verification of the chain is key to formally proving hash chains to be > correct. In your proposal we lose the easy verifiability because the > link hash is embedded in the ebpf loader program which has to be > disassembled to do the extraction of the hash and verify the loader is > actually checking it. I am not sure I understand your concern. This is something that can easily be built into tooling / annotations. bpftool -S -v <verification_key> <loader> <metadata> Could you explain what's the use-case for "easy verifiability". > > I was looking at ways we could use a pure hash chain (i.e. signature > over loader and real map hash) and it does strike me that the above > ebpf hash verification code is pretty invariant and easy to construct, > so it could run as a separate BPF fragment that then jumps to the real > loader. In that case, it could be constructed on the fly in a trusted > environment, like the kernel, from the link hash in the signature and > the signature could just be Sig(loader || map hash) which can then be The design I proposed does the same thing: Sig(loader || H_metadata) metadata is actually the data (programs, context etc) that's passed in the map. The verification just happens in the loader program and the loader || H_metadata is implemented elegantly to avoid any separate payloads. > easily verified without having to disassemble ebpf code. So we get the > formal provability benefits of using a real hash chain while still > keeping your verification in BPF. > > Regards, > > James > >
On Wed, May 14, 2025 at 8:35 PM KP Singh <kpsingh@kernel.org> wrote: > > On Wed, May 14, 2025 at 7:45 PM James Bottomley > <James.Bottomley@hansenpartnership.com> wrote: > > > > On Wed, 2025-05-14 at 19:17 +0200, KP Singh wrote: > > > On Wed, May 14, 2025 at 5:39 PM James Bottomley > > > <James.Bottomley@hansenpartnership.com> wrote: > > > > On Sun, 2025-05-11 at 04:01 +0200, KP Singh wrote: > > [...] > > > > > This implicitly makes the payload equivalent to the signed block > > > > > (B_signed) > > > > > > > > > > I_loader || H_meta > > > > > > > > > > bpftool then generates the signature of this I_loader payload > > > > > (which now contains the expected H_meta) using a key (system or > > > > > user) with new flags that work in combination with bpftool -L > > > > > > > > Could I just push back a bit on this. The theory of hash chains > > > > (which I've cut to shorten) is about pure data structures. The > > > > reason for that is that the entire hash chain is supposed to be > > > > easily independently verifiable in any environment because anything > > > > can compute the hashes of the blocks and links. This independent > > > > verification of the chain is key to formally proving hash chains to > > > > be correct. In your proposal we lose the easy verifiability > > > > because the link hash is embedded in the ebpf loader program which > > > > has to be disassembled to do the extraction of the hash and verify > > > > the loader is actually checking it. > > > > > > I am not sure I understand your concern. This is something that can > > > easily be built into tooling / annotations. > > > > > > bpftool -S -v <verification_key> <loader> <metadata> > > > > > > Could you explain what's the use-case for "easy verifiability". > > > > I mean verifiability of the hash chain link. Given a signed program, > > (i.e. a .h file which is generated by bpftool) which is a signature > > over the loader only how would one use simple cryptographic operations > > to verify it? > > > > I literally just said it above the hash can be extracted if you really > want offline verification. Are you saying this code is hard to write? > or is the tooling hard to write? Do you have some definition of > "simple cryptographic operations". All operations use tooling. > > > > > > > > > > I was looking at ways we could use a pure hash chain (i.e. > > > > signature over loader and real map hash) and it does strike me that > > > > the above ebpf hash verification code is pretty invariant and easy > > > > to construct, so it could run as a separate BPF fragment that then > > > > jumps to the real loader. In that case, it could be constructed on > > > > the fly in a trusted environment, like the kernel, from the link > > > > hash in the signature and the signature could just be Sig(loader || > > > > map hash) which can then be > > > > > > The design I proposed does the same thing: > > > > > > Sig(loader || H_metadata) > > > > > > metadata is actually the data (programs, context etc) that's passed > > > in the map. The verification just happens in the loader program and > > > the loader || H_metadata is implemented elegantly to avoid any > > > separate payloads. > > > > OK, so I think this is the crux of the problem: In formal methods > > proving the validity of a data based hash link is an easy set of > > cryptographic operations. You can assert that's equivalent to a > > signature over a program that verifies the hash, but formally proving > > it requires a formal analysis of the program to show that 1) it > > contains the correct hash and 2) it correctly checks the hash against > > the map. That makes the task of someone receiving the .h file > > containing the signed skeleton way harder: it's easy to prove the > > signature matches the loader instructions, but they still have to prove > > the instructions contain and verify the correct map hash. > > > > I don't see this as a problem for 2 reasons: > > 1. It's not hard > 2. Your typical user does not want to do formal verification and > extract signatures etc. > > [1] alone is enough. > > The key user journey is: > > * Build the program and the metadata > * Sign the blob once (as explained) > * A simple API to verify the sequence of operations. > > The user builds a program and signs the blob, they sign it because it > contains the hash of the metadata. It seems like you are optimizing > for the formal researcher but not for the tooling. The user just needs I meant not for the user. > good tooling and a simple API which is exactly what was proposed. > > - KP > > > Regards, > > > > James > > > >
On Wed, May 14, 2025 at 5:06 AM Paul Moore <paul@paul-moore.com> wrote: > > On Sat, May 10, 2025 at 10:01 PM KP Singh <kpsingh@kernel.org> wrote: > > > > ... > > > The signature check in the verifier (during BPF_PROG_LOAD): > > > > verify_pkcs7_signature(prog->aux->sha, sizeof(prog->aux->sha), > > sig_from_bpf_attr, …); > > I think we still need to clarify the authorization aspect of your > proposed design. > > Working under the assumption that the core BPF kernel code doesn't > want to enforce any restrictions, or at least as few as possible, I'm The assumption is not true, I should have clarified it in the original design. With the UAPI / bpf_attr the bpf syscall is simply denied if the signature does not verify, so we don't need any LSM logic for this. There is really no point in continuing as signature verification is a part of the API contract when the user passes the sig, keyring in the bpf syscall. Also, since we have a solid grasp on the design and its implementation being contained, it will be much simpler for us to actually implement the patches. We will keep you posted. - KP > expecting that the BPF kernel code would want to adopt an "allow all" > policy when it comes to authorizing signed and unsigned BPF programs, > delegating any additional restrictions to the LSM. With that in mind > I think we need to agree on a way for the BPF verifier to indicate > that it has verified the signature is correct to the LSM, and we need > a new LSM hook which runs *after* the verifier so that it can inspect > the results of the signature verification. While it might be tempting > to relocate the existing security_bpf_prog_load() hook, I believe it > makes sense to leave that hook before the verifier for those LSMs that > wish control access prior to the verifier's inspection using criteria > other than signatures. > > With respect to the LSM hook, since it appears that the signature is > going to be included in the bpf_attr struct, and I'm *guessing* the > best way for the verifier to indicate the result of the signature > verification is via a field inside bpf_prog_aux, this means the hook > could look something like this: > > int security_bpf_prog_verified(bpf_prog, bpf_attr); > > ... and be called immediately after bpf_check() in bpf_prog_load(). > As far as the new field in bpf_prog_aux is concerned, I think we can > probably start off with a simple bool to indicate whether a signature > was verified or not, with an understanding that we can move to a > richer construct in the future if we find it necessary. Neither of > these are directly visible to userspace so we have the ability to > start simple and modify as needed. > > Does this sound reasonable to everyone? Does anyone have any other > thoughts on the authorization aspect of BPF signature verification? > > -- > paul-moore.com
On Wed, 2025-05-14 at 20:35 +0200, KP Singh wrote: > On Wed, May 14, 2025 at 7:45 PM James Bottomley > <James.Bottomley@hansenpartnership.com> wrote: > > > > On Wed, 2025-05-14 at 19:17 +0200, KP Singh wrote: > > > On Wed, May 14, 2025 at 5:39 PM James Bottomley > > > <James.Bottomley@hansenpartnership.com> wrote: > > > > On Sun, 2025-05-11 at 04:01 +0200, KP Singh wrote: > > [...] > > > > > This implicitly makes the payload equivalent to the signed > > > > > block > > > > > (B_signed) > > > > > > > > > > I_loader || H_meta > > > > > > > > > > bpftool then generates the signature of this I_loader payload > > > > > (which now contains the expected H_meta) using a key (system > > > > > or > > > > > user) with new flags that work in combination with bpftool -L > > > > > > > > Could I just push back a bit on this. The theory of hash > > > > chains > > > > (which I've cut to shorten) is about pure data structures. The > > > > reason for that is that the entire hash chain is supposed to be > > > > easily independently verifiable in any environment because > > > > anything > > > > can compute the hashes of the blocks and links. This > > > > independent > > > > verification of the chain is key to formally proving hash > > > > chains to > > > > be correct. In your proposal we lose the easy verifiability > > > > because the link hash is embedded in the ebpf loader program > > > > which > > > > has to be disassembled to do the extraction of the hash and > > > > verify > > > > the loader is actually checking it. > > > > > > I am not sure I understand your concern. This is something that > > > can > > > easily be built into tooling / annotations. > > > > > > bpftool -S -v <verification_key> <loader> <metadata> > > > > > > Could you explain what's the use-case for "easy verifiability". > > > > I mean verifiability of the hash chain link. Given a signed > > program, (i.e. a .h file which is generated by bpftool) which is a > > signature over the loader only how would one use simple > > cryptographic operations to verify it? > > > > I literally just said it above the hash can be extracted if you > really want offline verification. Are you saying this code is hard to > write? or is the tooling hard to write? Do you have some definition > of "simple cryptographic operations". All operations use tooling. As I said, you have a gap in that you not only have to extract the hash and verify it against the map (which I agree is fairly simple) but also verify the loader program actually checks it correctly. That latter operation is not a simple cryptographic one and represents a security gap between this proposal and the hash linked chains you introduced in your first email in this thread. > > > > I was looking at ways we could use a pure hash chain (i.e. > > > > signature over loader and real map hash) and it does strike me > > > > that the above ebpf hash verification code is pretty invariant > > > > and easy to construct, so it could run as a separate BPF > > > > fragment that then jumps to the real loader. In that case, it > > > > could be constructed on the fly in a trusted environment, like > > > > the kernel, from the link hash in the signature and the > > > > signature could just be Sig(loader || map hash) which can then > > > > be > > > > > > The design I proposed does the same thing: > > > > > > Sig(loader || H_metadata) > > > > > > metadata is actually the data (programs, context etc) that's > > > passed in the map. The verification just happens in the loader > > > program and the loader || H_metadata is implemented elegantly to > > > avoid any separate payloads. > > > > OK, so I think this is the crux of the problem: In formal methods > > proving the validity of a data based hash link is an easy set of > > cryptographic operations. You can assert that's equivalent to a > > signature over a program that verifies the hash, but formally > > proving it requires a formal analysis of the program to show that > > 1) it contains the correct hash and 2) it correctly checks the hash > > against the map. That makes the task of someone receiving the .h > > file containing the signed skeleton way harder: it's easy to prove > > the signature matches the loader instructions, but they still have > > to prove the instructions contain and verify the correct map hash. > > > > I don't see this as a problem for 2 reasons: > > 1. It's not hard it requires disassembling the first 20 or so BPF instructions and verifying their operation, so that's harder than simply calculating hashes and signatures. > 2. Your typical user does not want to do formal verification and > extract signatures etc. Users don't want to do formal verification, agreed ... but they do want to know that security experts have verified the algorithms they're using. That's why I was thinking, since the loader preamble that verifies the hash is easy to construct, that the scheme could use a real hash linked chain, which has already been formally verified and is well understood, then construct the preamble for the loader you want in a trusted environment based on the hashes, meaning there's no security gap. Regards, James
On Wed, May 14, 2025 at 2:48 PM KP Singh <kpsingh@kernel.org> wrote: > On Wed, May 14, 2025 at 5:06 AM Paul Moore <paul@paul-moore.com> wrote: > > On Sat, May 10, 2025 at 10:01 PM KP Singh <kpsingh@kernel.org> wrote: > > > > > > > ... > > > > > The signature check in the verifier (during BPF_PROG_LOAD): > > > > > > verify_pkcs7_signature(prog->aux->sha, sizeof(prog->aux->sha), > > > sig_from_bpf_attr, …); > > > > I think we still need to clarify the authorization aspect of your > > proposed design. > > > > Working under the assumption that the core BPF kernel code doesn't > > want to enforce any restrictions, or at least as few as possible ... > > The assumption is not true, I should have clarified it in the original > design. With the UAPI / bpf_attr the bpf syscall is simply denied if > the signature does not verify, so we don't need any LSM logic for > this. There is really no point in continuing as signature verification > is a part of the API contract when the user passes the sig, keyring in > the bpf syscall. I think we need some clarification on a few of these details, it would be good if you could answer the questions below about the authorization aspects of your design? * Is the signature validation code in the BPF verifier *always* going to be enforced when a signature is passed in from userspace? In other words, in your design is there going to be either a kernel build time or runtime configuration knob that could selectively enable (or disable) signature verification in the BPF verifier? * In the case where the signature validation code in the BPF verifier is active, what happens when a signature is *not* passed in from userspace? Will the BPF verifier allow the program load to take place? Will the load operation be blocked? Will the load operation be subject to a more granular policy, and if so, how do you plan to incorporate that policy decision into the BPF program load path?
On Fri, May 16, 2025 at 12:49 PM Paul Moore <paul@paul-moore.com> wrote: > > On Wed, May 14, 2025 at 2:48 PM KP Singh <kpsingh@kernel.org> wrote: > > On Wed, May 14, 2025 at 5:06 AM Paul Moore <paul@paul-moore.com> wrote: > > > On Sat, May 10, 2025 at 10:01 PM KP Singh <kpsingh@kernel.org> wrote: > > > > > > > > > > ... > > > > > > > The signature check in the verifier (during BPF_PROG_LOAD): > > > > > > > > verify_pkcs7_signature(prog->aux->sha, sizeof(prog->aux->sha), > > > > sig_from_bpf_attr, …); > > > > > > I think we still need to clarify the authorization aspect of your > > > proposed design. > > > > > > Working under the assumption that the core BPF kernel code doesn't > > > want to enforce any restrictions, or at least as few as possible ... > > > > The assumption is not true, I should have clarified it in the original > > design. With the UAPI / bpf_attr the bpf syscall is simply denied if > > the signature does not verify, so we don't need any LSM logic for > > this. There is really no point in continuing as signature verification > > is a part of the API contract when the user passes the sig, keyring in > > the bpf syscall. > > I think we need some clarification on a few of these details, it would > be good if you could answer the questions below about the > authorization aspects of your design? > > * Is the signature validation code in the BPF verifier *always* going > to be enforced when a signature is passed in from userspace? In other > words, in your design is there going to be either a kernel build time > or runtime configuration knob that could selectively enable (or > disable) signature verification in the BPF verifier? If there is a signature in union bpf_attr and it's incorrect the prog_load command will be rejected. No point in adding a knob to control that. > * In the case where the signature validation code in the BPF verifier > is active, what happens when a signature is *not* passed in from > userspace? Will the BPF verifier allow the program load to take > place? Will the load operation be blocked? Will the load operation > be subject to a more granular policy, and if so, how do you plan to > incorporate that policy decision into the BPF program load path? If there is no signature the existing loading semantics will remain intact. We can discuss whether to add a sysctl or cgroup knob to disallow loading when signature is not present, but it probably should be a job of trivial LSM: if (prog_attr doesn't have signature && (task == .. || task is under certain cgroup || whatever)) disallow. Note that the prog verification itself is independent of the signature. If prog fails to pass safety checks it will still be rejected even if signature is ok. We're not going to do a verifier bypass.
On Fri, May 16, 2025 at 7:49 PM Alexei Starovoitov <alexei.starovoitov@gmail.com> wrote: > On Fri, May 16, 2025 at 12:49 PM Paul Moore <paul@paul-moore.com> wrote: > > > > I think we need some clarification on a few of these details, it would > > be good if you could answer the questions below about the > > authorization aspects of your design? > > > > * Is the signature validation code in the BPF verifier *always* going > > to be enforced when a signature is passed in from userspace? In other > > words, in your design is there going to be either a kernel build time > > or runtime configuration knob that could selectively enable (or > > disable) signature verification in the BPF verifier? > > If there is a signature in union bpf_attr and it's incorrect > the prog_load command will be rejected. > No point in adding a knob to control that. I agree that when a signature is provided and that signature check fails, the BPF load should be rejected. I'm simply trying to understand how you envision your design handling all of the cases, not just this one, as well as what build and runtime options you expect for controlling various aspects of this behavior. > > * In the case where the signature validation code in the BPF verifier > > is active, what happens when a signature is *not* passed in from > > userspace? Will the BPF verifier allow the program load to take > > place? Will the load operation be blocked? Will the load operation > > be subject to a more granular policy, and if so, how do you plan to > > incorporate that policy decision into the BPF program load path? > > If there is no signature the existing loading semantics will remain intact. > We can discuss whether to add a sysctl or cgroup knob to disallow > loading when signature is not present ... As mentioned earlier this week, if the BPF verifier is performing the signature verification as KP described, we will need a LSM hook after the verifier to serve as an access control point. Of course that doesn't preclude the addition of some type of sysctl/cgroup/whatever based access control, but the LSM hook would be needed regardless. > but it probably should be a job of trivial LSM ... Exactly. If the LSM is simply verifying the signature validation state of the BPF program being loaded it seems like an addition to IPE would be the best option from an upstream, in-tree perspective. However, with the post verifier LSM hook in place, one could also supply a BPF LSM to do something similar. It sounds like we are in agreement on the desirability and need for a post verifier LSM hook; we'll keep moving forward with this idea despite KP's earlier objections to the hook. > Note that the prog verification itself is independent of the signature. > If prog fails to pass safety checks it will still be rejected > even if signature is ok. There is plenty of precedence for a kernel subsystem rejecting a security relevant operation before a LSM access control hook is called; the reasons range from discretionary access control issues to simple matters of resource exhaustion. The possibility of the BPF verifier rejecting the program load due to verifier constraints is reasonable and expected. > We're not going to do a verifier bypass. Agreed. I don't recall anyone ever suggesting that as part of this recent BPF signature verification effort.
On Sat, May 17, 2025 at 8:03 AM Paul Moore <paul@paul-moore.com> wrote: > > On Fri, May 16, 2025 at 7:49 PM Alexei Starovoitov > <alexei.starovoitov@gmail.com> wrote: > > On Fri, May 16, 2025 at 12:49 PM Paul Moore <paul@paul-moore.com> wrote: > > > > > > I think we need some clarification on a few of these details, it would > > > be good if you could answer the questions below about the > > > authorization aspects of your design? > > > > > > * Is the signature validation code in the BPF verifier *always* going > > > to be enforced when a signature is passed in from userspace? In other > > > words, in your design is there going to be either a kernel build time > > > or runtime configuration knob that could selectively enable (or > > > disable) signature verification in the BPF verifier? > > > > If there is a signature in union bpf_attr and it's incorrect > > the prog_load command will be rejected. > > No point in adding a knob to control that. > > I agree that when a signature is provided and that signature check > fails, the BPF load should be rejected. I'm simply trying to > understand how you envision your design handling all of the cases, not > just this one, as well as what build and runtime options you expect > for controlling various aspects of this behavior. > > > > * In the case where the signature validation code in the BPF verifier > > > is active, what happens when a signature is *not* passed in from > > > userspace? Will the BPF verifier allow the program load to take > > > place? Will the load operation be blocked? Will the load operation > > > be subject to a more granular policy, and if so, how do you plan to > > > incorporate that policy decision into the BPF program load path? > > > > If there is no signature the existing loading semantics will remain intact. > > We can discuss whether to add a sysctl or cgroup knob to disallow > > loading when signature is not present ... > > As mentioned earlier this week, if the BPF verifier is performing the > signature verification as KP described, we will need a LSM hook after > the verifier to serve as an access control point. Of course that > doesn't preclude the addition of some type of sysctl/cgroup/whatever > based access control, but the LSM hook would be needed regardless. No. New hook is not needed. > > but it probably should be a job of trivial LSM ... > > Exactly. If the LSM is simply verifying the signature validation > state of the BPF program being loaded it seems like an addition to IPE > would be the best option from an upstream, in-tree perspective. > However, with the post verifier LSM hook in place, one could also > supply a BPF LSM to do something similar. > > It sounds like we are in agreement on the desirability and need for a > post verifier LSM hook; we'll keep moving forward with this idea > despite KP's earlier objections to the hook. Don't twist my words please. We're absolutely _not_ in agreement. What I described above can be done with the existing hook and its current set of arguments. We're not going to move or change the existing hook.
On May 17, 2025 12:13:50 PM Alexei Starovoitov <alexei.starovoitov@gmail.com> wrote: > On Sat, May 17, 2025 at 8:03 AM Paul Moore <paul@paul-moore.com> wrote: >> On Fri, May 16, 2025 at 7:49 PM Alexei Starovoitov >> <alexei.starovoitov@gmail.com> wrote: >>> On Fri, May 16, 2025 at 12:49 PM Paul Moore <paul@paul-moore.com> wrote: >>>> >>>> I think we need some clarification on a few of these details, it would >>>> be good if you could answer the questions below about the >>>> authorization aspects of your design? >>>> >>>> * Is the signature validation code in the BPF verifier *always* going >>>> to be enforced when a signature is passed in from userspace? In other >>>> words, in your design is there going to be either a kernel build time >>>> or runtime configuration knob that could selectively enable (or >>>> disable) signature verification in the BPF verifier? >>> >>> If there is a signature in union bpf_attr and it's incorrect >>> the prog_load command will be rejected. >>> No point in adding a knob to control that. >> >> I agree that when a signature is provided and that signature check >> fails, the BPF load should be rejected. I'm simply trying to >> understand how you envision your design handling all of the cases, not >> just this one, as well as what build and runtime options you expect >> for controlling various aspects of this behavior. >> >>>> * In the case where the signature validation code in the BPF verifier >>>> is active, what happens when a signature is *not* passed in from >>>> userspace? Will the BPF verifier allow the program load to take >>>> place? Will the load operation be blocked? Will the load operation >>>> be subject to a more granular policy, and if so, how do you plan to >>>> incorporate that policy decision into the BPF program load path? >>> >>> If there is no signature the existing loading semantics will remain intact. >>> We can discuss whether to add a sysctl or cgroup knob to disallow >>> loading when signature is not present ... >> >> As mentioned earlier this week, if the BPF verifier is performing the >> signature verification as KP described, we will need a LSM hook after >> the verifier to serve as an access control point. Of course that >> doesn't preclude the addition of some type of sysctl/cgroup/whatever >> based access control, but the LSM hook would be needed regardless. > > No. New hook is not needed. It would be good for you to explain how the existing LSM hook is sufficient to authorize the loading of a BPF program using the signature validation state determined in the BPF verifier. -- paul-moore.com >
On Sat, May 17, 2025 at 10:49 PM Paul Moore <paul@paul-moore.com> wrote: > > On May 17, 2025 12:13:50 PM Alexei Starovoitov > <alexei.starovoitov@gmail.com> wrote: > > On Sat, May 17, 2025 at 8:03 AM Paul Moore <paul@paul-moore.com> wrote: > >> On Fri, May 16, 2025 at 7:49 PM Alexei Starovoitov > >> <alexei.starovoitov@gmail.com> wrote: > >>> On Fri, May 16, 2025 at 12:49 PM Paul Moore <paul@paul-moore.com> wrote: > >>>> > >>>> I think we need some clarification on a few of these details, it would > >>>> be good if you could answer the questions below about the > >>>> authorization aspects of your design? > >>>> > >>>> * Is the signature validation code in the BPF verifier *always* going > >>>> to be enforced when a signature is passed in from userspace? In other > >>>> words, in your design is there going to be either a kernel build time > >>>> or runtime configuration knob that could selectively enable (or > >>>> disable) signature verification in the BPF verifier? > >>> > >>> If there is a signature in union bpf_attr and it's incorrect > >>> the prog_load command will be rejected. > >>> No point in adding a knob to control that. > >> > >> I agree that when a signature is provided and that signature check > >> fails, the BPF load should be rejected. I'm simply trying to > >> understand how you envision your design handling all of the cases, not > >> just this one, as well as what build and runtime options you expect > >> for controlling various aspects of this behavior. > >> > >>>> * In the case where the signature validation code in the BPF verifier > >>>> is active, what happens when a signature is *not* passed in from > >>>> userspace? Will the BPF verifier allow the program load to take > >>>> place? Will the load operation be blocked? Will the load operation > >>>> be subject to a more granular policy, and if so, how do you plan to > >>>> incorporate that policy decision into the BPF program load path? > >>> > >>> If there is no signature the existing loading semantics will remain intact. > >>> We can discuss whether to add a sysctl or cgroup knob to disallow > >>> loading when signature is not present ... > >> > >> As mentioned earlier this week, if the BPF verifier is performing the > >> signature verification as KP described, we will need a LSM hook after > >> the verifier to serve as an access control point. Of course that > >> doesn't preclude the addition of some type of sysctl/cgroup/whatever > >> based access control, but the LSM hook would be needed regardless. > > > > No. New hook is not needed. > > It would be good for you to explain how the existing LSM hook is sufficient > to authorize the loading of a BPF program using the signature validation > state determined in the BPF verifier. I already explained: .. a job of trivial LSM: if (prog_attr doesn't have signature && (task == .. || task is under certain cgroup || whatever)) disallow. If that's not obvious you have to wait for patches.
On Sun, May 18, 2025 at 11:52 AM Alexei Starovoitov <alexei.starovoitov@gmail.com> wrote: > On Sat, May 17, 2025 at 10:49 PM Paul Moore <paul@paul-moore.com> wrote: > > On May 17, 2025 12:13:50 PM Alexei Starovoitov > > <alexei.starovoitov@gmail.com> wrote: > > > On Sat, May 17, 2025 at 8:03 AM Paul Moore <paul@paul-moore.com> wrote: > > >> On Fri, May 16, 2025 at 7:49 PM Alexei Starovoitov > > >> <alexei.starovoitov@gmail.com> wrote: > > >>> On Fri, May 16, 2025 at 12:49 PM Paul Moore <paul@paul-moore.com> wrote: > > >>>> > > >>>> I think we need some clarification on a few of these details, it would > > >>>> be good if you could answer the questions below about the > > >>>> authorization aspects of your design? > > >>>> > > >>>> * Is the signature validation code in the BPF verifier *always* going > > >>>> to be enforced when a signature is passed in from userspace? In other > > >>>> words, in your design is there going to be either a kernel build time > > >>>> or runtime configuration knob that could selectively enable (or > > >>>> disable) signature verification in the BPF verifier? > > >>> > > >>> If there is a signature in union bpf_attr and it's incorrect > > >>> the prog_load command will be rejected. > > >>> No point in adding a knob to control that. > > >> > > >> I agree that when a signature is provided and that signature check > > >> fails, the BPF load should be rejected. I'm simply trying to > > >> understand how you envision your design handling all of the cases, not > > >> just this one, as well as what build and runtime options you expect > > >> for controlling various aspects of this behavior. > > >> > > >>>> * In the case where the signature validation code in the BPF verifier > > >>>> is active, what happens when a signature is *not* passed in from > > >>>> userspace? Will the BPF verifier allow the program load to take > > >>>> place? Will the load operation be blocked? Will the load operation > > >>>> be subject to a more granular policy, and if so, how do you plan to > > >>>> incorporate that policy decision into the BPF program load path? > > >>> > > >>> If there is no signature the existing loading semantics will remain intact. > > >>> We can discuss whether to add a sysctl or cgroup knob to disallow > > >>> loading when signature is not present ... > > >> > > >> As mentioned earlier this week, if the BPF verifier is performing the > > >> signature verification as KP described, we will need a LSM hook after > > >> the verifier to serve as an access control point. Of course that > > >> doesn't preclude the addition of some type of sysctl/cgroup/whatever > > >> based access control, but the LSM hook would be needed regardless. > > > > > > No. New hook is not needed. > > > > It would be good for you to explain how the existing LSM hook is sufficient > > to authorize the loading of a BPF program using the signature validation > > state determined in the BPF verifier. > > I already explained: > .. a job of trivial LSM: > if (prog_attr doesn't have signature && > (task == .. || task is under certain cgroup || whatever)) > disallow. I read that earlier reply as an example that covers a sample use case, I didn't realize you were asserting that was the only approach you were considering. Perhaps that was the source of confusion earlier, we may disagree, but I don't intentionally "twist" words; not only is that rude, it's just stupid in public, archived discussions. As I mentioned previously, we really need to see an explicit yes/no flag from the BPF verifier to indicate that the signature on the BPF program has been validated. It really should be as simple as adding a bool to bpf_prog_aux which the BPF verifier sets to true upon successful signature validation, and then an LSM can use this flag as input to an access control decision in a hook placed after the verifier. Are you objecting to the addition of a flag in the bpf_prog_aux struct (or some other struct tightly coupled to the BPF program), the LSM hook after the verifier, or both? It would also be helpful if you can elaborate on the technical reasons behind these objections.
On Sun, May 18, 2025 at 11:34 PM Paul Moore <paul@paul-moore.com> wrote: > > On Sun, May 18, 2025 at 11:52 AM Alexei Starovoitov > <alexei.starovoitov@gmail.com> wrote: > > On Sat, May 17, 2025 at 10:49 PM Paul Moore <paul@paul-moore.com> wrote: > > > On May 17, 2025 12:13:50 PM Alexei Starovoitov > > > <alexei.starovoitov@gmail.com> wrote: > > > > On Sat, May 17, 2025 at 8:03 AM Paul Moore <paul@paul-moore.com> wrote: > > > >> On Fri, May 16, 2025 at 7:49 PM Alexei Starovoitov > > > >> <alexei.starovoitov@gmail.com> wrote: > > > >>> On Fri, May 16, 2025 at 12:49 PM Paul Moore <paul@paul-moore.com> wrote: > > > >>>> > > > >>>> I think we need some clarification on a few of these details, it would > > > >>>> be good if you could answer the questions below about the > > > >>>> authorization aspects of your design? > > > >>>> > > > >>>> * Is the signature validation code in the BPF verifier *always* going > > > >>>> to be enforced when a signature is passed in from userspace? In other > > > >>>> words, in your design is there going to be either a kernel build time > > > >>>> or runtime configuration knob that could selectively enable (or > > > >>>> disable) signature verification in the BPF verifier? > > > >>> > > > >>> If there is a signature in union bpf_attr and it's incorrect > > > >>> the prog_load command will be rejected. > > > >>> No point in adding a knob to control that. > > > >> > > > >> I agree that when a signature is provided and that signature check > > > >> fails, the BPF load should be rejected. I'm simply trying to > > > >> understand how you envision your design handling all of the cases, not > > > >> just this one, as well as what build and runtime options you expect > > > >> for controlling various aspects of this behavior. > > > >> > > > >>>> * In the case where the signature validation code in the BPF verifier > > > >>>> is active, what happens when a signature is *not* passed in from > > > >>>> userspace? Will the BPF verifier allow the program load to take > > > >>>> place? Will the load operation be blocked? Will the load operation > > > >>>> be subject to a more granular policy, and if so, how do you plan to > > > >>>> incorporate that policy decision into the BPF program load path? > > > >>> > > > >>> If there is no signature the existing loading semantics will remain intact. > > > >>> We can discuss whether to add a sysctl or cgroup knob to disallow > > > >>> loading when signature is not present ... > > > >> > > > >> As mentioned earlier this week, if the BPF verifier is performing the > > > >> signature verification as KP described, we will need a LSM hook after > > > >> the verifier to serve as an access control point. Of course that > > > >> doesn't preclude the addition of some type of sysctl/cgroup/whatever > > > >> based access control, but the LSM hook would be needed regardless. > > > > > > > > No. New hook is not needed. > > > > > > It would be good for you to explain how the existing LSM hook is sufficient > > > to authorize the loading of a BPF program using the signature validation > > > state determined in the BPF verifier. > > > > I already explained: > > .. a job of trivial LSM: > > if (prog_attr doesn't have signature && > > (task == .. || task is under certain cgroup || whatever)) > > disallow. > > I read that earlier reply as an example that covers a sample use case, > I didn't realize you were asserting that was the only approach you > were considering. Perhaps that was the source of confusion earlier, > we may disagree, but I don't intentionally "twist" words; not only is > that rude, it's just stupid in public, archived discussions. > > As I mentioned previously, we really need to see an explicit yes/no > flag from the BPF verifier to indicate that the signature on the BPF > program has been validated. It really should be as simple as adding a > bool to bpf_prog_aux which the BPF verifier sets to true upon > successful signature validation, and then an LSM can use this flag as > input to an access control decision in a hook placed after the > verifier. Are you objecting to the addition of a flag in the > bpf_prog_aux struct (or some other struct tightly coupled to the BPF > program), the LSM hook after the verifier, or both? It would also be > helpful if you can elaborate on the technical reasons behind these > objections. Neither the aux field, nor the hook are required because: * If the signature is passed, it will be enforced, there are no "runtime aspects" that need to be configurable here. * What the LSM can specify a policy for is when a signature is not passed, for this, it does not need an aux field or a signature or the new hook, existing hooks are sufficient. - KP > > -- > paul-moore.com
On Mon, May 19, 2025 at 3:20 PM KP Singh <kpsingh@kernel.org> wrote: > > On Sun, May 18, 2025 at 11:34 PM Paul Moore <paul@paul-moore.com> wrote: > > > > On Sun, May 18, 2025 at 11:52 AM Alexei Starovoitov > > <alexei.starovoitov@gmail.com> wrote: > > > On Sat, May 17, 2025 at 10:49 PM Paul Moore <paul@paul-moore.com> wrote: > > > > On May 17, 2025 12:13:50 PM Alexei Starovoitov > > > > <alexei.starovoitov@gmail.com> wrote: > > > > > On Sat, May 17, 2025 at 8:03 AM Paul Moore <paul@paul-moore.com> wrote: > > > > >> On Fri, May 16, 2025 at 7:49 PM Alexei Starovoitov > > > > >> <alexei.starovoitov@gmail.com> wrote: > > > > >>> On Fri, May 16, 2025 at 12:49 PM Paul Moore <paul@paul-moore.com> wrote: > > > > >>>> > > > > >>>> I think we need some clarification on a few of these details, it would > > > > >>>> be good if you could answer the questions below about the > > > > >>>> authorization aspects of your design? > > > > >>>> > > > > >>>> * Is the signature validation code in the BPF verifier *always* going > > > > >>>> to be enforced when a signature is passed in from userspace? In other > > > > >>>> words, in your design is there going to be either a kernel build time > > > > >>>> or runtime configuration knob that could selectively enable (or > > > > >>>> disable) signature verification in the BPF verifier? > > > > >>> > > > > >>> If there is a signature in union bpf_attr and it's incorrect > > > > >>> the prog_load command will be rejected. > > > > >>> No point in adding a knob to control that. > > > > >> > > > > >> I agree that when a signature is provided and that signature check > > > > >> fails, the BPF load should be rejected. I'm simply trying to > > > > >> understand how you envision your design handling all of the cases, not > > > > >> just this one, as well as what build and runtime options you expect > > > > >> for controlling various aspects of this behavior. > > > > >> > > > > >>>> * In the case where the signature validation code in the BPF verifier > > > > >>>> is active, what happens when a signature is *not* passed in from > > > > >>>> userspace? Will the BPF verifier allow the program load to take > > > > >>>> place? Will the load operation be blocked? Will the load operation > > > > >>>> be subject to a more granular policy, and if so, how do you plan to > > > > >>>> incorporate that policy decision into the BPF program load path? > > > > >>> > > > > >>> If there is no signature the existing loading semantics will remain intact. > > > > >>> We can discuss whether to add a sysctl or cgroup knob to disallow > > > > >>> loading when signature is not present ... > > > > >> > > > > >> As mentioned earlier this week, if the BPF verifier is performing the > > > > >> signature verification as KP described, we will need a LSM hook after > > > > >> the verifier to serve as an access control point. Of course that > > > > >> doesn't preclude the addition of some type of sysctl/cgroup/whatever > > > > >> based access control, but the LSM hook would be needed regardless. > > > > > > > > > > No. New hook is not needed. > > > > > > > > It would be good for you to explain how the existing LSM hook is sufficient > > > > to authorize the loading of a BPF program using the signature validation > > > > state determined in the BPF verifier. > > > > > > I already explained: > > > .. a job of trivial LSM: > > > if (prog_attr doesn't have signature && > > > (task == .. || task is under certain cgroup || whatever)) > > > disallow. > > > > I read that earlier reply as an example that covers a sample use case, > > I didn't realize you were asserting that was the only approach you > > were considering. Perhaps that was the source of confusion earlier, > > we may disagree, but I don't intentionally "twist" words; not only is > > that rude, it's just stupid in public, archived discussions. > > > > As I mentioned previously, we really need to see an explicit yes/no > > flag from the BPF verifier to indicate that the signature on the BPF > > program has been validated. It really should be as simple as adding a > > bool to bpf_prog_aux which the BPF verifier sets to true upon > > successful signature validation, and then an LSM can use this flag as > > input to an access control decision in a hook placed after the > > verifier. Are you objecting to the addition of a flag in the > > bpf_prog_aux struct (or some other struct tightly coupled to the BPF > > program), the LSM hook after the verifier, or both? It would also be > > helpful if you can elaborate on the technical reasons behind these > > objections. > > Neither the aux field, nor the hook are required because: > > * If the signature is passed, it will be enforced, there are no > "runtime aspects" that need to be configurable here. > * What the LSM can specify a policy for is when a signature is not > passed, for this, it does not need an aux field or a signature or the > new hook, existing hooks are sufficient. > What about wanting to create a policy that requires signatures under certain situations and allowing the lack of a signature under others? How is that implemented with the existing hooks? As I understand it, all the existing hooks know (would know) is that _if_ there is a signature _then_ it will be enforced. There is no way to know _whether_ there is a signature. An example policy I can think of is that most users (with CAP_BPF) must submit signed programs but some users are exempted. Would that policy be able to be made with the current hooks? > - KP > > > > > -- > > paul-moore.com >
> > > > > > No. New hook is not needed. [...] > > > > > > > > > > It would be good for you to explain how the existing LSM hook is sufficient > > > > > to authorize the loading of a BPF program using the signature validation > > > > > state determined in the BPF verifier. > > > > > > > > I already explained: > > > > .. a job of trivial LSM: > > > > if (prog_attr doesn't have signature && > > > > (task == .. || task is under certain cgroup || whatever)) > > > > disallow. > > > > > > I read that earlier reply as an example that covers a sample use case, > > > I didn't realize you were asserting that was the only approach you > > > were considering. Perhaps that was the source of confusion earlier, > > > we may disagree, but I don't intentionally "twist" words; not only is > > > that rude, it's just stupid in public, archived discussions. > > > > > > As I mentioned previously, we really need to see an explicit yes/no > > > flag from the BPF verifier to indicate that the signature on the BPF > > > program has been validated. It really should be as simple as adding a > > > bool to bpf_prog_aux which the BPF verifier sets to true upon > > > successful signature validation, and then an LSM can use this flag as > > > input to an access control decision in a hook placed after the > > > verifier. Are you objecting to the addition of a flag in the > > > bpf_prog_aux struct (or some other struct tightly coupled to the BPF > > > program), the LSM hook after the verifier, or both? It would also be > > > helpful if you can elaborate on the technical reasons behind these > > > objections. > > > > Neither the aux field, nor the hook are required because: > > > > * If the signature is passed, it will be enforced, there are no > > "runtime aspects" that need to be configurable here. > > * What the LSM can specify a policy for is when a signature is not > > passed, for this, it does not need an aux field or a signature or the > > new hook, existing hooks are sufficient. > > > > What about wanting to create a policy that requires signatures under certain > situations and allowing the lack of a signature under others? How is that > implemented with the existing hooks? > As I understand it, all the existing hooks know (would know) is that _if_ there > is a signature _then_ it will be enforced. There is no way to know _whether_ > there is a signature. > The signature is passed in bpf_attr and if there is a signature the LSM's job is done. https://elixir.bootlin.com/linux/v6.14.7/source/kernel/bpf/syscall.c#L5771 It will be enforced. - KP > An example policy I can think of is that most users (with CAP_BPF) must submit > signed programs but some users are exempted. Would that policy be able to be > made with the current hooks? > > > - KP > > > > > > > > -- > > > paul-moore.com > >