Proxy for the WAF; fingerprints in both modesT1110.004

Stop bots and credential stuffing

When a login form takes well-formed requests from rotating addresses that all claim to be a browser, identify the client by how it connects, not by what it says. Find the JA4+ fingerprint the requests share, check it with the classifier, then act on the fingerprint: rate limit or challenge the login path at the WAF, and drop the fingerprint in the kernel only when no real user shares it.

Overview

Someone is driving your login form with a script. The requests are well-formed, the user agent says Chrome, and the addresses rotate through a residential proxy pool, so rate limiting alone either misses them or starts catching real users.

Every field a bot controls, it lies about. What it cannot easily change is how its TLS and TCP stack behaves, and that is what Synapse matches on: the fingerprint travels with the client, not with its address.

When you see this

  1. Failed logins climb while each source address sends only a handful of requests.
  2. The User-Agent names a browser, but the TLS or TCP fingerprint is not that browser's.
  3. One JA4 fingerprint shows up across many unrelated source addresses.
  4. A rate limit either never triggers or starts limiting real users.

Steps

  1. 01

    Watch who is connecting

    Attach the terminal view to the running agent and send yourself a normal login first, so you know what a real browser looks like. Then watch the attack traffic arrive next to it.

    Attach to the running daemon
    synapse --terminal
  2. 02

    Find the fingerprint the requests share

    Behind address rotation or CGNAT, ask the agent about an address as a whole: aggregate returns every connection it saw from that address, with its fingerprints. Compare the JA4 across a few attacking addresses.

    EventBridge: everything seen from one address
    curl --unix-socket /var/run/synapse-control.sock \
      -X POST http://localhost/query \
      -H 'Content-Type: application/json' \
      -d '{"src_ip":"198.51.100.23","aggregate":true}'
    Every layer that touched one address
    jq -c 'select(.src_ip == "198.51.100.23")' /var/log/synapse/events.log
  3. 03

    Ask the classifier

    The fingerprint classifier answers whether a client's JA4+ fingerprint is malicious, with a probability. It needs an -ml build. Read the model card before you wire its output straight to a block.

    /etc/synapse/config.yaml
    mode: "proxy"
    
    ml:
      fingerprint_classifier:
        enabled: true
    DecisionIs the fingerprint shared by a real browser build your users run?

    Yes Do not block it: you would block everyone on that browser. Rate limit or challenge at the WAF instead.

    No It belongs to the tool. Block it by fingerprint in the next steps, whatever address it arrives from.

  4. 04

    Slow the login path at the WAF

    A credential-stuffing rule usually wants rate_limit rather than block: the login endpoint is legitimate, it is the rate that is not. Counters are per rule and per client address: requests allowed per period, then duration seconds of 429. Where you are unsure, challenge with a CAPTCHA.

    WAF rule, action rate_limit or challenge
    http.request.path == "/login" and threat.score > 30
    WAF rule for sources the feed already condemns
    threat.score > 80 and threat.advice == "block"
  5. 05

    Drop the tool by its fingerprint

    A smart firewall rule on the fingerprint installs a kernel block, so a scanner that changes address every request is still stopped by the thing that does not change. Start the rule with the log action to prove it on live traffic, then switch it to drop with fingerprint scope.

    Smart firewall rule, log first, then drop
    ja4 == "t13d190900_9dc949149365_97f8aa674fd9"
  6. 06

    Confirm it took effect

    Watch the drops arrive rather than waiting for a pipeline to confirm them.

    Everything dropped, newest first
    jq -c 'select(.action == "drop") | {ts, layer, source, src_ip, rule_msg}' \
      /var/log/synapse/events.log | tail -20

Common mistakes

  1. Blocking a fingerprint that real browsers share. A fingerprint is not an identity: every user of a browser build has the same one.
  2. Blocking a shared egress address. A CGNAT or corporate NAT address is many people; prefer the fingerprint or a combination of signals.
  3. Relying on rate limits behind a load balancer without setting proxy.trusted_proxies: the bucket keys on the L4 peer, which is the balancer.
  4. Sending the classifier's score straight to a drop before reading what it was measured at.

Escalate when

  • Any account that logged in successfully from the attacking fingerprint.
  • Attempts against privileged or service accounts.

Where this stops working

  • A determined adversary can mimic a fingerprint. This raises the cost of automation; it does not make it impossible.
  • The agent sees less than the proxy: without terminating TLS you get the client-side fingerprints but not the request, so no WAF and no CAPTCHA.
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 Change ip.src to any other address: the fingerprint block still applies. Then set ja4 to the browser value, and the next layer, the WAF, challenges the login instead.

The request

ingress · proxy mode

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

Connection
Source, resolved by the platform
Fingerprints, from Dendrite
HTTP, readable in proxy mode
Model scores, sample output from Cortex
Flow behaviour, per source
Payload, what Thalamus inspects
Result Dropped by a smart firewall rule
ResultDropped by a smart firewall ruleAmygdala · enforced in the kernel
  1. 01Capture and fingerprintDendrite · On the wireObserved

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

  2. 02Access rulesHillock · XDP hook, before routingPassed

    198.51.100.23 (NL, AS64501) 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 81, malicious flow 77. 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 nftablesDropped

    Dropped, and a persistent block installed on the fingerprint: every connection presenting it is stopped, whatever its address.

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

    No rule matched.

    Not reached
    Not reached
  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": "smart_firewall",
  "action": "drop",
  "source": "fingerprint_rule",
  "signals": [
    "fingerprint_rule"
  ],
  "rule_id": "s3",
  "ban_secs": 3600,
  "src_ip": "198.51.100.23",
  "src_port": 54321,
  "dst_ip": "198.51.100.10",
  "dst_port": 443,
  "src_country": "NL",
  "fingerprints": {
    "ja4t": "65535_2-4-8-1-3_1460_8",
    "ja4": "t13d190900_9dc949149365_97f8aa674fd9"
  }
}

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.