Agent or proxyT1046

Turn detections into kernel blocks

When a client is known by how it behaves rather than where it comes from, write the rule over fingerprints, flow shape, model verdicts and IDS context. Prove it in log mode, put your exceptions above it, and promote it to drop. The block lands in the kernel, scoped to an address or to the fingerprint itself.

Overview

Access rules know addresses. The WAF knows requests, and only in proxy mode. Between them sits everything else Synapse knows about a client: its fingerprints, how its flows behave, and what the models and the IDS concluded.

The smart firewall is a wirefilter rule engine over all of it, evaluated by Amygdala on every agent. A match installs a block in the kernel, so enforcement costs a map lookup rather than a request.

When you see this

  1. A scanner or tool keeps changing its address.
  2. One source touches many ports or hosts in a short time.
  3. A detection should become a block automatically, without a ticket.

Steps

  1. 01

    Pick the fields

    The scheme carries 87 fields, all optional: fingerprints, flow behaviour, ML verdicts, IDS context, threat intelligence and Kubernetes identity. A rule that names a field nothing populates never matches, which is the usual reason a rule seems to do nothing.

  2. 02

    Write the rule in log mode

    A log rule records what it would have done and enforces nothing, so you can prove it on live traffic first.

    Smart firewall rule, action log
    flow.unique_dst_ports ge 25 and flow.flows_per_min ge 100
  3. 03

    Choose what a drop blocks

    IP scope blocks the source address. IP and source port blocks that pair. Fingerprint scope blocks every connection presenting the fingerprint, whatever its address.

    DecisionDo legitimate clients share the fingerprint?

    Yes Scope the drop to the address, or combine the fingerprint with an address condition.

    No Fingerprint scope follows the tool across every address it uses.

  4. 04

    Put your exceptions above it

    The first matching rule wins, and if no rule matches the traffic is allowed. An allow placed below a broad drop never runs.

    Smart firewall rule, action allow, placed above
    ip.src in {192.0.2.50/32}
  5. 05

    Promote it, then check the log

    Switch the action to drop. Blocks carry a TTL and are swept when it expires, so a source seen once does not stay in a kernel map for ever. An expression that does not parse is skipped with a log line, not rejected, so check the agent log after shipping a rule.

  6. 06

    Automate it

    A SOAR playbook or your own automation can add a rule through the Signal API. The expression is validated when it arrives, and every agent receives the rule from the platform.

    Signal API v2
    curl -X POST https://api.gen0sec.com/v2/signal \
      -H "Authorization: Bearer $GEN0SEC_API_KEY" \
      -H "Content-Type: application/json" \
      -d '[{"schema_version":2,"kind":"smart_firewall_rule","op":"upsert",
           "rule_ref":"sweep-198-51-100-66","expires_in":86400,
           "reason":"Port sweep","rule":{"name":"Port sweep","type":"custom",
           "expression":"ip.src in 198.51.100.66/32","action":"block"}}]'

Common mistakes

  1. Placing an allow below the drop it was meant to escape.
  2. Reading ids.severity as a magnitude. 1 is the most severe; prefer ids.score, where higher is worse.
  3. Dropping a common browser fingerprint at fingerprint scope, which blocks everyone on that browser.

Escalate when

  • A rule that would block addresses in your own ranges.
  • The same fingerprint dropped on many agents at once.

Where this stops working

  • Only a ja4t rule stops the first connection. For every other match the first connection completes, and the source is blocked from then on.
  • Rules come from the platform: an agent that cannot reach it keeps the ruleset it last received.
  • Invalid expressions fail quietly, with a log line on the agent.
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 Switch the scan rule from log to drop. Then set ip.src to 192.0.2.50, your own scanner: the allow above the scan rule wins.

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 Delivered to the application
ResultDelivered to the applicationAllowed, with findings · Logged by Amygdala
  1. 01Capture and fingerprintDendrite · On the wireObserved

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

  2. 02Access rulesHillock · XDP hook, before routingPassed

    198.51.100.66 (NL, AS64502) is on no access list.

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

    No firewall rules in this policy.

  4. 04Intrusion detectionThalamus · On the hostNot used

    No signatures loaded for this scenario.

  5. 05Behavioural modelsCortex · On the host CPUObserved

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

  6. 06Service graphHippocampus · On the hostNot used

    No workload identity on this flow.

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

    Matched a log rule: recorded what it would have done, enforced nothing.

    No match
    Matched
  8. 08WAF rulesProxy · In the proxy, after decryptionNot used

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

  9. 09Content scanningProxy · ClamAV, before forwardingNot used

    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": "smart_firewall",
  "action": "log",
  "source": "behavioral",
  "signals": [
    "behavioral"
  ],
  "rule_id": "s22",
  "src_ip": "198.51.100.66",
  "src_port": 54321,
  "dst_ip": "198.51.100.10",
  "dst_port": 3389,
  "src_country": "NL",
  "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.