Valentine’s Day DDoS: The “Gift” That Tried to Take digi77.com Down
February 14, 2026 — Battle-Tested Defense Against Subnet-Rotating Botnets
On February 14, 2026, it looked like someone wanted to give me a Valentine’s gift.
They did — just not the kind you want.
Early that morning, my digi77.com server got slammed with a DDoS that wasn’t the usual “a thousand infected PCs from all over the world.”
I’m talking about entire subnets showing up like waves.
The timing was also… interesting. It happened two days after I announced that Kodachi supports built-in AI capabilities. Coincidence or not, the goal was clearly to knock the server offline.
What made it worse is that this wasn’t “obviously bad” traffic. A lot of it looked valid:
- normal TCP handshakes
- valid packets
- normal-looking HTTP behavior (just at insane volume)
That’s exactly why CSF struggled. Not because CSF is “bad,” but because when the flood is made of normal-looking traffic, it’s harder to separate signal from noise fast enough. And once your server is chewing through endless valid connections, your CPU and connection tracking become the target.
My CPU hit 100% and stayed there. Services started choking.
So I did what I always do when the internet doesn’t have the tool I need:
I wrote my own Bash solution.
And guess what?
It worked.
It blocked 100% of the waves I observed during the incident — thousands at a time. Then thousands more would appear from a different region, and the script just kept handling it. I’m still under attack while writing this post, which is exactly why I’m writing it.
Why This Matters (And Why “Just Block It Upstream” Isn’t Always Simple)
I searched for tools and guides that can handle this kind of attack pattern the way I needed it handled.
I could not find a tool on the net that does this
— especially not something that:
- reacts in real time,
- escalates from IPs to subnets automatically,
- survives massive rotation,
- and keeps the server usable while under pressure.
I even asked GPT for advice, and the response (paraphrased) was basically:
- “If packets reach Linux, there isn’t much you can do about it.”
- “It must be blocked at the provider level.”
- “And if the packets are legitimate, how will you block them upstream?”
That’s not wrong in a scenario where the attacker saturates your uplink before the traffic even reaches you.
But many real-world attacks (including what I saw) aren’t only about filling bandwidth — they’re about melting your CPU, exhausting conntrack, draining worker threads, and keeping you too busy to respond.
So I built a script with a single job:
Keep the server online during a rotating subnet DDoS — automatically.
Key Features (What the Script Does)
- Subnet-level blocking (CIDR escalation)
Stops “whack-a-mole” IP rotation by promoting bans from single IPs to/24,/20, or other ranges when subnet abuse is detected. - Real-time offender ranking
Continuously detects top talkers (by connections and/or request sources) and reacts within seconds. - Built for “legit packet” floods
Works when packets are valid and classic “bad packet” filtering fails — because the attack looks normal until you measure volume and patterns. - Load-aware defense mode
Tightens thresholds automatically when CPU/load spikes, prioritizing uptime over perfect analytics. - Fast firewall application strategy
Blocks in a way that avoids firewall self-DoS (batched updates and efficient rule structures). - Rotation-resistant logic
Handles attackers constantly swapping regions, ranges, and subnets — blocks thousands, then blocks thousands more without manual babysitting. - Whitelist & safety rails
Protects admin IPs, monitoring, and trusted services from accidental lockouts. - Attack intelligence output
Reveals what the attacker is doing: burst timing, concentration by range, and how sources shift over time. - Rule hygiene (cleanup/expiry)
Avoids infinite rule growth by expiring or rotating temporary blocks safely. - “Stay online” priority
The main goal is not pretty graphs — it’s keeping your machine responsive while the storm is happening.
How It Works (High-Level, With Safe Snippets)
I’m not publishing the full script here, but I can share safe snippets that explain the approach without exposing the private logic that makes it effective.
1) Watch system pressure (load + connection counts)
When the numbers spike beyond safe thresholds, the script shifts into aggressive mitigation mode.
2) Identify abusive sources by volume
3) Escalate from IP blocking to subnet blocking
4) Apply blocks efficiently (repeat offender tracking)
5) Keep the ruleset clean while the attack evolves
Live Attack Intelligence (from this incident)
The script’s repeat-offender tracker produced this data during the active attack:
495
Total Blocked
195
Permanent Bans
47
Countries
134
Providers
The dominant provider across France and Germany: Contabo — accounting for 56.9% of all block hits across 221 IPs. A single hosting provider used as a botnet launchpad.
Escalation stats: 60.6% of entries are still temporary (below 3x threshold) — 39.3% were promoted to permanent blocks after repeated offenses. GeoIP enrichment resolved 480 of 495 entries across 47 countries and 134 providers.
Quick Start (When You Have the Script)
The script supports comprehensive command categories for monitoring, blocking, and automating DDoS defense. Here’s everything you can do:
Diagnostics & Monitoring
Banning (nftables)
CSF Blocking (temp-first strategy)
Repeat Offender Tracking
Cron Automation
Setup
Parameter Reference
Operational tips:
- Run it in
screenortmux - Make sure you have fallback access (console, IPMI, alternate admin route)
- Configure whitelist before enabling aggressive blocking
- Pair with upstream/CDN mitigation when possible (best of both worlds)
What You Gain
- Uptime during real incidents
- Subnet-grade defense against rotating bot swarms
- Reduced manual firefighting
- Better visibility into the attacker’s behavior
- A practical tool when “block upstream” is not instantly available
Important reality check:
If your uplink is fully saturated upstream, local tools can’t beat physics — provider-level filtering is often required.
But if the attack is designed to melt your server resources using valid traffic (CPU/conntrack/workers), local mitigation can keep you alive — and it did.
Conclusion
On Feb 14, 2026, I got a Valentine’s “gift” I didn’t want: a subnet-heavy DDoS aimed at taking digi77.com offline — suspiciously timed two days after I announced Kodachi’s built-in AI capabilities.
I searched for an existing solution. I couldn’t find a tool online that did what I needed.
I asked GPT, and the answer was essentially: “If packets reach Linux, there isn’t much you can do — block it at provider level… but good luck if it’s legit traffic.”
So I wrote my own Bash solution.
It blocked 100% of the botnets I saw — thousands at a time, then thousands more from different regions — and kept the server online.
Get the Script (Support Kodachi)
I’ve released plenty of free scripts and sources before — 100+ over time. This one is different: it’s battle-tested under a real attack, and it’s not something you’ll easily find “ready-made” on the net.
If you want it, support the Kodachi project with a $30 donation and I’ll send you the complete solution as a thank-you — 4,000+ lines of battle-tested code.
To the attackers:
My server is still up.
Try harder. 😄