Tetragon vs Sysmon for Linux: What We Learned Running 27 Container Attacks
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:
| TracingPolicy | Kernel Hook | Attack Technique |
|---|---|---|
| fileless-execution | memfd_create, execveat | T1620 Fileless execution |
| kernel-module-loading | finit_module, init_module | T1547.006 Kernel module persistence |
| mount-operations | mount | T1611 Container escape via mount |
| ptrace-injection | ptrace | T1055.008 Process injection |
| ld-preload-hijack | security_file_open | T1574.006 LD_PRELOAD hijack |
| process-disguise | prctl | T1036.004 Process name masquerade |
| raw-socket-bpf-filter | setsockopt | T1205.001 BPFDoor style backdoor |
| io-uring-setup | io_uring_setup, io_uring_enter | Curing rootkit technique |
| seccomp-manipulation | seccomp | Seccomp notify injection |
| bpf-program-loading | bpf | T1014 BPF based rootkit |
| mmap-executable-memory | mmap | Reflective loading |
| sensitive-write-operations | write (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
| Capability | Sysmon for Linux | Tetragon eBPF |
|---|---|---|
| Process creation with full CLI | Strong (Event 1) | Present (exec events) |
| File creation/modification | Strong (Event 11) | Requires TracingPolicy per path |
| Network connections | Strong (Event 3) | Requires TracingPolicy |
| DNS queries | Strong (Event 22) | Requires TracingPolicy |
| Fileless execution (memfd) | Blind | Detects via kprobe |
| Kernel module loading | Sees userspace binary | Hooks actual syscall |
| Process injection via ptrace | May see strace binary | Hooks ptrace syscall directly |
| LD_PRELOAD hijack | Sees modified env | Hooks file open on ld.so.preload |
| Process name masquerade (prctl) | Blind | Hooks prctl syscall |
| Raw socket BPF filter | Blind | Hooks setsockopt |
| BPF program loading | Blind | Hooks bpf syscall |
| io_uring setup | Blind | Hooks io_uring_setup |
| io_uring operations | Blind | Blind (kprobe limitation) |
| seccomp manipulation | Blind | Hooks seccomp syscall |
| mmap with PROT_EXEC | Blind | Hooks mmap syscall |
| Setup complexity | Low (install + config) | High (policy authoring per technique) |
| Runtime overhead | Negligible (not measurable above baseline) | Under 1% CPU with proper filters |
| Kernel version sensitivity | Broadly compatible | Policies need per version testing (6.8+ recommended) |
| Maintenance | Stable, rarely needs updates | Policies need kernel version testing |
| Container context | Limited (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
| Metric | Value |
|---|---|
| TracingPolicies deployed | 19 |
| Tetragon Wazuh rules | ~200 |
| Tetragon Sigma rules | 36 |
| Live attack scenarios tested | 27 |
| Attacks visible only to Tetragon | 9 |
| Attacks visible only to Sysmon | 0 |
| Attacks visible to both | 18 |
| APT techniques replicated | PUMAKIT, 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.