Written by

Threatmatic

At

Mon Oct 05 2026

The Four Gates and the Watchtower: EdgeGuard's Flood Defense, End to End

A flood doesn't attack one moment in a connection's life — it attacks whichever moment is weakest. EdgeGuard now defends all four, plus the one thing none of them alone can see.

Back

A connection has a whole life. Most defenses only guard one moment of it.


A SYN flood is a half-open-connection problem. A reflection attack is a bandwidth problem. A botnet with two hundred machines, each opening a perfectly normal connection and sending at a perfectly reasonable rate, is neither — and it's the one that gets through defenses built for the other two. EdgeGuard's answer wasn't to pick the right single mechanism. It was to stop treating a connection's life as one moment, and defend all four it actually passes through — plus the one vantage point that watches all four at once.

Three-panel comic. 200 bots each pass every per-source check individually. Bundled together they strain the origin anyway. A watchtower figure on a rooftop notices the service's total traffic has broken its baseline and tightens the gates.

Four moments, four different defenses

Every connection EdgeGuard's gateway handles passes through the same four moments, and each one calls for a mechanism built for it specifically — not one generic rule stretched to cover all four.

Before the handshake. A connection that was never going to behave doesn't always bother completing one. Known attack tooling leaves fingerprints in its very first packet — options a real OS stack would never send, a source port no legitimate client would pick. EdgeGuard checks for these in the kernel's own fast packet-processing path, before the operating system commits a single byte of memory to the connection.

While it's half-open. A flood of real-looking SYNs that never finish the handshake is trying to exhaust the gateway's own backlog — memory reserved for connections that haven't proven they're real yet. SYN cookies solve this at the protocol level: the gateway hands back a cryptographically verifiable cookie instead of allocating state, so a flood of fake handshakes costs it nothing to absorb.

Once it's established. A connection that completed a real handshake can still be attacked — an off-path adversary trying to inject a forged reset or forged data into a session they're not actually part of. Challenge ACK (RFC 5961) makes that blind: before accepting a sequence-number guess, the gateway challenges it, so a real participant answers correctly and a blind attacker doesn't.

Once it's running. A connection can be completely legitimate in every way that matters above and still be abusive in volume — far more packets, or far more bytes, than any real client sends. A per-source ceiling on an established connection catches this, using the same connection-tracking the kernel already maintains for free.

The gap distributed floods find anyway

Every one of those four is a per-source decision — judging the one connection, or the one source IP, in front of it. That's exactly right for a single attacker hammering one target. It's exactly the wrong granularity for two hundred bots, each individually unremarkable, each comfortably under every ceiling above — and all two hundred hitting the same service at once. No single gate was ever built to see the sum of everything that passed through it. That's a structural gap, not a tuning problem — tightening any one gate's threshold either misses a distributed flood entirely or starts punishing real customers long before it catches one.

The watchtower

Closing that gap means watching a different thing: not any one connection, but the service's own traffic shape as a whole, over time. EdgeGuard's detector does this by comparing a service's current packet rate and connection-arrival pattern against its own recent history — an exponentially-weighted baseline it updates continuously, with no database round-trip on the decision path.

Run against real traffic on a test gateway, a steady baseline around 30 packets per second — with connections arriving in a smooth, regular rhythm — spiked to 403 packets per second with a visibly erratic arrival pattern the moment a burst started. The detector's deviation score crossed 2,076 against a flagging threshold of 3. That's not a close call, and it didn't require knowing anything about where the 200 connections came from — only that the service's shape had broken.

What happens when it flags something

A detector that watches the whole service, by design, can't point at which source caused it — unlike the four gates above, it never had source-level identity to begin with. So the response works at the same level it detects: by default, it logs and alerts, a person decides what's next. The opt-in escalation tightens the existing per-source ceilings — specifically for the one flagged service, for a bounded window, then reverts automatically. It can't surgically remove the 200 bots. It doesn't need to: squeezing every source hitting that one service drops the flood's aggregate throughput without touching anything else running through the same gateway.

What's next

The mechanism above has been run end to end against real traffic, by hand. What's left is making it run on its own: a scheduler that keeps the watchtower observing continuously instead of once, and a second comparison — not a service against its own past, but one gateway against its siblings serving the same service elsewhere. That catches something the self-comparison structurally can't: a gateway whose own baseline has quietly drifted to accept an attack that started slowly enough to never look like a spike to itself.


Four real moments in a connection's life, each with its own defense that's actually built for it — and one watchtower that sees what none of the four, alone, ever could.