Network EdgeOpen source · alpha

Aethon

Wire-speed Linux kernel-bypass intrusion prevention and stateful TCP inspection, dropping volumetric attacks in the network driver RX ring.

Aethon is an XDP and AF_XDP intrusion prevention system for Linux hosts. It filters malicious packets in the kernel driver before the TCP/IP stack is ever invoked, and routes suspicious flows over zero-copy AF_XDP rings to a multi-core C++20 userspace engine for deep packet inspection.

View source on GitHubEngineering benchmarks
License
GPL (eBPF program)
Language
C++20 · eBPF
Status
Open source · alpha
Target Audience

Who is this for?

Built specifically for systems teams where generic abstraction layers cost too much CPU time and introduce unacceptable tail latency.

✓

Infrastructure and site-reliability engineers defending Linux servers against volumetric L3/L4 DDoS attacks.

✓

High-frequency trading and gaming infrastructure where Linux kernel firewall processing latency (iptables) is intolerable.

✓

Teams that need deep pattern matching (Suricata/Snort/OWASP rules) at multi-gigabit line rates on commodity hardware.

The Engineering Problem

What problem does it solve?

Prevents Linux kernel network stack saturation during multi-gigabit packet floods.

Standard Linux iptables or nftables process packets only after socket buffers (sk_buff) are allocated, which causes high CPU utilization and memory starvation during 10Mpps+ floods. Aethon attaches directly to the NIC driver via eXpress Data Path (XDP), dropping volumetric floods in 15 nanoseconds without memory allocation.

Architecture Benchmark

Why choose Aethon instead of existing alternatives?

How Aethon compares with standard Linux approaches on latency, safety, and operational overhead.

Approach / TechnologyVerdictTrade-off & Limitation
Linux iptables / nftablesHigh Stack OverheadAllocates full sk_buff per packet; connection tracking chokes under volumetric SYN/UDP floods.
DPDK Dedicated AppliancesHardware InflexibleRequires dedicated NICs, claims 100% of CPU cores on spin-locks, bypassing the OS completely.
Snort / Suricata (Standard)Userspace Copy PenaltyRelies on libpcap/AF_PACKET packet copies, limiting deep inspection to sub-line-rate throughput.
Aethon (AlgoMesh)Kernel-Bypass eBPF/XDPDrops volumetric attacks in driver ring; zero-copy AF_XDP to multi-threaded Hyperscan DPI engine.

Key Capabilities

Kernel-Space Driver RX Hook

eBPF/XDP bytecode executes at the network interface driver level to drop volumetric floods before memory allocation.

Zero-Copy AF_XDP UMEM Rings

Hands off packets requiring deep inspection to userspace worker threads pinned to CPU cores using direct memory buffers.

Multi-Pattern Hyperscan DPI

Compiles Emerging Threats and OWASP regex rule databases to scan packet payloads at wire speed across parallel streams.

Stateful TCP Reassembly

Tracks out-of-order segments and fragmented UDP packets to reconstruct raw payloads before pattern evaluation.

Get started

Try it in a network namespace

sudo apt-get install libbpf-dev libxdp-dev libhyperscan-dev libssl-dev clang llvm
./veth0.bash            # creates veth0 <-> client_ns test network
./build.sh --release
sudo ./build/src/afxdp_control veth0

On the roadmap

What is planned next. Follow progress on GitHub.

  • Flow bypass: inspect once, then pass clean flows at line rate
  • Hyperscan streaming mode across TCP segments
  • Native-mode zero-copy AF_XDP and a hard memory budget