Back to Blog
    detection engineeringcontainer security

    Tetragon vs Sysmon for Linux: What We Learned Running 27 Container Attacks

    ·11 min read

    We run both Sysmon for Linux and Cilium Tetragon on the same container host. Same machine, same kernel, same attacks. The overlap between the two tools is smaller than you would expect.

    Sysmon for Linux watches process creation, file creation, network connections, and DNS queries. It is userspace telemetry. Tetragon hooks kernel syscalls directly via eBPF kprobes and tracepoints. The difference is not just where they sit in the stack. It changes what attacks are visible to each tool.

    We learned this by running 27 container attack scenarios and building detection rules against both telemetry sources. The scenarios cover two phases: container runtime attacks (Docker socket abuse, cgroup escapes, cryptominer patterns, data exfiltration, reconnaissance, reverse shells, secret extraction, privilege escalation) and kernel level attacks (fileless execution, module loading, mount escapes, ptrace injection, LD_PRELOAD hijack, process masquerade, and more). Five of the 27 are advanced in memory simulations that replicate specific APT tooling at the syscall level.

    This post covers what we found.

    The Setup

    Our test host is Ubuntu 24.04 (kernel 6.8) running over a dozen Docker containers. It has a Wazuh agent, Sysmon for Linux, and Tetragon all running simultaneously. Telemetry flows through two separate paths into the same SIEM:

    Sysmon events are processed by Wazuh rules, forwarded through Filebeat to our log management platform, where Sigma detection rules run against them.

    Tetragon events go to a JSON event log, read by the Wazuh agent as a JSON log source, processed by dedicated Wazuh rules, then forwarded through the same pipeline where Tetragon specific Sigma rules fire.

    Both telemetry streams converge in the same search index. A single query shows detections from both sources for the same attack. That convergence is what makes the comparison useful.

    Runtime overhead was negligible for both tools. Sysmon's CPU impact was not measurable above baseline. Tetragon with 19 active TracingPolicies ran under 1% CPU and minimal memory overhead, consistent with published Cilium benchmarks. Neither tool introduced detectable latency in container operations.

    What Sysmon Sees That Tetragon Does Not

    Sysmon for Linux produces structured, high context events. A Sysmon Event 1 (Process Create) gives you the binary path, full command line, parent process, user, working directory, and file hash. All in one event. This is the same data model that made Sysmon on Windows the backbone of most detection programs.

    For container attacks where the adversary runs recognizable commands (Docker socket mounting, cgroup escape attempts, cryptominer execution patterns, Docker cp exfiltration, container reconnaissance, reverse shells, environment variable extraction, and SYS_PTRACE abuse) Sysmon's process creation events were sufficient for detection. The command line content is enough.

    Sysmon also captures DNS queries (Event 22) and network connections (Event 3), which matter for detecting C2 callbacks, DNS exfiltration, and lateral movement from containers. Tetragon can monitor these through custom TracingPolicies, but Sysmon provides them out of the box with no policy authoring required.

    Where Sysmon holds an advantage:

    Immediate usability. Install it, point your SIEM agent at the log file, and you have process/file/network telemetry flowing. No policy authoring, no kprobe selection, no kernel version compatibility concerns. Sysmon is broadly kernel version agnostic. Tetragon TracingPolicies are sensitive to kernel version (we develop and test against 6.8+), so mixed fleet deployments need per version validation.

    Rich command line context. Sysmon Event 1 includes the full command line string. Tetragon's exec events include process arguments, but kprobe events give you syscall parameters (file descriptors, flags, memory addresses) which require interpretation rather than pattern matching.

    File creation tracking. Sysmon Event 11 records every file write with the target filename. Useful for detecting webshells, dropper artifacts, and persistence mechanisms without needing to write a custom TracingPolicy for each file path.

    What Tetragon Sees That Sysmon Cannot

    This is where the gap becomes serious. Sysmon for Linux hooks at the userspace boundary. Tetragon hooks inside the kernel. A set of attack techniques are invisible to Sysmon because they operate below the layer Sysmon monitors.

    We deployed 19 TracingPolicies, each hooking specific kernel functions:

    TracingPolicyKernel HookAttack Technique
    fileless-executionmemfd_create, execveatT1620 Fileless execution
    kernel-module-loadingfinit_module, init_moduleT1547.006 Kernel module persistence
    mount-operationsmountT1611 Container escape via mount
    ptrace-injectionptraceT1055.008 Process injection
    ld-preload-hijacksecurity_file_openT1574.006 LD_PRELOAD hijack
    process-disguiseprctlT1036.004 Process name masquerade
    raw-socket-bpf-filtersetsockoptT1205.001 BPFDoor style backdoor
    io-uring-setupio_uring_setup, io_uring_enterCuring rootkit technique
    seccomp-manipulationseccompSeccomp notify injection
    bpf-program-loadingbpfT1014 BPF based rootkit
    mmap-executable-memorymmapReflective loading
    sensitive-write-operationswrite (filtered)Sensitive file modification

    Each policy generates telemetry when the specified syscall fires, regardless of whether the calling process is visible to userspace monitoring tools.

    The Attacks Sysmon Misses

    Fileless execution via memfd_create. An attacker calls memfd_create() to create an anonymous file in memory, writes a payload to it, then calls execveat() with AT_EMPTY_PATH to execute directly from the file descriptor. No binary ever touches disk. Sysmon sees nothing because there is no file creation event and no standard process creation event. Tetragon's fileless execution policy catches both the memfd_create and the execveat syscalls.

    Kernel module loading from a container. Calling insmod or finit_module() from a privileged container to load a kernel module. Sysmon might see the insmod process creation, but it cannot tell you that a finit_module syscall actually reached the kernel. Tetragon hooks the syscall directly, so you know whether the module load was attempted at the kernel level, not just that a userspace binary ran.

    LD_PRELOAD hijack. An attacker compiles a shared library with a constructor function, sets LD_PRELOAD to load it, and every subsequent process in that environment runs the injected code. The LD_PRELOAD mechanism operates at the dynamic linker level. Sysmon may record the process creation with the modified environment, but Tetragon's security_file_open hook on ld.so.preload catches the actual file open that loads the malicious library, regardless of how the preload was set.

    PUMAKIT multi stage dropper. One of our advanced simulations replicates this rootkit, which had zero AV detections when Elastic discovered it targeting critical infrastructure in 2024. The attack chain is memfd_create (twice), fork, prctl(PR_SET_NAME) to masquerade as a kernel thread, then execveat(AT_EMPTY_PATH). Tetragon fires on both fileless-execution and process-disguise policies. Sysmon produces no relevant events because the entire chain operates through syscalls with no disk artifacts or standard process creation.

    BPFDoor raw socket + packet filter. We replicated the Earth Bluecrow APT backdoor technique (150+ samples identified in 2025 targeting telecom and finance). The process creates a raw socket with socket(AF_PACKET, SOCK_RAW), then attaches a BPF filter with setsockopt(SO_ATTACH_FILTER) to listen for magic packets that activate the backdoor. Tetragon's raw-socket-bpf-filter policy fires on the setsockopt call. Sysmon does not instrument socket options.

    io_uring syscall bypass. This one deserves its own section.

    The io_uring Blind Spot

    The ARMO Curing rootkit proof of concept (presented at 38c3 in late 2025) demonstrated that io_uring can perform file I/O and network operations without triggering any syscall. The io_uring interface uses shared memory ring buffers between userspace and kernel. After the initial io_uring_setup() call, subsequent operations (IORING_OP_READ, IORING_OP_WRITE, IORING_OP_CONNECT) execute entirely in kernel space without going through the syscall table.

    Our simulation runs this exact chain: io_uring_setup to create the ring, then reads and writes through the ring buffer. Tetragon catches the io_uring_setup syscall because we have a kprobe on it. But the actual read and write operations are invisible. They do not trigger kprobes because they bypass the syscall entry point entirely.

    This means we can detect that a process set up an io_uring ring (which is suspicious in a container and is itself a useful detection), but we cannot see what it does after setup. The fix requires BPF LSM hooks rather than kprobes, and Tetragon supports this through lsmhooks policies. We have not deployed those yet, but the architecture supports it.

    To be clear: Sysmon cannot detect any part of this. Not the setup, not the operations. Tetragon at least catches the ring creation. Neither tool can see the ring operations without LSM hooks.

    The Honest Comparison

    CapabilitySysmon for LinuxTetragon eBPF
    Process creation with full CLIStrong (Event 1)Present (exec events)
    File creation/modificationStrong (Event 11)Requires TracingPolicy per path
    Network connectionsStrong (Event 3)Requires TracingPolicy
    DNS queriesStrong (Event 22)Requires TracingPolicy
    Fileless execution (memfd)BlindDetects via kprobe
    Kernel module loadingSees userspace binaryHooks actual syscall
    Process injection via ptraceMay see strace binaryHooks ptrace syscall directly
    LD_PRELOAD hijackSees modified envHooks file open on ld.so.preload
    Process name masquerade (prctl)BlindHooks prctl syscall
    Raw socket BPF filterBlindHooks setsockopt
    BPF program loadingBlindHooks bpf syscall
    io_uring setupBlindHooks io_uring_setup
    io_uring operationsBlindBlind (kprobe limitation)
    seccomp manipulationBlindHooks seccomp syscall
    mmap with PROT_EXECBlindHooks mmap syscall
    Setup complexityLow (install + config)High (policy authoring per technique)
    Runtime overheadNegligible (not measurable above baseline)Under 1% CPU with proper filters
    Kernel version sensitivityBroadly compatiblePolicies need per version testing (6.8+ recommended)
    MaintenanceStable, rarely needs updatesPolicies need kernel version testing
    Container contextLimited (no container ID)Native (container ID in every event)

    The table makes Tetragon look dominant, but the setup complexity column matters. Each Tetragon detection requires writing a TracingPolicy that specifies the exact kernel function to hook, the arguments to capture, and optional filters to reduce noise. Getting a single policy right involves reading kernel source to confirm function signatures, testing across kernel versions, and tuning filters to avoid capturing benign syscalls from container runtimes.

    We wrote 19 TracingPolicies. Each one took real engineering effort. Sysmon gives you process, file, network, and DNS telemetry with a single configuration file.

    Container Context

    One area where Tetragon has a structural advantage: container awareness. Every Tetragon event includes the container ID, pod name (if Kubernetes), and namespace. This means you can write detection rules that fire only when a syscall happens inside a container, or only in a specific container, without needing to correlate process IDs against container metadata.

    Sysmon for Linux has no container context. A process creation event from inside a Docker container looks identical to one from the host, except for filesystem paths that hint at overlay mounts. You can work around this with SIEM pipeline rules that check for /var/lib/docker/overlay2 in process paths, but it is a heuristic, not a guarantee.

    This matters for reducing false positives. Container runtime processes (runc, containerd, busybox, setpriv) generate enormous Sysmon event volume that must be filtered downstream. Tetragon TracingPolicies can filter at the kernel level before the event is ever generated, meaning the noisy events never reach the log file. In our deployment, kernel level filtering eliminated the need for tens of millions of suppression rules that the Sysmon pipeline requires.

    What We Run in Production

    Both. This is not a versus situation despite the title.

    Sysmon covers the userspace layer: process creation with command lines, file writes, network connections, DNS. These are the bread and butter detections that catch most commodity threats and many APT techniques that still rely on running recognizable binaries.

    Tetragon covers the kernel layer: fileless execution, namespace manipulation, ptrace injection, BPF program loading, kernel module insertion, memory permission changes. These are the techniques that sophisticated actors use specifically because userspace monitoring does not see them.

    The two tools together give us visibility from userspace down to the syscall table. The only gap remaining is io_uring ring buffer operations, which requires BPF LSM hooks that we have not yet deployed.

    Both telemetry sources feed our continuous attack validation framework, which lets us simulate kernel level techniques and prove that detection rules actually fire. This dual telemetry approach is what lets our daily validations actually prove coverage for kernel level techniques that would be invisible to Sysmon alone.

    The Numbers

    MetricValue
    TracingPolicies deployed19
    Tetragon Wazuh rules~200
    Tetragon Sigma rules36
    Live attack scenarios tested27
    Attacks visible only to Tetragon9
    Attacks visible only to Sysmon0
    Attacks visible to both18
    APT techniques replicatedPUMAKIT, BPFDoor, Curing, Pupy RAT
    Runtime overhead (Tetragon)Under 1% CPU
    Runtime overhead (Sysmon)Negligible

    Zero attacks were visible only to Sysmon. That does not mean Sysmon is redundant. It means the attacks we designed were specifically targeting kernel level blind spots. In a typical compromise involving credential theft, lateral movement, and tool deployment, Sysmon's command line and file creation telemetry catches most of the kill chain. Tetragon catches the parts that a sophisticated attacker designs to be invisible to userspace tools.

    Recommendations

    If you run containers and you can only deploy one tool, deploy Sysmon first. It gives you the widest coverage with the least effort. The detections you build against process creation and file writes will catch the majority of real world attacks.

    If you run containers and you face adversaries who use fileless techniques, process injection, or kernel level persistence, add Tetragon. The engineering cost is real (TracingPolicy authoring is not trivial), but the visibility into memfd_create, ptrace, BPF program loading, and namespace manipulation cannot be replicated at the userspace level.

    If you are building a detection program from scratch, start with Sysmon for breadth, add Tetragon TracingPolicies for the specific kernel techniques that your threat model calls for, and plan for BPF LSM hooks to close the io_uring gap.

    The tools are complementary, not competing. Use both.