ProxyT1190

Protect an app before the patch lands

When a flaw in your stack is being exploited and the fix is not deployed, because the vendor has not shipped it or you cannot roll it out this week, move the boundary in front of the app. Put Synapse in proxy mode in front of the unchanged app, write a WAF rule for the exact request shape that reaches the flaw, order your exceptions above it, and make the proxy the only way in.

Mean time to exploit, M-Trends 2026−7 days

Mandiant estimates that the mean time to exploit vulnerabilities has dropped to about −7 days, “meaning exploitation is routinely occurring before a patch is even released.” Exploits were the most common way in for the sixth year running, at 32% of intrusions. Patching fast still matters; it just no longer comes first.

Source: Mandiant, M-Trends 2026

Overview

Exploitation now routinely starts before a patch exists, and a patch that does exist still has to be tested and rolled out. For that stretch, every application is one you cannot change. For some it never ends: a vendor appliance, an unmaintained internal service, something under a change freeze.

In proxy mode Synapse terminates TLS, applies policy and forwards to the unchanged application over its existing port. The application needs no modification and does not need to know it is behind anything.

When you see this

  1. Exploitation is reported against a product or library you run, and there is no patch yet.
  2. A patch exists, but testing and rolling it out will take days or weeks.
  3. The application cannot be patched, redeployed or given a new library at all.

Steps

  1. 01

    Put Synapse in front

    Upstreams live in a separate file that reloads without a restart. On Kubernetes the same thing is driven from Ingress objects.

    /etc/synapse/config.yaml
    mode: "proxy"
    
    proxy:
      address_http: "0.0.0.0:80"
      address_tls: "0.0.0.0:443"
      upstream:
        conf: "/etc/synapse/upstreams.yaml"
  2. 02

    Write the virtual patch

    Block the exact request shape that reaches the vulnerability and leave everything else alone. Rules are checked when they load, rather than failing open at runtime.

    WAF rule, action block
    http.request.method == "POST" and starts_with(http.request.path, "/admin")
    DecisionWas the app reachable while the flaw was already being exploited?

    Yes The rule protects you from now on, not before. Treat the host as suspect until you know otherwise: follow the contain a compromised host playbook.

    No Carry on.

  3. 03

    Put exceptions above the block

    Evaluation stops at the first matching rule. An allow placed below a broad block never runs.

    WAF rule, action allow, placed above the block
    ip.src in {192.0.2.0/24}
    DecisionDo trusted callers still need the patched path?

    Yes Add an allow for them and move it above the block.

    No Keep the block alone.

  4. 04

    Make the proxy the only path in

    Anything that reaches the application by another route, such as a second interface, an internal caller or a management port, bypasses every rule. Close those with firewall rules.

  5. 05

    Ship the real fix

    A WAF rule is a shape, not a fix: it blocks the exploit you described, and a variant that reaches the same bug differently gets through. Use the time it buys to test and deploy the patch, then retire the rule.

Common mistakes

  1. Placing an allow rule below the block it was meant to escape.
  2. Leaving a second route to the application open.
  3. Treating the virtual patch as permanent.

Escalate when

  • Requests that match the patched shape from an address inside your network.

Where this stops working

  • Only traffic through the proxy is protected.
  • Terminating TLS means holding certificates. With passthrough instead, the WAF and content scanning have nothing to read.
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 Set ip.src to 192.0.2.10, the office. The allow rule is below the block, so it never runs: move it up.

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 Refused with 403
ResultRefused with 403Proxy · WAF
  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.200 (NL, AS64503) 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 3, 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 nftablesNot used

    No smart firewall rules in this policy.

  8. 08WAF rulesProxy · In the proxy, after decryptionRefused

    Refused with 403. The application never sees the request.

    Matched
    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": "waf",
  "action": "block",
  "source": "waf",
  "rule_id": "w7",
  "src_ip": "198.51.100.200",
  "src_port": 54321,
  "dst_ip": "198.51.100.10",
  "dst_port": 443,
  "src_country": "NL",
  "fingerprints": {
    "ja4t": "64240_2-4-8-1-3_1460_10",
    "ja4": "t13d1516h2_8daaf6152771_02713d6af862"
  }
}

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.