What to do when it actually happens.
Step-by-step playbooks for the attacks Gen0Sec is built to stop. Each one opens with the answer, walks through the steps with the rules and commands to use, says where the approach stops working, and ends in a lab where you run it: change the request or the rules and watch where it stops.
- Playbooks
- 16
- Steps
- 86
- Rules, configs and commands
- 64
Every step is in the docs. The playbooks follow the use cases and feature pages on docs.gen0sec.com, so the rule you copy here is the rule the agent loads, and the limits are the ones the docs admit to. Where a playbook goes beyond the docs, it says so.
Detection and response (4)
Act on a model verdict
When you want to catch what no signature or feed knows, turn on Cortex's models, watch what they flag, and act only when a model and a second signal agree. The probabilities are uncalibrated, so set your own threshold, and read the model card before a verdict decides a block.
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.
Detect known exploits with Suricata rules
When the security community already has a signature for an attack, run it on the host. Thalamus loads Suricata-compatible rules unchanged, across thirty-plus protocols. Tell it what your network is, read the alerts as EVE JSON, and decide what a hit does: alert only, ban the source with ids.enforce_block, or act on it in a smart firewall rule.
Block what the fleet already saw
When an address one of your agents banned reaches another, let the fleet's evidence count. Each agent reports what it blocked; the platform corroborates across the deployment, and every agent pulls the set back. Run it advisory first, read the numbers, then enforce where they hold up.
Bots and abuse (2)
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.
Rate limit an endpoint, not a user
When an endpoint is legitimate but a client calls it too often, rate limit it rather than block it. A WAF rule with the rate_limit action counts per rule and per client address, allows requests up to a threshold, then answers 429 for a penalty you choose. Behind a load balancer, set trusted proxies first, or the counter keys on the balancer.
Applications (4)
Block malware in uploads
When users upload files into your service, scan what they send before it reaches storage or a worker. Arm ClamAV, aim it with a WAF rule at the upload paths only, decide what happens to files you cannot scan, and alert when the scanner fails, because it fails open.
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.
Compile rules from your own code
When hand-written rules no longer match what the application serves, take the rules from the application itself. Microglia reads its routes, parameter types, auth boundaries and egress, and compiles positive WAF, IDS and firewall rules from them. Review the surface, put your exceptions above the compiled rules, and let the rules ship with the code.
Protect Kubernetes services at the ingress
When your services already sit behind Ingress objects, make Synapse the ingress controller. The operator turns Ingress and Gateway API resources into Synapse's routes and hot-reloads them; the smart firewall, WAF and IDS then run on the same path as every route, with no sidecar and no second hop.
Inside the network (3)
Detect lateral movement
When an intruder is already inside, the traffic that matters is one workload reaching another. Give the flows names with the operator's identity producer, compile your NetworkPolicy into declared conversations, and review what was observed but never declared. Then declare it, or contain it.
Contain a compromised host
When you no longer trust a host, cut its outbound paths instead of pulling the cable. Allow only what the investigation needs, deny all other egress below those exceptions, keep watching what the host tries to reach, and block by SNI through Amygdala where a port is not specific enough.
Find hosts that beacon
When malware calls home, it tends to call on a schedule. Thalamus can write one beacon record per source and destination pair that reconnects at a regular interval. The record is telemetry, with no score, alert or ban: confirm it with a second signal, and contain the host if it holds up.
Investigation and visibility (2)
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.
Ship every decision to your SIEM
When your SOC works in a SIEM, send it Synapse's decisions in a format it already parses. Every layer emits one event model, so a single record says who enforced, what was done and what decided. Ship block events as CEF or JSON Lines, add IDS alerts, and decide about access logs deliberately, because they are billed by volume.
Read it, then run it.
Every playbook ends in a lab: the same request, the same rules, evaluated in your browser. A demo does it on your own traffic.