Research · v1.0.0

Is a Software Bill of Behavior Good Enough? Replaying Four Real-World Compromises Against a Behavior-Level Supply-Chain Control

Lars Shakya Buch-Jepsen

v1.0.0Latest stable release: 2026-11-21

Is a Software Bill of Behavior Good Enough? Replaying Four Real-World Compromises Against a Behavior-Level Supply-Chain Control

Status and disclosure scope. This article reports the committed, run-URL-cited evidence of the public verification harness SBOB-Examples [1] and its public toolchain repositories [2] [3] [4]. All results are CI-lab evidence: disposable containers, replayed corpora, and stamped green workflow runs in the harness repository. No production pilot, performance, or false-positive-rate measurements are claimed anywhere in this article. All incident reconstructions are watermarked and defanged and were executed loopback-only; no real credentials, endpoints, or live exploits were touched. A companion article in this collection describes the transpiler that produces the detection and enforcement artifacts under test.

1. Introduction

On 2026-11-17, versions 1.26.1 and 1.26.2 of Microsoft’s official agent-framework package were published to PyPI with an added credential stealer, reached roughly 41k downloads per week of exposure, and were removed within about 55 minutes [5] [6]. The attacker held publish access and uploaded wheel-only artifacts with no matching git tag and no test suite; the stealer then ran on every Python start through a .pth startup hook, harvesting environment variables, /proc/*/environ, and up to 60-80 credential files, and exfiltrated them in a single HTTPS POST. Signing and provenance tooling answers “was this release authorized?”; it cannot answer “what does this code do at runtime?” - especially when the attacker authors the release and its test corpus, which is exactly what test-derived behavioral profiles ingest.

The same blind spot appears in incidents that never touch the supply chain. Runtime CVEs - the PHP2Shell PHP RCEs (CVE-2026-109618, CVE-2026-109619, added to the CISA Known Exploited Vulnerabilities catalog on 2026-10-26 [7]), Java2Shell (CVE-2026-114938, a JIT RCE in OpenJDK 17), and NGINX2Root (CVE-2026-123007, an unauthenticated nginx RCE chained to a kernel SCTP local-privilege-escalation) - ship no release at all, so no artifact gate can inspect anything. What they share with the PyPI hijack is that the post-exploitation activity is observable behavior: a shell spawn, an undeclared file write, an undeclared socket, a kernel module load. Earlier supply-chain incidents made the same point from the other side: the SolarWinds compromise delivered the attack inside a legitimate, fully inventoried update pipeline [8], and Log4Shell turned a logging feature in a ubiquitous dependency into a remote-code-execution primitive that no component inventory could distinguish from legitimate use [9].

Transparency artifacts have nonetheless become the supply chain’s first line of defense: Executive Order 14028 put SBOMs on the regulatory map [10], the NTIA minimum-elements report fixed what an SBOM must contain [11], CycloneDX [12] and SPDX [13] made them machine-processable, and SLSA [14] and in-toto [15] grade build provenance and attest each supply-chain link, with Sigstore [16] providing keyless signing for releases. All of these answer composition and provenance questions. None declares what a deployed workload is allowed to do.

This article answers one empirical question: can a declared behavior contract, machine-enforced through a Monitor-Audit-Enforce ladder, detect and deny real post-compromise behavior - and where does it honestly fail? We answer it with evidence, not opinion, by replaying four real-world compromise classes against the Software Bill of Behavior (SBoB) toolchain in a public verification harness whose every claim cites a committed evidence document and a stamped green CI run URL [1].

2.1 Transparency and provenance artifacts answer “what”, not “what it does”

The SBOM ecosystem is now standardized: NTIA’s minimum elements [11], CycloneDX [12] and SPDX [13] interchange formats, regulatory pull from EO 14028 [10], and build-integrity frameworks such as SLSA [14] and in-toto [15], with Sigstore [16] signing releases. These artifacts describe composition and provenance of the artifact. None of them says anything about the deployed system’s runtime behavior, which is where the post-compromise signal lives.

2.2 Detection stacks alert on events; they do not declare allowances

Wazuh agents collect events - the Linux audit subsystem [17] on Linux hosts, the Windows event channel with Sysmon, typically - and ship them to a manager whose decoder chains and rules raise alerts, with CDB lists for allowlist-style lookups [18]. Sigma standardized shareable detection rules [19], Falco brought syscall-level runtime rules to containers [20], and MITRE ATT&CK catalogs the post-compromise behaviors such rules target [21]. These stacks are configured by hand per host: the question “what is this workload allowed to do?” is answered implicitly, or not at all.

2.3 Enforcement stacks block; they do not derive from a per-workload contract

Linux seccomp BPF enforces syscall policy [22] and AppArmor enforces path and capability policy [23]; Kubernetes NetworkPolicy does the same for egress. Each is written per workload by hand, so the same workload’s detection rule, enforcement profile, and release review are three artifacts written three times and drifted three times.

2.4 The gap: a declared behavior contract per workload

The Software Bill of Behavior addresses the gap by making the workload’s expected observable behavior a reviewable, versioned manifest [24]: the executables it may run, the paths it may open, the endpoints it may connect to. A declared contract enables drift detection (observed behavior outside the contract is an alert) and behavioral release review (a release that widens the contract is a scored decision). The transpiler that compiles such manifests into Wazuh detection bundles, multi-engine rules, enforcement profiles, and a scored release-diff gate is described in the companion transpiler article of this collection; this article tests the resulting contracts against real compromises.

3. The SBoB Model and Toolchain Under Test

An SBoB manifest binds one container image (spec.imageID) to a declarative contract: execs[], opens[], egress[], ingress[], plus rulePolicies qualifying signature-class actions [24]. The toolchain - the public Software-Bill-of-Behavior transpiler and CLI [2], the SBOB-Forge generator [3], and the SBOB-Registry profile registry [4] - produces, per workload:

  • Supply-chain gates (pre-install): fail-closed refusal when no comparable profile can be generated or verified; signed-registry verification (ERR_VERIFY_SIG_MISSING); and canary profiling of the artifact under a kernel-level audit observer.
  • Detection (Monitor/Audit): transpiled Wazuh drift rules and CDB allowlists [18], fed by node-side auditd [17], plus Sigma rules [19].
  • Enforcement (Enforce): NetworkPolicy egress allowlists, AppArmor exec/open allowlists, and seccomp profiles over the signature syscall surface [22] [23], with active responses and an enforcement-telemetry rule.

The ladder is toolchain-enforced: a section may not skip rungs (ERR_ENFORCE_LADDER), and entering Enforce requires an operator-attested incident-free audit window (ERR_ENFORCE_NOT_AUDITED). The whole toolchain is drift-gated: every CI run of the harness regenerates the artifacts from the pinned toolchain and diffs them against the committed bundles, so the evidence can never silently stale.

4. Method: A Verification Harness, Not a Demo

SBOB-Examples [1] answers the research question with committed evidence. All nine milestones (M1-M9; issues #2-#6, #10, #11, #14, #15) are closed on main as of 2026-11-20. Four scenarios, each with its own CI lane, committed evidence document, and stamped green run URL:

Scenario Compromise class Entry vector Milestones
A: agent-framework PyPI hijack (2026-11-17) Malicious release; attacker authors artifact and corpus Unauthorized publish M1-M5
B: PHP2Shell (CVE-2026-109618/109619) Memory-corruption RCE in php-fpm [25] [26] [7] CVE; no release ever shipped M6-M7
C: Java2Shell (CVE-2026-114938) JIT Base64 fast-path RCE in OpenJDK 17, pre-auth on common Java services [27] CVE in runtime M8
D: NGINX2Root (CVE-2026-123007) Unauthenticated nginx RCE chained to a kernel SCTP LPE, including container escape [28] CVE + kernel LPE M9

Harness discipline, enforced by tests rather than by convention:

  1. Reconstructed payloads are watermarked and run only in disposable CI containers; every network stand-in is loopback-local (a loopback sink stands in for the exfil endpoint, the C2 becomes a 127.0.0.1 listener, declared peers are aliased onto lo), with CI assertions that no non-loopback socket is ever opened.
  2. The audit observer runs node-side - in-container auditd cannot hold the netlink multicast group on hosted runners, a fact proven live during the harness work - which matches the production SBoB deployment model.
  3. Every lane uses expected-verdict assertions with run URLs, never permanently red: an expected-silent window (a behavior that should not fire) is asserted as silent, so absences are findings, not hidden gaps.

The evidence base is docs/incident-report.md, docs/supply-chain-evidence.md, and the per-scenario evidence documents (docs/agent-framework/, docs/php2shell/, docs/java2shell/, docs/nginx2root/), each stamped with its green run URLs.

5. Experimental Evaluation

Evaluation status. All four scenarios were executed for real in disposable CI containers against the pinned toolchain, with committed evidence documents and stamped green workflow runs (cited per claim below; the eight distinct run URLs are 44657815995, 44789125134, 44789707792, 44800715326, 44591553822, 44821530534, 44828736662, 44834477759 in the SBOB-Examples Actions tab). Detection was validated both on recorded event corpora through the Wazuh logtest path and, where the harness could execute behaviors live, by real side effects. Enforcement was validated by real kernel-level denials. This is CI-lab validation: no production pilot, no event-volume false-positive measurement, and no performance or overhead numbers are claimed.

5.1 Scenario A - the supply-chain hijack (gates + detection + enforcement)

  • Gate A (fail-closed refusal) - the realistic catch. 1.26.1/1.26.2 shipped wheel-only, no sdist, no tag, no tests, so no comparable candidate profile can be generated or verified: the gate fails closed and flags the dependency-update PR for human review, and a consumer pinning signed registry profiles finds no signed entry (sbobctl verify exits with ERR_VERIFY_SIG_MISSING), breaking the automated-install path (loose >=1.26 pins) that did the damage in the real 55-minute window. run 44657815995
  • Gate B (scored delta, on demo scaffolding only) scored clean (0) on both malicious versions: the attacker’s harvesting destinations are all dynamic (built with os.path.join and request-object POSTs) and quarantine without declared placeholder policies. This clean-0 is itself the finding: corpus-derived profiles are author-supplied claims, and an attacker who ships no tests authors a corpus that proves nothing.
  • Gate C (canary, kernel-observed) identifies the stealer pre-install without attacker cooperation: the .pth hook fires on the first Python start, and the canary deltas score advisory (1.26.1: 21, 1.26.2: 23; clean control delta = 0) - below mandatory because the diff ladder weights credential reads at +1 each, which is itself a recorded finding (Section 6, finding 3).
  • Layer 2 (Monitor/Audit detection) - on the first .pth-triggered Python start, open-drift rule 100221 fired on the /proc/*/environ sweep and credential-file reads, and connect-drift rule 100231 fired on the single exfil POST - minutes after install, not at the next CVE scan. Honest absences (exec-drift 100211, the cloud-credential overlay 100201) stayed quiet and were asserted as such. runs 44789125134 and 44789707792
  • Layer 3 (Enforce) - with egress limited to declared peers, the exfil POST failed closed at the kernel level (REJECT counter hit, zero sink receipts), the clean 1.26.0 workload was untouched (no false positive), and the Monitor-Audit-Enforce transition was committed in a validated state file. run 44800715326

5.2 Scenario B - PHP2Shell: detection and enforcement in anger

No supply-chain layer exists by nature (no release shipped) - stated, not papered over. Four post-exploit behaviors were executed for real in a disposable php-fpm container: a /bin/sh spawn, a webshell drop into the webroot, a C2 callback, and memfd_create staging. Detection fired the mapped rules 100111/100121/100131/100163 on the recorded corpus, with the sustained-frequency children 100112/100122/100132 driven through the session API replay; live capture fired the node-scoped 100163 and proved behaviors 1-3 by real side effects. Under Enforce, all four behaviors were blocked for real: shell exec denied, webshell write denied, C2 connect failed closed (REJECT counter +1), and memfd_create returned EPERM - with the benign workload fully unaffected. runs 44591553822 and 44821530534

5.3 Scenario C - Java2Shell: the JVM case

A Java 17 service fixture executed the post-RCE chain for real: the transpiled bundle (registry slot 3) fired 100311 (shell exec), 100321 (JSP write), and 100331 (C2 connect), with sustained children 100312/100322/100332 on the 8x session replay; the benign corpus stayed silent. The in-JVM defineClass staging leg produced no OS-visible record - recorded as an expected-silent finding: the moment the payload touches the OS (exec, file, socket), drift fires. run 44828736662

5.4 Scenario D - NGINX2Root: worker scope and host scope

An nginx fixture ran the post-RCE worker chain as the worker uid: worker-scope drift 100411 (shell exec), 100421 plus the sensitive-file overlay 100401 (recon reads of /etc/passwd, /etc/shadow), 100431 (C2 connect), and the host-scope module-load signature 100460 fired live when the first SCTP socket autoloaded the sctp kernel module. The post-escape host root shell fired host-scope 100511/100521/100501 on the recorded corpus, observed through the node-side audit observer. run 44834477759

5.5 Verdict summary

Scenario Detected at first execution Damage step denied under Enforce Clean workload false positives
A: PyPI hijack Yes (rules 100221/100231) + pre-install refusal and canary Yes (exfil POST failed closed, 0 sink receipts) None
B: PHP2Shell Yes (100111/100121/100131/100163 + sustained children) Yes (all four behaviors denied) None
C: Java2Shell Yes (100311/100321/100331 + sustained children); in-JVM staging invisible Detection-layer scenario None
D: NGINX2Root Yes (worker 100411/100421/100431, module-load 100460 live, host 100511/100521/100501) Detection-layer scenario None

6. Findings: Where the Behavior Layer Stops

The harness’s expected-verdict discipline surfaced exactly where the model stops. Each finding is a committed evidence item, not a hidden absence:

  1. Provenance gap. SBoB observes behavior, not identity: the unauthorized publish, the wheel-only upload, and the missing tag are provenance signals it does not see (by design).
  2. Corpus blind spot (structural). Test-derived baselines only prove what their author wanted proven; a compromised release ships whatever corpus the attacker chooses, and dynamic destinations quarantine in static lift (Gate B scored clean-0). The supply-chain layer must therefore rest on refusal and kernel observation, never on attacker-supplied tests.
  3. Credential-read mass is under-weighted on the diff ladder (+1 per read-only open, so advisory 21/23, never mandatory at 60-80 files); at the detection layer the cloud-credential watchlist does not cover .azure/, .npmrc, .git-credentials, or runner tokens, so the level-12 overlay never fires.
  4. DNS-blind egress: name resolution rides the declared resolver and alerts nothing; only the connect to the resolved IP fires.
  5. Container exe-scoping. Node-side auditd resolves container binaries via overlay2 paths, so exe-scoped audit keys cannot tag containerized workloads; the affected rules were proven on recorded corpora, while live behaviors were proven by side effects.
  6. In-JVM staging is invisible until it touches the OS (the defineClass leg of scenario C).
  7. Kernel-internal exploitation is invisible to userspace audit (the SCTP LPE work itself); only the module-load event is observable - and on hosts where sctp is already loaded, no event exists at all (the scenario D expected-silent variant).
  8. Cold-start consumers have no baseline and therefore no drift signal; the ladder correctly forces Monitor to precede Audit and Enforce.
  9. Multi-workload managers: the generated opens base rules match on record type, not on the event key, so with several bundles installed the lowest-slot open rule shadows the others (observed live; the escape gate ran host-only, matching the production one-workload-per-agent-group shape).
  10. Publisher-side corpus availability cannot be assumed - the planned upstream microsoft/agent-framework corpus returned 404 after the takedown; the lane re-checks availability on every run and records the finding.

7. Implications for Software Supply Chain Protection

The evidence supports a layered position, not a substitution:

  • Provenance and signing remain the first line (PyPI Sigstore [16], Rekor, SLSA [14], registry policies): they address the root cause of scenario A, the unauthorized publish. SBoB does not and cannot claim to catch that.
  • SBoB’s distinctive value is the behavior layer: (a) pre-install refusal when an artifact cannot be profiled or verified - the only automated control that broke scenario A’s install path; (b) canary identification of what an artifact actually does, without trusting its tests; (c) runtime detection of post-exploitation behavior regardless of entry vector - including CVE classes where no supply-chain artifact exists at all (scenarios B-D); (d) enforcement that fails closed on the damage step (exfil, shell, write, memfd) with no false positives on the clean workload.
  • Deployment discipline matters: the Monitor-Audit-Enforce ladder with an attested incident-free audit window is not bureaucracy; it is what makes Enforce safe to enable, because cold-start consumers otherwise have no signal to audit.

8. Improvement Roadmap

Each improvement maps to a finding in Section 6:

  1. Weight credential access as a capability class (a ladder class keyed on credential-path shapes such as /proc/*/environ and dotfile credential names) and extend the sensitive-file watchlist to cloud and CI credential locations (.azure/, runner _temp tokens, .git-credentials, .npmrc) - fixes finding 3.
  2. Close the dynamic-destination quarantine in static lift: declared placeholder policies for os.path.join-built paths and request-object URLs, so publisher-side profiles do not under-report exactly the harvesting surface - fixes finding 2.
  3. Container-aware attribution: uid/cgroup-scoped audit modes (or an in-container agent on self-hosted nodes) so exe-scoped rules actually tag containerized workloads node-side - fixes finding 5 and makes live detection of scenarios B-D as strong as the corpus proofs.
  4. Key-aware opens base rules (match the event’s key, not just the record type) so multi-workload managers do not shadow by registry slot - fixes finding 9.
  5. In-runtime instrumentation for the JVM and PHP cases (JVMTI/javaagent [29], or syscall interposition) to make in-JVM defineClass staging observable - fixes finding 6; and eBPF/LSM-based kernel telemetry [30] for the module-load and exploitation surface - fixes finding 7.
  6. DNS-layer egress visibility (resolver logging correlated with connects) to shrink the DNS-blind window - fixes finding 4.
  7. Registry discipline: fail-closed signed profiles in consumer CI, corpus-availability re-checks with recorded 404 findings, and drift-gated regenerate-and-diff on every lane run - sustains findings 1 and 10 as first-class gates.
  8. Honesty floor as a permanent gate: malicious canaries must score at least advisory (asserted in CI), and every expected-silent window (in-JVM staging, sctp-already-loaded, kernel-internal work) must remain a committed finding, not a hidden absence.

9. Discussion and Limitations

This study’s strength is also its limit: the evidence is CI-lab evidence. It proves that the transpiled artifacts are accepted by a real Wazuh manager, that they fire on the mapped drift and stay silent on benign corpora, and that enforcement denies the damage step in a disposable container - all with committed, rerunnable evidence. It does not measure false-positive rates at production event volume, alert fatigue, or the operational cost of contract maintenance; those require the production pilot. The four scenarios are real compromise classes, but the replayed payloads are watermarked reconstructions running loopback-only, so the harness proves the control’s behavior on faithful stand-ins, not on live attacker infrastructure. Finally, the corpus blind spot (finding 2) means the supply-chain gates were validated with demo scaffolding for the scored-delta path; the fail-closed refusal and the kernel-observed canary - the two gates that do not depend on attacker cooperation - are the validated ones.

10. Conclusion

Across four real compromise classes - a PyPI hijack, two runtime RCEs, and an nginx RCE chained to a kernel LPE with container escape - a behavior-level contract graded Monitor-Audit-Enforce detected the post-exploitation behavior in every case and denied the damage step under Enforce with zero false positives on the clean workload. Equally important, the harness’s expected-verdict discipline surfaced exactly where the model stops: provenance, attacker-controlled corpora, credential-read weighting, DNS-blind egress, container exe-scoping, in-runtime staging, and kernel-internal work. For software supply chain protection, the practical answer is therefore not “SBoB instead of signing” but signing for provenance, SBoB for behavior: refusal and canary at the gate, drift detection at first execution, and fail-closed enforcement on the exfil/exec/write surface - with the gap map in Section 6 as the improvement roadmap for the toolchain.

[1]
DevelApp.ai, “SBOB-Examples: Verification harness replaying real compromises against the SBoB toolchain.” [Online]. Available: https://github.com/DevelApp-ai/SBOB-Examples
[2]
DevelApp.ai, “Software-bill-of-behavior: The SBoB transpiler and sbobctl CLI.” [Online]. Available: https://github.com/DevelApp-ai/Software-Bill-of-Behavior
[3]
DevelApp.ai, “SBOB-Forge: Candidate SBoB generation from artifacts and telemetry.” [Online]. Available: https://github.com/DevelApp-ai/SBOB-Forge
[4]
DevelApp.ai, “SBOB-Registry: Committed workload registry and signed profile registry.” [Online]. Available: https://github.com/DevelApp-ai/SBOB-Registry
[5]
Wiz Research, “Malicious version of Microsoft’s agent-framework published to PyPI.” [Online]. Available: https://www.wiz.io/blog/malicious-version-of-microsofts-agent-framework-published-to-pypi
[6]
Aikido Security, “Two malicious agent-framework releases hit PyPI in 33 minutes.” [Online]. Available: https://www.aikido.dev/blog/two-malicious-agent-framework-releases-hit-pypi-in-33-minutes
[7]
Cybersecurity and Infrastructure Security Agency, “Known exploited vulnerabilities catalog.” [Online]. Available: https://www.cisa.gov/known-exploited-vulnerabilities-catalog
[8]
Cybersecurity and Infrastructure Security Agency, “Compromise of SolarWinds Orion network management product, alert AA20-352A.” CISA, 2020. Available: https://www.cisa.gov/news-events/alerts/aa20-352a
[9]
National Institute of Standards and Technology, “CVE-2021-44228: Critical vulnerability in apache Log4j2.” NVD, 2021. Available: https://nvd.nist.gov/vuln/detail/CVE-2021-44228
[10]
Executive Office of the President, “Improving the nation’s cybersecurity, executive order 14028.” Federal Register, 86 FR 33533, 2021. Available: https://www.federalregister.gov/documents/2021/05/12/2021-10460/improving-the-nations-cybersecurity
[11]
National Telecommunications and Information Administration, “The minimum elements for a software bill of materials (SBOM),” U.S. Department of Commerce, 2021. Available: https://www.ntia.gov/report/2021/minimum-elements-software-bill-materials-sbom
[12]
OWASP Foundation, “CycloneDX specification.” OWASP Foundation, 2024. Available: https://cyclonedx.org/specification/
[13]
ISO/IEC, Information technology — software package data exchange (SPDX) specification. 2021. Available: https://spdx.dev/specifications/
[14]
OpenSSF SLSA Project, “Supply-chain levels for software artifacts (SLSA) v1.0.” OpenSSF, 2023. Available: https://slsa.dev
[15]
in-toto Project, “In-toto: A framework to secure the integrity of software supply chains.” CNCF, 2024. Available: https://in-toto.io
[16]
Sigstore Project, “Sigstore: Keyless signing for software supply chains.” [Online]. Available: https://sigstore.dev
[17]
Linux Audit Project, “Linux audit subsystem.” [Online]. Available: https://github.com/linux-audit
[18]
Wazuh, Inc., “Wazuh documentation.” [Online]. Available: https://documentation.wazuh.com/
[19]
Sigma Project, “Sigma: Generic signature format for SIEM systems.” [Online]. Available: https://github.com/SigmaHQ/sigma
[20]
CNCF Falco Project, “Falco: Cloud native runtime security.” [Online]. Available: https://falco.org
[21]
MITRE, “MITRE ATT&CK matrix for enterprise.” [Online]. Available: https://attack.mitre.org
[22]
Linux Kernel Documentation, “Seccomp BPF (SECure COMPuting with filters).” [Online]. Available: https://docs.kernel.org/userspace-api/seccomp_filter.html
[23]
AppArmor Project, “AppArmor.” [Online]. Available: https://apparmor.net
[24]
Bill of Behavior, “Software bill of behavior (BoB) specification.” Online specification, 2026. Available: https://billofbehavior.com/bob/docs/spec/
[25]
National Institute of Standards and Technology, “CVE-2026-109618: PHP2Shell remote code execution in PHP.” NVD, 2026. Available: https://nvd.nist.gov/vuln/detail/CVE-2026-109618
[26]
National Institute of Standards and Technology, “CVE-2026-109619: PHP2Shell remote code execution in PHP.” NVD, 2026. Available: https://nvd.nist.gov/vuln/detail/CVE-2026-109619
[27]
National Institute of Standards and Technology, “CVE-2026-114938: Java2Shell JIT remote code execution in OpenJDK 17.” NVD, 2026. Available: https://nvd.nist.gov/vuln/detail/CVE-2026-114938
[28]
National Institute of Standards and Technology, “CVE-2026-123007: NGINX2Root unauthenticated remote code execution in nginx.” NVD, 2026. Available: https://nvd.nist.gov/vuln/detail/CVE-2026-123007
[29]
Oracle, “Java virtual machine tool interface (JVMTI) specification, Java SE 17.” [Online]. Available: https://docs.oracle.com/en/java/javase/17/docs/specs/jvmti.html
[30]
eBPF Foundation, “eBPF: Safe kernel programmability.” [Online]. Available: https://ebpf.io