Agent or proxyT1498.001

Absorb a volumetric attack

When a flood arrives faster than the host can refuse it, drop known sources at the XDP hook, before the kernel allocates anything for them. Make sure the threat feed is installed, confirm the firewall really runs in XDP mode, check what the kernel holds, and hand layer 7 floods to the proxy.

Overview

The problem is rarely that the traffic is hard to identify. It is that identifying it at all costs more than you have left, because by the time a userspace process sees a packet the kernel has already allocated for it.

Access rules are enforced by Hillock at the XDP hook, which runs in the driver before routing and before a socket buffer exists. That is the cheapest drop a Linux host can perform, and it answers one question only: is this source allowed to talk to me at all.

When you see this

  1. The host saturates before the application has refused anything.
  2. Most of the flood comes from sources that repeat, or that threat intelligence already lists.
  3. The packets are trivial to identify; processing them is what you cannot afford.

Steps

  1. 01

    Install the threat feed and let the firewall pick its backend

    Threat detection distributes known-bad sources as a database the agent installs into kernel maps. ASN and country are resolved on the platform side and arrive already expanded, so the datapath never does a lookup.

    /etc/synapse/config.yaml
    firewall:
      mode: "auto"        # auto, xdp, nftables, iptables, none
    
    platform:
      threat:
        enabled: true
  2. 02

    Check which backend is actually enforcing

    auto picks XDP where the kernel supports it and falls back to nftables, then iptables. The rule you wrote does not change, only the machinery under it.

    DecisionIs the host running XDP?

    Yes Drops happen in the driver, before routing. Carry on.

    No XDP needs a driver that supports it and a kernel with BTF. nftables and iptables still drop early, but not at driver level: plan for a supported NIC and kernel.

  3. 03

    See what the kernel holds

    When a rule appears not to work, check what is really loaded. The flag reads the pinned maps and exits; it needs root and does not need Synapse running.

    Rules the kernel is enforcing
    sudo synapse --show-firewall-rules json
  4. 04

    Add the sources the feed does not know

    Put repeat sources on an access rule: an address or CIDR, an ASN or a country. They land in the same kernel maps as the feed.

  5. 05

    Separate a layer 7 flood

    A slow flood of well-formed requests from unremarkable addresses passes XDP untouched. That one has to be handled at the proxy, by fingerprint and rate.

    DecisionAre the packets well-formed requests from addresses nobody has flagged?

    Yes Treat it as a bot problem: follow the bots and credential stuffing playbook.

    No It is a volumetric flood. Keep it at the access rules.

Common mistakes

  1. Expecting an address list to stop a distributed attack from addresses you have never seen.
  2. Assuming XDP when the host has fallen back to nftables or iptables.
  3. Restarting the agent in the middle of an attack: the XDP link is pinned and re-attachment is not instantaneous.

Escalate when

  • The flood is genuinely novel and larger than the link: that needs upstream capacity, not a host rule.

Where this stops working

  • An address list cannot stop a distributed attack from addresses you have never seen. It absorbs known-bad and repeat sources cheaply.
  • Layer 7 floods look like valid traffic here and have to be handled at the proxy.
Run it here

Send the request. Watch where it stops.

Edit the request or any rule and the pipeline runs again. The rules are real wirefilter expressions, evaluated the way the agent evaluates them; the traffic and model scores are samples. It all runs in your browser.

Try this Turn off the threat-feed entry: the flood reaches the host, and nothing behind it is cheaper.

The request

ingress · agent mode

Every value is a rule field. Change one and the pipeline re-runs.

Connection
Source, resolved by the platform
Fingerprints, from Dendrite
Model scores, sample output from Cortex
Flow behaviour, per source
Payload, what Thalamus inspects
Result Dropped at the XDP hook
ResultDropped at the XDP hookHillock · access rules
  1. 01Capture and fingerprintDendrite · On the wireObserved

    Computed JA4T for this connection. Capture only: Dendrite never blocks.

  2. 02Access rulesHillock · XDP hook, before routingDropped

    203.0.113.77 matches 203.0.113.0/24. Dropped in the driver, before routing and before a socket buffer exists.

    From the threat feed: known-bad sourcesMatched
    Country, resolved to IP ranges on the platform sideNo match
  3. 03Firewall rulesHillock · TC hook, in the kernelNot reached

    No firewall rules in this policy.

  4. 04Intrusion detectionThalamus · On the hostNot reached

    No signatures loaded for this scenario.

  5. 05Behavioural modelsCortex · On the host CPUNot reached

    Sample scores, 0 to 100: C2 2, scan 66, malicious flow 90. Nothing leaves the machine to be scored.

  6. 06Service graphHippocampus · On the hostNot reached

    No workload identity on this flow.

  7. 07Smart firewall rulesAmygdala · Decided on the host, enforced in nftablesNot reached

    No smart firewall rules in this policy.

  8. 08WAF rulesProxy · In the proxy, after decryptionNot reached

    Agent mode does no HTTP proxying, so there is no request for the WAF to read.

  9. 09Content scanningProxy · ClamAV, before forwardingNot reached

    No WAF rule selected this request for scanning, so nothing was scanned.

Field names and operators follow the docs: WAF and Smart Firewall. A rule that names an unknown field does not load; a field the request does not carry never matches.

What lands in the event log
{
  "ts": "2026-11-17T09:41:07.212Z",
  "layer": "access_rules",
  "action": "drop",
  "source": "threat_intel",
  "rule_msg": "From the threat feed: known-bad sources",
  "src_ip": "203.0.113.77",
  "src_port": 54321,
  "dst_ip": "198.51.100.10",
  "dst_port": 53,
  "src_country": "US",
  "fingerprints": {
    "ja4t": "64240_2-4-8-1-3_1460_10"
  }
}

Shaped like the documented event schema; the timestamp, ports, rule ids and ban duration are illustrative.

Now on your own traffic.

A demo runs the same pipeline against real packets, with the engineers who built it.