Agent or proxy

Investigate one connection

When you need to know what one client is, ask the agent that saw it. The terminal view shows fingerprints and decisions as they happen; EventBridge answers a direct question about one connection, with its JA4+ fingerprints, SNI, ALPN and TLS version; the event log says what every layer decided about that address.

Overview

Logs tell you what happened. During an incident the question is usually narrower: what is this client, and what did we do about it. The agent already captured the answer, one local socket away.

EventBridge is that socket: a control socket for request and response queries about a connection, and an event socket that streams fingerprints as they arrive. Both are local only, with no network listener to secure.

When you see this

  1. An alert names an address and you need to know what client is behind it.
  2. Your application wants the client's TLS fingerprint, SNI or ALPN, which it cannot see itself.
  3. A deployment needs a quick check that the agent is seeing traffic.

Steps

  1. 01

    Attach the live view

    Standalone mode attaches a viewer to the running agent over a local socket and detaches again, leaving the agent untouched.

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

    Open the sockets

    Both sockets are off until you give them a path. Restart after setting them. On Windows they are loopback TCP instead: 127.0.0.1:19198 for control and 127.0.0.1:19199 for events.

    /etc/synapse/config.yaml
    daemon:
      control_socket: "/var/run/synapse-control.sock"
      event_socket: "/var/run/synapse-events.sock"
  3. 03

    Ask about one connection

    src_ip and src_port are required; narrow with dst_ip, dst_port, ja4 or ja4t. Only fields actually captured appear. A connection the cache has evicted returns 404 with status not_found.

    EventBridge query
    curl --unix-socket /var/run/synapse-control.sock \
      -X POST http://localhost/query \
      -H 'Content-Type: application/json' \
      -d '{"src_ip":"203.0.113.42","src_port":54321}'
  4. 04

    Behind CGNAT, ask by address

    Set aggregate and drop src_port to get every connection seen under that address. Combine it with expect_ja4_prefix to keep only one fingerprint family.

    EventBridge query
    curl --unix-socket /var/run/synapse-control.sock \
      -X POST http://localhost/query \
      -H 'Content-Type: application/json' \
      -d '{"src_ip":"203.0.113.42","aggregate":true}'
  5. 05

    See what every layer decided

    The event log has one record per decision, from every layer, in the same shape.

    One address, across every layer
    jq -c 'select(.src_ip == "203.0.113.42")' /var/log/synapse/events.log
  6. 06

    Watch the stream

    The event socket needs no handshake: connect, and events arrive as newline-delimited JSON. Packet events carry connection fingerprints; Http events need the proxy to have parsed a request.

    Live fingerprints
    socat -u UNIX-CONNECT:/var/run/synapse-events.sock - \
      | jq -c 'select(.type == "Packet") | {src_ip, ja4, sni}'

Common mistakes

  1. Expecting history. The cache is bounded and recent; use the event export for anything retrospective.
  2. Querying one port behind CGNAT, where many clients share the address. Use aggregate.
  3. Treating the terminal view as monitoring. Nobody is watching a terminal at 3am.

Escalate when

  • The connection carries a fingerprint a rule or the classifier already flagged.
  • The SNI the client asked for does not match the host it reached.

Where this stops working

  • Local only, by design: anything off-host goes through the export path.
  • Answers are best-effort. A field is absent rather than wrong when a view was never captured.
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 This bot is dropped by its fingerprint. Under the pipeline, the event panel shows the record that decision writes. EventBridge answers the same question about one live connection.

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.