eBPF‑Based Kernel Integrity Attestation for Secure Boot on Linux 6.14

The Linux kernel has long relied on Secure Boot to guarantee that the code loaded during the early boot sequence is signed by a trusted authority. While this protects the system from persistent boot‑time malware, it does not address runtime compromises that occur after the kernel has taken control. In Linux 6.14, the kernel introduces a brand‑new eBPF‑driven integrity attestation framework that continuously verifies that the executing kernel image matches the originally signed payload. This article provides a low‑level, step‑by‑step walkthrough of how the feature works, how to enable it, and how security teams can integrate the attestation data into zero‑trust orchestration pipelines.

Why Runtime Attestation Matters

Secure Boot verifies the PEM signature of vmlinuz before handing control to the kernel. However, sophisticated attackers can still inject malicious code after boot via:

• Loadable kernel modules (LKMs) that bypass module signature verification.
• Direct memory patching through compromised drivers.
• Exploitation of SELinux or AppArmor policy misconfigurations.

The new eBPF attestation subsystem, named kint_attest, creates a cryptographic hash of the kernel’s code and data sections at load time and then re‑hashes them periodically using an eBPF program attached to the kprobe of the security_inode_permission hook. Any deviation triggers an immediate kernel panic or a user‑space alert, depending on the configured policy.

Core Components of the Attestation Stack

The framework consists of three tightly coupled components:

1. Boot‑time Measurement Engine (BME): Executes in the early boot stage, reads the ELF headers of vmlinuz, computes a SHA‑384 digest of each loadable segment, and stores the digests in a read‑only kernel data structure (struct kint_snapshot).
2. eBPF Attestation Program (EAP): A privileged eBPF program that runs in the kernel’s kprobe context. It reads the current memory contents of the measured sections, recomputes the digest, and compares it against the BME snapshot.
3. User‑Space Attestation Daemon (USAD): A systemd‑managed daemon (kintd) that loads the eBPF bytecode, configures the policy (panic vs. notify), and forwards any integrity violations to a remote telemetry endpoint via TLS‑encrypted gRPC.

Enabling the Feature in Linux 6.14

To start using the attestation framework, rebuild the kernel with the following configuration options enabled:

CONFIG_KINT_ATTEST=y
CONFIG_KINT_ATTEST_EBPF=y
CONFIG_KINT_ATTEST_USERSPACE=y
CONFIG_CRYPTO_SHA384=y

After recompiling, add the following kernel command‑line parameters:

kint_attest=enable
kint_policy=panic   # alternatives: notify, logonly
kint_interval=30    # seconds between periodic checks

Finally, enable the daemon:

systemctl enable --now kintd.service

Inside the eBPF Attestation Program

The eBPF bytecode is generated automatically by the build system, but for transparency we can inspect the source located at /usr/lib/kintd/attest.bpf.c. The program follows a classic kprobe pattern:

SEC("kprobe/security_inode_permission")
int kint_attest_probe(struct pt_regs *ctx)
{
    struct kint_snapshot *snap = bpf_map_lookup_elem(&snap_map, &zero);
    if (!snap)
        return 0; // no snapshot, should never happen

    // Re‑hash the .text section
    __u8 cur_hash[SHA384_DIGEST_SIZE];
    bpf_probe_read_kernel(&cur_hash, sizeof(cur_hash), snap->text_addr);

    // Compare with the stored hash
    if (bpf_memcmp(cur_hash, snap->text_hash, SHA384_DIGEST_SIZE) != 0) {
        // Integrity violation – send event to user‑space
        struct kint_event ev = { .type = KINT_EVT_TEXT_CORRUPT };
        bpf_perf_event_output(ctx, &events, BPF_F_CURRENT_CPU,
                              &ev, sizeof(ev));
        // Optionally trigger panic based on policy
        if (snap->policy == KINT_POLICY_PANIC)
            bpf_trigger_panic();
    }
    return 0;
}

Notice the use of bpf_probe_read_kernel to safely read kernel memory, and bpf_perf_event_output to push a notification to the user‑space daemon. The bpf_trigger_panic helper is a new addition in Linux 6.14 that forces an immediate kernel panic when the policy requires it.

Integrating Attestation with Zero‑Trust Orchestration

The attestation daemon emits protobuf messages over gRPC to the endpoint defined in /etc/kintd/config.yaml. A typical security‑orchestrator (e.g., HashiCorp Sentinel, Open Policy Agent, or a custom ServiceNow integration) can consume these events and enforce a response such as:

• Isolate the host from the network via a firewall rule.
• Trigger an automated forensic snapshot using kexec to capture memory.
• Invalidate the host’s TLS certificate in the internal PKI.

Because the attestation data is signed with the kernel’s built‑in RSA‑PSS key, the orchestrator can verify authenticity without trusting the host’s operating system.

Performance Impact and Benchmarks

The eBPF program runs only on the selected kprobe, which is triggered whenever a process checks inode permissions—a relatively frequent event. Benchmarks performed on an AMD Zen 4 server (12‑core, 64 GB RAM) show:

The overhead is negligible for most workloads, and the security benefit outweighs the cost in high‑value environments such as financial trading platforms, critical infrastructure SCADA nodes, and confidential compute clusters.

Limitations and Future Work

While the current implementation protects the kernel’s static code and read‑only data sections, it does not yet cover dynamically allocated kernel memory (e.g., kmalloc buffers) or user‑space binaries that are mapped after boot. The Linux community has already drafted a follow‑up feature, kint_dynamic, which will use eBPF tracepoints on kmem_cache_alloc to extend the measurement surface.

Additionally, the attestation framework assumes a trusted root of verification – the Secure Boot public key. In environments where hardware root‑of‑trust (TPM 2.0) is unavailable, administrators must rely on a software‑based trust anchor, which reduces the overall assurance level.

Best‑Practice Checklist

• Compile the kernel with CONFIG_KINT_ATTEST and enable CONFIG_CRYPTO_SHA384.
• Store the attestation daemon’s TLS certificates on a hardware security module (HSM) to prevent key exfiltration.
• Set kint_policy=panic only on hosts that can afford a brief outage; otherwise use notify and let the orchestrator decide.
• Integrate the gRPC endpoint with your existing SIEM or XDR platform for correlated alerts.
• Regularly rotate the Secure Boot signing keys and re‑enroll the attestation daemon to avoid key reuse attacks.

"Runtime kernel attestation turns the kernel from a static trust anchor into a continuously verified component, closing a gap that attackers have exploited for years."

Conclusion

Linux 6.14’s eBPF‑based kernel integrity attestation is a game‑changing addition to the security toolbox. By marrying Secure Boot’s immutable start‑up guarantee with a lightweight, high‑frequency runtime verification loop, it gives operators the ability to detect and respond to kernel compromises the moment they occur. The implementation is deliberately simple—leveraging existing eBPF infrastructure, a small user‑space daemon, and standard cryptographic primitives— which means it can be deployed today on production fleets without major architectural changes.

As the threat landscape continues to evolve, especially with the rise of supply‑chain attacks that target kernel modules and firmware, continuous attestation will become a baseline requirement for any organization that claims a zero‑trust posture. Stay tuned for the upcoming kint_dynamic extension, which promises to broaden coverage to mutable kernel memory and even selected user‑space binaries.