South Africa's Breach Wave: A Practical Guide to AI Attacks and Daily Patching

South Africa’s Cyber Hack Wave: AI Attackers Move in Minutes, Defenders Take Weeks

👁83views

Attackers move in minutes because AI has made offensive tooling cheap and widely available, while vulnerabilities are exploited before patches are applied. Defenders take weeks because detection, approval, patching and supplier oversight are slow. South African organisations should shorten patch cycles, monitor continuously, and tightly govern third party service providers holding personal data.

South Africa’s Cyber Hack Wave: AI Attackers Move in Minutes, Defenders Take WeeksAndrew Baker's Technology Blog Posts, 21/Nov/2026
https://andrewbaker.ninja/2026/11/21/south-africas-cyber-hack-wave-ai-attackers-move-in-minutes-defenders-take-weeks/

Article Summary
  • 1.
    What it is
    South Africa cyber hack wave analysis: the article explains why a sustained run of breaches at Bob Group, Ampath, Travelstart and others reflects three forces at once, cheap AI attack tooling, exploitation before patches exist, and slow organisational decision making.
  • 2.
    Why it matters
    South Africa cyber hack wave defence needs a different operating model, not more effort inside the old one, because attackers face no change boards, quarterly patch cycles or annual budgets. The article gives executives three measurable questions and five changes to test where their organisation stands.
  • 3.
    Key takeaway
    The article argues the real crisis in South Africa's cyber hack wave is not attacker capability but that the speed of attack has overtaken the speed of organisational decision making, such as weekly change boards and quarterly procurement.
8,143 words · ~41 min read

If you have five minutes, read the introduction, the short version for executives, section 6, section 13 and section 14. The rest is the evidence and the engineering detail behind them.

This morning MyBroadband reported that a major South African financial technology company had suffered a data breach involving personal information, and within hours a friend forwarded me a member notice from a financial services group explaining that one of its contracted service providers had been breached, exposing names, ID numbers and contact details. Neither surprised me, which is itself the problem. Over the last two months South Africa has seen a sustained wave of publicly reported breaches, ransomware claims and incident statements, and I do not think it is a run of bad luck.

Artificial intelligence is behind this shift, as a risk multiplier rather than as the proven cause of any particular breach. It has not invented new kinds of attack; reused passwords, unpatched servers and exposed admin consoles are as old as the internet. What it has changed is the economics. AI has made capable offensive tooling cheap and available to anyone, it is finding vulnerabilities faster than vendors can ship fixes, and it is collapsing the time from a flaw being found to a working exploit from weeks to hours. Each of those changes alone would raise the risk. Together, they mean that the weaknesses South African organisations have carried for years, and the slow way most of them make decisions, have suddenly become far more dangerous.

That is why the thing that worries me most is not on the attacker’s side at all. The real crisis is that AI has pushed the speed of attack past the speed of organisational decision making. Defenders are still bound by weekly change advisory boards, vendors who take months to certify a new runtime, procurement that takes a quarter, annual budgets and patch windows. Attackers never had any of those constraints, and the limits they did have, which were scarce skill, time, money and the effort of attacking many targets at once, are exactly what AI has stripped away. The answer is not more effort inside the old operating model; it is a different operating model.

If you are on a board or an executive committee, three questions will tell you most of what you need to know about where your organisation stands. How long does it take us, measured rather than estimated, to patch or verifiably mitigate an exploited vulnerability on an internet facing system? Which of our administrative interfaces and application origins can be reached directly from the internet today? And if an attacker took over one laptop this afternoon, how far could they get before we noticed? The rest of this post explains why those questions matter now and what to change so that the answers improve.

The minutes in the headline are measured. CrowdStrike’s 2026 Global Threat Report found that the average criminal intruder moved from their first foothold to a second system in 29 minutes in 2025, with the fastest doing it in 27 seconds, and that operations by AI enabled adversaries rose 89% in a year. Mandiant found that the median time for a criminal group to hand stolen access to the next group fell from more than eight hours in 2022 to 22 seconds in 2025. The weeks are less precisely measured, because nobody publishes defender response times for South African organisations, so that half of the headline describes a structural mismatch rather than a statistic: quarterly patch cycles, weekly change boards and incidents where working out how to isolate a system starts only after the alarm goes off.

{
  "type": "bar",
  "data": {
    "labels": ["Fastest attacker breakout", "Average attacker breakout", "Target: identify exposed systems", "Target: verified mitigation", "Target: permanent fix", "Typical quarterly patch cycle"],
    "datasets": [{
      "label": "Minutes (log scale)",
      "data": [0.45, 29, 240, 1440, 4320, 129600],
      "backgroundColor": ["#d9534f", "#d9534f", "#2f6fdf", "#2f6fdf", "#2f6fdf", "#7a7a7a"]
    }]
  },
  "options": {
    "indexAxis": "y",
    "plugins": {
      "title": { "display": true, "text": "Attacker speed versus defender response, in minutes (log scale)" },
      "legend": { "display": false }
    },
    "scales": { "x": { "type": "logarithmic", "title": { "display": true, "text": "Minutes" } } }
  }
}

The chart is illustrative and compares different things on a compressed scale: the red bars are CrowdStrike’s measured breakout times for 2025 (27 seconds and 29 minutes), the blue bars are the defender targets I propose later in this post (4 hours, 24 hours and 72 hours), and the grey bar is a quarterly patch cycle of about 90 days, which is still common. They are not timings from the same incidents, but the gap between red and grey is the problem this post is about.

None of this is unique to South Africa. The tools, the vulnerabilities and the governance problem are the same everywhere, and the European supermarket attacks and the ARTEX campaigns hit organisations across dozens of countries. What makes South Africa a useful case study is that its baseline is lower, so the consequences are showing up here earlier and more visibly. If you run technology anywhere else, read the South African examples as a preview rather than as someone else’s problem.

The short version for executives is five changes, each covered in detail below:

  • Measure, rather than estimate, how long it takes to find and fix exposed systems, and give someone the authority to act the same day without a committee.
  • Stop running infrastructure you do not need to run, and keep every origin and administrative interface off the public internet.
  • Replace network trust and VPNs with identity based, zero trust access, and phishing resistant MFA for everyone.
  • Segment networks and permissions using evidence of real traffic, so that one compromised laptop cannot reach critical systems.
  • Assume someone is already inside: pre build the ability to seal off a compromised system or business area in minutes, rehearse it, and back it with EDR on every managed device, deception and tested recovery.

I have covered parts of this before in The CVE Wave Is Coming. Most Organisations Are Not Prepared, When Critical Infrastructure Cannot Be Patched, ARTEX AI Cyber Attacks, the supermarket fridge hacks and the Binance hack that started on developer laptops. This post is about how those pieces fit together and what the fix looks like on Monday morning; the engineering checks and scripts are in an appendix at the end, so the argument can be read without them.

1. A Sustained Wave of Breaches

The recent list is long, and it helps to separate what organisations have confirmed from what attackers have only claimed. Bob Group, which runs Bob Shop, told customers that an unauthorised party had been in its systems between 30 October and 1 November and had copied older card records along with the key needed to decrypt them, so the card numbers should be treated as exposed. Ampath confirmed it fell victim to a cyberattack on 2 October and that identity, contact, medical aid and payment related data may have been taken, while disputing the attacker’s claim of more than 80 million records and saying it had no evidence that medical records or test results were compromised. Travelstart disclosed a breach exposing customer details and flight ticket information, and TFG London, The Foschini Group’s UK business, lost several IT systems at Phase Eight, Hobbs and Whistles to an incident detected on 11 October.

Then there are the claims that have not been verified. A seller on an underground forum claimed 366GB of data from Rand Mutual Assurance, including 1.68 million workers’ compensation claim records, and demanded US$95,000; RMA said it had received an alert about a breach and was investigating, but neither the claim nor the data had been verified when it was reported. Ransomware groups have also listed or claimed LegalWise, Samwumed and Edcon, among others. One South African threat intelligence tracker has rated the local threat level as high for more than six consecutive months, while noting that leak site aggregators undercount because not every listing is indexed. Nobody can give a verified daily national breach rate, but the pattern of publicly reported incidents is sustained and broad, touching insurance, health, retail, travel, financial services and the suppliers behind them.

The supplier problem deserves its own mention, because it is how an organisation with good security of its own ends up in the news. In June, MIP Holdings, which supplies policy administration and CRM software to insurers and other financial services firms, detected an extortion attack. According to TechCentral, the attackers got in through an employee’s personal laptop using credentials the employee had reused on an unrelated service that had itself been breached, then reached a Jira support platform that was being decommissioned, where tickets that should have contained obfuscated data held identity numbers, email addresses and phone numbers in clear text; around 400,000 records relating to customers of 45 insurers were taken. ITWeb reported that the Jira environment also held access credentials in some cases, which the attackers used to reach certain FTP and SFTP sites, so both personal data and secrets were sitting in support tickets. MIP’s chief executive confirmed that MIP paid the extortionists in return for an undertaking to destroy the data, and the group then turned on the insurers whose customers the data belonged to, posting records of Hollard policyholders on its leak site. Hollard has said the information was obtained through the MIP incident and that its own forensic work found no evidence of compromise within the Hollard environment.

What strikes me about the confirmed cases is how ordinary the root causes are: a reused password on a personal laptop, personal data and credentials left in support tickets, a decryption key stored where the attacker could reach it, and, in a smaller case reported by the same tracker, a vibe coded website compromised six days after launch because its administrator password was in plain text in the page source. The national survey data points the same way. In Sophos’s State of Ransomware 2026, as reported by Daily Maverick, 47% of the South African ransomware victims surveyed cited a complete lack of protection as the root cause, the highest of 17 countries, and 85% linked their ransomware incident to their most significant identity attack, against 67% globally. The second figure is a respondent link rather than proof that identity was the initial entry point in 85% of cases, but together the numbers describe organisations losing to basic gaps rather than exotic techniques.

2. AI Is Behind the Shift, Even Where It Is Not Behind Each Breach

Because AI is the thread running through everything that follows, I want to be explicit about what the evidence shows and what it does not. What AI demonstrably enables is well documented: models that find and exploit vulnerabilities on public benchmarks, open weight models with their safety training stripped out, and packaged frameworks that automate reconnaissance and exploitation. What has been observed in real campaigns is narrower but real, with CrowdStrike, Microsoft, Check Point and the FBI all reporting intrusions run with AI orchestration frameworks over the last few months.

What can be established about the recent South African breaches is narrower still. None of the public reporting I have seen shows that AI was used in any of them, and the disclosed root causes are reused passwords, plain text credentials, clear text personal data and badly stored keys. So the claim I am making is not that AI was used to break into Bob Shop or MIP, and it is not that AI explains every breach report. Rising numbers of reported incidents also reflect long standing security weaknesses, better reporting under POPIA, more of the economy running online and simply more criminal activity. The claim is narrower and, I think, harder to argue with: AI is a risk multiplier. It takes the weaknesses South African organisations already have and makes them cheaper, faster and easier for far more people to exploit, while flooding defenders with vulnerabilities to fix and shrinking the time they have to fix them. The three sections that follow are three ways AI is doing that.

3. AI Shift One: Attack Tooling for Anyone, With the Guardrails Removed

Hugging Face alone hosted more than two million public models by 2025, and the open weight models among them are now good enough to matter. In August, the Chinese lab Z.ai released GLM 5.3, a 753 billion parameter model it describes as the strongest open weight coding model available. On Z.ai’s own published benchmarks, as summarised by DeepLearning.AI, it scored 84.5% on CyberGym, a test of finding and confirming real vulnerabilities, narrowly ahead of Claude Mythos 5 at 83.8%, and 54.4% on ExploitBench, more than double its predecessor’s score but still well behind the leading proprietary models on that harder exploitation test. Benchmark scores are not the same as success against real, defended systems, but Z.ai itself said the jump in exploitation capability was larger than it had intended and held the weights back for about two weeks of safety evaluation before releasing them.

That pause made little practical difference, because within days of the weights appearing an abliterated copy was on Hugging Face under the heading “Built for offensive cybersecurity”. Abliteration identifies the direction in a model’s internal representations that drives refusals and removes it from the weights without retraining, and the publisher of that copy reports a 0% refusal rate on the HarmBench harmful prompt set at higher reasoning settings with an MMLU score about one and a half points below the original. None of this requires specialist skill: in May, the Financial Times and the AI safety group Alice stripped the guardrails from Meta’s Llama 3.3 in under ten minutes on an ordinary laptop using Heretic, a free tool whose author said it had already been used to produce more than 3,500 decensored models with 13 million downloads between them. Once weights are public, every safety decision the lab made becomes a suggestion.

The orchestration has been packaged too. ARTEX, an open source multi agent penetration testing framework published on GitHub in July, picked up more than 12,000 forks within weeks and can drive commercial or local models, with attackers wiring in DeepSeek, GLM and Grok through compatible gateways. As I detailed, with sources, in my ARTEX post, CrowdStrike attributed a campaign against more than 200 organisations in at least 14 countries over eleven days to a China nexus group using it, Microsoft tied it to a supply chain compromise that attempted sign ins to more than 2,250 downstream Microsoft 365 tenants, Check Point estimated the cost of a campaign at roughly $145 to $1,500 based on the attacker servers it examined, and the FBI issued a flash alert on 13 November. When scanning and exploiting hundreds of organisations costs less than a laptop, attackers no longer need to choose their targets carefully.

4. AI Shift Two: AI Finds the Flaws and Writes the Exploits

Published CVEs went from roughly 28,800 in 2023 to about 40,000 in 2024 and a record 48,185 in 2025, as I set out in my legacy systems post, and on 13 November 2026 the year’s count passed 100,000, more than double the whole of 2025 with seven weeks still to go. VulnCheck’s Josh Bressers put it simply: “vulnerability hunting with AI is driving a majority of what we’re seeing.” The reason is that AI is now finding vulnerabilities at a scale no human research community could match. In the first month of Anthropic’s Project Glasswing, about 50 organisations given early access to Claude Mythos Preview flagged more than 10,000 significant security flaws in their own software, with Cloudflare alone finding around 2,000, of which 400 were rated high or critical. That wave is now arriving in vendors’ patch releases. Bloomberg reported in July that the US National Vulnerability Database had already recorded 45,207 flaws by 27 July, close to the record total for all of 2025; that Oracle’s July update fixed 1,449 flaws against 309 a year earlier; that Microsoft disclosed 642 in July, nearly five times the same month in 2025; and that a single Chrome update fixed 433 flaws against 11 a year before, 401 of them found internally by Google.

Most of that AI discovery is being done by defenders, and that matters for how the numbers should be read. VulnCheck counted 1,061 vulnerabilities attributed to AI assisted discovery in the first half of 2026 and found that only 1.3% had been confirmed as exploited in the wild, and Bloomberg noted that CISA’s catalogue showed no rise in the number of exploited flaws. CVE totals are also shaped by disclosure practices and by how many organisations can assign CVEs. But for an organisation trying to keep up, the source of a discovery makes little difference: every flaw a vendor’s AI finds becomes a patch that has to be assessed, tested and deployed, and every patch is a map that an attacker’s AI can read backwards. Even if attackers found nothing themselves, the volume of fixes alone would break a quarterly patching model.

{
  "type": "bar",
  "data": {
    "labels": ["2023", "2024", "2025", "2026 to 13 Nov"],
    "datasets": [{
      "label": "Published CVEs",
      "data": [28800, 40000, 48185, 100222],
      "backgroundColor": "#2f6fdf"
    }]
  },
  "options": {
    "plugins": {
      "title": { "display": true, "text": "Published CVEs per year" },
      "legend": { "display": false }
    },
    "scales": { "y": { "beginAtZero": true } }
  }
}

Volume is only part of the story, because speed now matters more. Mandiant’s M-Trends 2026 report, drawing on its 2025 investigations, estimated that the mean time to exploit had fallen to around minus seven days. Time to exploit, as Mandiant uses it, is the gap between a fix becoming available and the first observed exploitation, averaged across the exploited vulnerabilities it tracked. A negative mean does not mean every one of those vulnerabilities was exploited before its patch; it means that exploitation before the patch was common enough, and sometimes early enough, to pull the average below zero. It covers only the minority of CVEs that are exploited at all, and a few long running zero days can drag a mean down, but it is enough to retire the assumption that you will hear about a flaw, assess it and schedule a fix before anyone uses it. Exploits also remained the most common way in for the sixth year running, at 32% of the intrusions Mandiant investigated. Other measures point the same way. CrowdStrike found that 42% of the vulnerabilities it saw exploited in 2025 were exploited before public disclosure, and VulnCheck’s State of Exploitation report found that the median time from a CVE being published to it appearing on a known exploited list fell from 120 days in 2025 to 80 days in the first half of 2026, while nearly a quarter of exploited flaws were exploited on or before the day they were published. Recorded Future’s Alexander Leslie told Bloomberg that the average time to exploit had fallen from 72 hours last year to 24 hours in 2026, a different measure from Mandiant’s but the same direction.

AI is now one of the main things pushing that window further negative, because it collapses the time between a bug existing and a working exploit existing. Mandiant does not attribute its figure to AI, and much of the 2025 data predates the most capable models, but this month’s biggest disclosure shows the direction clearly. Java4Shell was found by the security startup Calif using OpenAI’s Codex agent, and according to Calif’s own account the whole process took about three hours and roughly $200 in tokens: one hour to find the flaw and two to build a working exploit, with Calif noting that most of the later exploit chains were built almost autonomously by AI. Calif reported its find responsibly, but an attacker with the same tools does not have to, and the same models that write exploits can read a vendor’s patch, a public pull request or a bug tracker comment and work backwards to the vulnerability in hours. Exploitation used to be gated by scarce human skill and time; it is now gated mainly by compute, which is cheap, and that is why the gap between discovery and attack keeps shrinking.

This is what one week in November looked like:

DateVulnerabilityWhat it affectsFix and status when disclosed
13 NovCVE-2026-123039, Check Point Gaia (sk1000362)Check Point firewalls, security gateways and management serversLocal privilege escalation to root, chained with earlier Mobile Access portal flaws; exploited against a couple of dozen customers; CISA exploited catalogue with a 16 November deadline
17 NovCVE-2026-114938, “Java4Shell”Oracle Java SE and OpenJDK 17, 21, 25 and 27, plus the Java 8 performance pack, on x86 CPUs with AVX-512 VBMI; unauthenticated paths into Keycloak, Jira, Confluence, Jenkins, Artifactory and PingFederateCVSS 8.1, rated difficult to exploit; fixed in 17.0.21.1, 21.0.13.1, 25.0.5.1 and 27.0.1.1, with other vendors on their own numbering; CISA urged immediate patching; no confirmed exploitation
18 Nov“NGINX2Root”, five nginx flaws led by CVE-2026-123007nginx 1.9.5 to 1.31.8 and NGINX Plus, mostly through HTTP/2Fixed in 1.30.7 stable and 1.31.9 mainline; disabling HTTP/2 mitigates two of the five; working exploit code public; no confirmed exploitation
18 NovSix critical F5 BIG-IP flaws, CVE-2026-123637 and five iRule CVEsBIG-IP, APM, SSL Orchestrator and PEM 17.1, 17.5 and 21.1, plus BIG-IP Next for Kubernetes and CNF, in specific iRule and APM configurationsRated 9.8; not reported as exploited
19 NovPHP security releases with flaws rated critical, including CVE-2026-115560 and a bug reported as “phpAfterShell”All supported PHP 8 branches; PHP says the critical issues need non default configuration or uncommon setupsFixed in 8.2.36, 8.3.37, 8.4.28 and 8.5.13, alongside the new 8.6.0; not reported as exploited

That is five significant disclosures in seven days, each of which would have demanded an emergency response from any organisation running the affected software in an exposed configuration, across the web server, the application runtime, the scripting language and two families of perimeter device that sit in front of a large share of South African corporate networks. Only the Check Point flaw was confirmed as exploited when it was disclosed, but Java4Shell shows how thin the margin has become: the malformed input that triggers the bug was posted publicly on 9 September in a proposed OpenJDK fix that its author later closed as inactive, more than two months before the CVE existed, so anyone who read that pull request with a capable model had a head start on every defender waiting for an advisory.

5. AI Shift Three: Organisational Latency Becomes the Biggest Risk

Organisational latency is not new, and for decades it was tolerable because attacks moved at human speed. AI has changed that, and the slow processes most organisations rely on are now the largest single source of exposure. Many South African organisations patch on a quarterly or six monthly cycle, route production changes through a weekly change advisory board, depend on vendors who take months to certify a new Java or PHP version, buy security tooling through procurement cycles measured in quarters, and fund it from budgets set a year in advance. Each of those processes was designed to reduce risk, and in a slower world they did, but today every one of them is latency that the attacker gets for free.

The underlying problem is what organisations are optimising for. Change governance in most large companies is built to prevent failed changes, because a failed change is visible, attributable and lands on someone’s performance review, while a delayed change that leaves a vulnerability open for three weeks usually harms nobody’s career unless it is exploited. Attackers optimise for exactly the opposite: they make their living from delayed changes. So the governance model systematically trades a small, visible risk for a large, invisible one, and boards rarely see the trade being made because the change failure rate is reported every month and the exposure window almost never is. Fixing that is a question of risk appetite and incentives as much as technology: the exposure window has to be measured and reported with the same weight as change failures, and the people who own change governance have to be held accountable for both.

Firewalls do not fix this, and the same week illustrated why: the Check Point flaw was in the firewall itself, and perimeter appliances, VPN gateways and load balancers have been among the most heavily exploited categories of device for years because they are internet facing, run privileged code and are patched less often than servers. Even where the firewall holds, it does nothing about a reused password on a personal laptop, which is how MIP was breached. Traditional IT departments, including well funded ones in banks, are organised around projects, change windows and annual planning, and they will struggle in an environment where the right response to a Tuesday advisory is a production change on Tuesday afternoon.

6. What I Would Ask My CIO on Monday Morning

The three questions at the top of this post become much more useful when they are turned into tests with a clock attached, because a test can be failed and a question can always be answered optimistically. If I sat on a board today, these are the three I would ask, and I would ask for a demonstration rather than an assurance.

  1. If a critical internet facing vulnerability is disclosed at 9am tomorrow, can we prove by 1pm which of our systems are exposed? Not estimate, not “we believe we do not run that”, but produce the list from an inventory that includes containers, bundled runtimes and suppliers’ hosted services.
  2. Can we deploy a verified mitigation before the end of the same day without convening a change advisory board? That means a pre approved emergency change path, automated testing and rollback, and someone with the authority to use it at 3pm on a Wednesday.
  3. If an attacker compromises an employee’s laptop, can we demonstrate, rather than assume, that they cannot reach our critical systems? The only convincing answer is a recent test that shows what that laptop could and could not reach.

An organisation that can answer yes to all three, with evidence, is in a different league from one that cannot, regardless of how much it spends on security tooling. Everything in the rest of this post is aimed at making those three answers true.

7. The Principle: Eliminate, Isolate, Automate, Verify

The architecture underneath the practical steps is simple to state. Eliminate the infrastructure you do not need to operate yourself, isolate what remains so that nothing important is reachable from the internet or from a compromised laptop, automate change so that a patch or mitigation can go out in hours without a meeting, and continuously verify that the controls you believe you have are actually in place. The tools I mention below, including AWS, Cloudflare, Zscaler, Netskope and my own sg-tightener, are examples of how to implement those principles rather than the point in themselves, and equivalent services from other providers work in the same way.

8. Step One: Patch or Mitigate Daily

Quarterly patching is now a decision to be exposed for most of every quarter, but daily patching does not mean treating every CVE the same way. Targets should depend on exploitability and exposure, and they should separate verified containment, meaning a compensating control you have tested actually blocks the attack, from permanent remediation, meaning the patched version is deployed everywhere. The targets I would start from are these:

SituationVerified containmentPermanent remediation
Actively exploited and reachable from the internetWithin 24 hoursWithin 72 hours
Public exploit code, reachable from the internet, not yet seen exploitedWithin 48 hoursWithin 7 days
Exploited or weaponised, reachable only internallyWithin 72 hoursWithin 14 days
Vulnerable code present but the affected function is not reachableNot requiredNext routine cycle, with the reachability decision recorded

Some systems genuinely will not meet those numbers, and they should go through a documented, time limited exception with compensating controls and a named owner rather than quietly drifting.

Start with an inventory you can query, because you cannot patch what you cannot find. When Java4Shell landed, the useful question was not “do we run Java” but “which hosts run Java 17 or later, on x86 CPUs with AVX-512 VBMI, behind an unauthenticated Keycloak or Jira”, and that should be a query rather than a meeting. The inventory needs to include container images and bundled runtimes, because a patched host running an old container image is still vulnerable, and reloading nginx keeps the old binary in memory until the process restarts.

The second move is to pre approve the change, so that emergency patches for the web server, runtime and operating system become a standing approved change type with automated testing, canary deployment and automatic rollback, so that the change board approves the pattern once rather than each instance at two in the morning, and with immutable infrastructure patching becomes a rebuild of the image and a rolling replacement of instances or pods. Then triage by evidence rather than by score, because CISA’s Known Exploited Vulnerabilities catalogue, public exploit code, internet exposure and the reachability of the vulnerable code path tell you far more than a CVSS number, and a vulnerability is not the same thing as an exploitable attack path.

For a first pass on individual Linux hosts, Appendix A contains an indicative script that compares nginx, PHP and Java versions with this week’s fixed releases.

9. Step Two: Eliminate What You Do Not Need to Run, and Isolate the Rest

The fastest patch is the one you never have to apply. If your web tier sits behind an AWS Application Load Balancer, your database runs on RDS or Aurora, and your code runs on Lambda or Fargate, then the provider patches the underlying hosts, operating systems and much of the managed middleware without a change board. That is a large reduction in patching burden but not a transfer of all responsibility, because under the shared responsibility model you still own your application code, its dependencies, the runtime versions you choose, your container images and every configuration setting, and a vulnerable library in a Lambda function is still yours to fix. The argument for managed services is now as much a security argument as a cost one, and I covered how to adopt them without becoming trapped in The Exit Is the Architecture.

What remains should sit behind an edge. Putting Cloudflare, or an equivalent edge platform, in front of every internet facing application means a web application firewall inspects traffic before it reaches your infrastructure and DDoS protection absorbs volume attacks. In a week like this one the value is virtual patching, since edge providers often publish managed rules for widely exploited flaws and you can write your own rule to block a specific exploit pattern quickly. How much that helps depends entirely on the vulnerability: a WAF rule can block a well characterised request pattern, but it may be bypassed by encoding tricks, may not see the traffic at all for some protocols, and does nothing for flaws reachable after authentication, so it reduces risk while you patch rather than guaranteeing any particular grace period.

The edge only helps if attackers cannot go around it. Lock origins so that they accept traffic only from the edge provider, ideally through an outbound tunnel such as Cloudflare Tunnel so that the origin has no public inbound ports at all, or at minimum by restricting inbound rules to the provider’s published address ranges. Administrative interfaces, whether firewall consoles, Jenkins, Kubernetes dashboards or refrigeration controllers, should never be reachable from the public internet. That does not mean nobody can reach them remotely; it means remote access goes through an identity aware gateway that checks who the user is and whether their device is healthy, rather than through an address anyone can find with a scanner.

10. Step Three: Replace the Perimeter with Zero Trust

If the perimeter firewall is not going to save you, the replacement is to stop trusting the network at all. A zero trust architecture grants access to each application individually, based on who the user is, how strongly they authenticated and whether their device is healthy, rather than on whether they happen to be inside the network. Platforms such as Zscaler, Netskope and Cloudflare One deliver this as a service: users connect to a nearby edge, the edge checks identity and device posture, and only then brokers a connection to the specific application, which is never itself exposed to the internet. Inside AWS, AWS Verified Access does a similar job for internal applications.

The sequence I would follow starts with replacing the VPN, because VPN appliances are a favourite target and a VPN session typically lands a user on a whole network rather than a single application. After that comes phishing resistant MFA for everyone rather than just administrators, using passkeys or hardware security keys instead of SMS codes or push approvals, followed by device posture checks so that a personal laptop with a reused password, like the one used to breach MIP, cannot reach a production support system whatever credentials it presents. None of this is new thinking, but for years it was something organisations could defer, and that is no longer true.

Replacing the VPN with an access product is the start of zero trust, not the whole of it. Zero trust is an architectural model rather than a product category, and the same principle has to apply between workloads as well as between people and applications: services should authenticate to each other with workload identities rather than shared secrets or network location, authorisation should be checked at every service call, privileged access should be granted just in time and recorded, and sessions should be evaluated continuously rather than trusted for hours after a single login. Identity based access also fails when the identity itself is stolen, which is increasingly how attackers work, through session token theft, consent phishing and helpdesk social engineering, so detecting anomalous use of valid credentials, binding sessions to devices where possible and keeping session lifetimes short matter as much as the strength of the original login.

11. Step Four: Segment Everything, and Prove It With Data

Segmentation is what turns a breach into an incident rather than a catastrophe. Most serious intrusions involve an attacker getting a foothold somewhere unimportant and moving sideways to something important, and in a flat network nothing stops that movement. In AWS, effective segmentation has several layers: security groups and network ACLs for network paths, IAM policies and permission boundaries for what each workload and person can call, egress controls so that a compromised workload cannot freely reach the internet or exfiltrate data, separate accounts with tightly scoped cross account roles between environments, and authorisation at the service level so that reaching an endpoint is not the same as being allowed to use it. Network rules are the most visible layer and the one most often left wide open.

The first step is to find the open doors, and Appendix B contains a read only script that lists security groups open to the whole internet and shows which of them are attached to network interfaces with public IP addresses.

The harder problem is rules that are not open to the world but are still far broader than they need to be, because nobody knows which sources genuinely use them and nobody wants to break production by guessing. That is why I built sg-tightener. It reads 90 days of VPC flow logs, works out which source addresses actually talk to each resource, and proposes replacement rules using the tightest CIDR blocks the observed traffic supports, accepting a block only if no more than 20% of its address space went unobserved, so that you tighten aggressively without locking out real users. It works in plan, apply and revert steps, in the same spirit as Terraform, so every change can be reviewed before it happens and rolled back if something was missed. Observed traffic is evidence, not proof of future need: disaster recovery paths, failover routes, month end and year end batch jobs and seasonal workloads may never appear in a 90 day window, so proposed changes should be checked against documented application dependencies and recovery scenarios before they are applied, and the revert step should be part of the plan rather than an afterthought. With that discipline, when the alternative is guesswork that has been accumulating for years, evidence from your own traffic is the cheapest way I know to cut the blast radius of the next breach.

Beyond the network, stop workstations talking to each other over SMB, RDP and WinRM, and alert whenever a single host suddenly reaches a large number of internal targets, because that pattern is what an automated framework like ARTEX looks like from the inside.

12. Step Five: Assume Breach, and Pre Build the Seal Off

Even with daily patching, an edge, zero trust and tight segmentation, some attacks will get through, especially when exploitation can begin before a patch exists, and the question then is how quickly you notice. I have argued in Decoys as Zero Day Sensors and Fighting the Swarm that deception deserves a much bigger role, because fake credentials, decoy hosts and canary tokens that no legitimate user ever touches give you a high confidence alert regardless of which vulnerability the attacker used. Pair that with endpoint detection and response on every server and laptop, not just the ones that were easy to install it on, running in prevention mode rather than detect only wherever it is compatible, with any critical workload that genuinely cannot run in prevention mode documented as an exception with its own compensating monitoring, because EDR is often the first thing that notices an attacker who got in through a flaw nobody knew about yet. Measure coverage as a number and chase the gaps, and remember its limit: EDR only protects devices you manage, which is why a personal laptop like the one used to breach MIP should never be able to reach production in the first place. Add centralised logs that attackers cannot delete, and a recovery process you have actually rehearsed, because a backup you have never restored is a hope rather than a control.

Detection only helps if you can act on it faster than the intruder moves, and against a 29 minute average breakout that means containment has to be built and rehearsed before the incident, not designed during it. In most organisations today, isolating a compromised business area would mean working out which network rules, credentials and integrations to change while the attacker is still moving, which is a plan measured in hours. The alternative is to pre build a seal off at several levels: a single server, a group of servers, one application, a partner connection and a whole business area, each applied in one step and reversed in one step, so that you can stop a breach without stopping the business. A sensible target is to seal off the affected area within 15 minutes of detection, which only works if each level has been proven on test systems and then rehearsed in regular breach drills, at least one of which should start from a compromised engineer’s laptop.

For the clearest threats, the first response should be automatic, with the rule for when to automate set by two things together: how confident the detection is and how much business impact the isolation would cause. High confidence detections on systems that can be isolated cheaply should trigger an immediate response, while lower confidence signals or isolations that would take down a critical service should go to a person first. Where automation applies, it should cut off the intruder’s access and isolate the affected system immediately, with an on duty engineer confirming or reversing the action within minutes. Many organisations resist this because an automatic action might disrupt a legitimate workload, which is the same governance instinct described in section 5, but a reversible isolation of one server is a far smaller risk than a human response that starts after the attacker has already moved on. Containment also depends on the earlier steps: a seal off is undermined by permanent credentials that work from anywhere, so long lived keys should be replaced by short lived, on request access that expires within hours, and cloud keys should only work from your own network. The Binance theft is a reminder of where this gets hardest, because the intruder arrived holding a trusted engineer’s credentials and used legitimate deployment and signing paths, so developer laptops, pipelines, internal AI tools and anything that can sign or move money need their own containment plan, including two person control and limits on what a trusted system will do even when asked correctly.

Extend the same scrutiny to your suppliers. The MIP incident, and the notice my friend received this morning, both sit in third parties holding data on someone else’s behalf, so know which suppliers hold your customers’ data, what they store in their support tools, and what you will do on the day they call.

13. Why Regulation Will Not Save Us

When a threat becomes this visible, the natural instinct for regulators is to reach for regulation, either by regulating AI itself or by prescribing in more detail how companies must defend themselves. I understand the instinct, but in this case neither is likely to change the outcome, and the second could make it worse.

Start with where the attacks come from. These attacks are not coming from South Africa, and they are not coming from any single place. Anyone who looks at where hostile traffic actually originates sees it arriving from all over the world, and it is often not coming from the countries people instinctively expect. Part of that is because attackers deliberately route through compromised servers, rented cloud capacity and hijacked home routers in whichever country is convenient, so the apparent source of an attack says very little about who is behind it. But the broader point stands: the people attacking South African companies are, overwhelmingly, outside the reach of South African law, and in many cases outside the reach of any law that will actually be enforced against them.

That is why regulating AI will not help with this particular problem. A South African, or even a European or American, rule on how AI models may be built or used binds the companies that choose to comply with it, not the attacker running an abliterated model on their own hardware in another jurisdiction. The open weight models that matter have already been published, copied and stripped of their safety training, and no regulation can recall weights that are sitting on thousands of hard drives around the world. There may be good reasons to regulate AI in other areas, but slowing down attackers who already have the tools is not one of them.

Regulating how companies defend themselves is more tempting and, I think, more risky. Prescriptive security rules are written against the threats of the year they were drafted, take years to update and are measured through audits and checklists, which tends to produce organisations that are good at demonstrating compliance rather than good at responding quickly. Every additional approval, attestation and reporting step that a rule adds is more of the organisational latency this post is about, and the attackers will not wait for the paperwork. If regulators want to help, the most useful thing they can do is hold organisations accountable for outcomes, such as how quickly they find and contain exposure, rather than adding prescriptive process that slows the response down.

None of this lets companies off the hook. If anything it puts the burden squarely on them, because there is no external fix coming. This is a situation where organisations need to urgently and rapidly reconstruct how they operate: how they patch, how they make change decisions, how they grant access, how they segment and how they contain a breach. No regulator, firewall vendor or AI policy will do that for them.

14. Measure It, or It Will Not Change

Organisational latency only shrinks when it is measured, so I would put a small set of numbers in front of the executive committee every month. The targets below are my suggestions rather than an industry standard, and the point is to measure the real figure honestly before arguing about the target.

MeasureWhat it tells youSuggested target
Time to identify exposureHours from a critical advisory to knowing every affected systemUnder 4 hours
Time to verified containment, exploited internet facing vulnerabilitiesHours from advisory to a tested compensating control or patchUnder 24 hours
Time to permanent remediation, exploited internet facing vulnerabilitiesHours from advisory to the fix deployed everywhereUnder 72 hours
Origins and admin interfaces reachable from the public internet, other than through an identity aware gatewayWhether isolation is realZero
EDR coverage of servers and laptopsWhether you would see an attacker on a managed device100% of managed devices, in prevention mode
Users on phishing resistant MFAHow exposed you are to credential theft and reuseAll users
Tested lateral movement reachabilityHow far a compromised laptop can actually get, measured by testingTested at least quarterly, shrinking each time
Time from detection to seal offWhether an intruder stays in the area they enteredUnder 15 minutes, proven in drills
Restore tests completedWhether recovery worksEvery critical system, at least twice a year

Which brings me back to the three tests: whether you can prove which systems are exposed within four hours of an advisory, whether you can deploy a verified mitigation the same day without a committee, and whether you can demonstrate that a compromised laptop cannot reach your critical systems. South Africa has spent years treating cybersecurity as a compliance cost to be minimised, and the steady stream of breach notifications is the bill for that decision. AI has given attackers cheap and capable tooling, models with the safety removed, packaged frameworks and a steady supply of fresh vulnerabilities, and they have none of the meetings, approvals and budget cycles that slow defenders down. AI did not create South Africa’s security gaps, but it has made every one of them more expensive to leave open. The organisations that come through this will not be the ones with the biggest firewall; they will be the ones that make decisions at the speed the threat now demands, patching daily, keeping their origins and admin interfaces off the internet, trusting identities rather than networks, segmenting using real evidence, and assuming that someone is already inside.

Engineering Appendices

The two scripts below are for engineers who want a starting point. They are indicative checks rather than scanners, and the caveats with each one matter. Appendix A: Checking hosts against this week’s fixes

This script is an indicative check, not a vulnerability scanner, and it should not be the basis for a production decision on its own. It compares nginx, PHP and Java versions on a Linux host with the fixed releases in the table in section 4, including Java runtimes bundled outside the path. It reads the Java version from the runtime’s own java.version property rather than parsing the banner, because OpenJDK builds print banners in several formats, and it treats each nginx and PHP release branch explicitly, so a version on an older branch is never counted as fixed just because its number happens to sort higher. Distributions often backport fixes without changing version numbers and vendors such as Corretto and Zulu use their own numbering, so a “CHECK” result is a prompt to confirm against the relevant advisory and an “OK” result is not a guarantee.

cat > cve-week-check.sh << 'EOF'
#!/usr/bin/env bash
# Indicative check only, not a vulnerability scanner.
# Compares local nginx, PHP and Java versions with the fixed releases from the week of 16 November 2026.
# Distro backports and vendor Java builds can make results wrong in either direction: confirm against advisories.

# Strip build suffixes (+7, -ea, _402, -1ubuntu) and pad to four numeric parts so 17.0.21 compares with 17.0.21.1
norm() {
  local v=${1%%[+_-]*} a b c d
  IFS=. read -r a b c d <<< "$v"
  printf '%d.%d.%d.%d' "$((10#${a:-0}))" "$((10#${b:-0}))" "$((10#${c:-0}))" "$((10#${d:-0}))"
}
ver_ge() {
  local have want
  have=$(norm "$1"); want=$(norm "$2")
  [ "$(printf '%s\n%s\n' "$want" "$have" | sort -V | head -n1)" = "$want" ]
}

echo "== nginx (NGINX2Root, CVE-2026-123007 and related) =="
if command -v nginx >/dev/null 2>&1; then
  v=$(nginx -v 2>&1 | sed -n 's|.*nginx/\([0-9.]*\).*|\1|p')
  branch=$(echo "$v" | cut -d. -f1,2)
  case "$branch" in
    1.30) fixed=1.30.7 ;;
    1.31) fixed=1.31.9 ;;
    *)
      if ver_ge "$v" "1.32.0"; then fixed="$v"
      else fixed=""; fi ;;
  esac
  if [ -z "$fixed" ]; then
    echo "nginx $v CHECK: branch $branch has no upstream fix; move to 1.30.7 or 1.31.9, or confirm a vendor backport"
  elif ver_ge "$v" "$fixed"; then
    echo "nginx $v OK (upstream version; confirm vendor packaging)"
  else
    echo "nginx $v CHECK: upstream fix on this branch is $fixed; restart the service after upgrading, a reload is not enough"
  fi
  if nginx -T 2>/dev/null | grep -Eq '(^|[[:space:]])http2([[:space:]]|;)|listen .*http2'; then
    echo "  HTTP/2 is enabled: disabling it mitigates two of the five flaws only"
  fi
else
  echo "nginx not found on PATH"
fi

echo "== PHP (CVE-2026-115560 and related, 19 November releases) =="
if command -v php >/dev/null 2>&1; then
  v=$(php -r 'echo PHP_VERSION;')
  branch=$(echo "$v" | cut -d. -f1,2)
  case "$branch" in
    8.2) fixed=8.2.36 ;; 8.3) fixed=8.3.37 ;; 8.4) fixed=8.4.28 ;; 8.5) fixed=8.5.13 ;; 8.6) fixed=8.6.0 ;;
    *) fixed="" ;;
  esac
  if [ -z "$fixed" ]; then
    echo "PHP $v CHECK: branch $branch is not covered by these fixes; upgrade to a supported release"
  elif ver_ge "$v" "$fixed"; then
    echo "PHP $v OK (upstream version; confirm vendor packaging)"
  else
    echo "PHP $v CHECK: upstream fix on this branch is $fixed"
  fi
else
  echo "php not found on PATH"
fi

echo "== Java (Java4Shell, CVE-2026-114938) =="
if grep -q avx512vbmi /proc/cpuinfo 2>/dev/null; then
  echo "CPU supports AVX-512 VBMI: unpatched affected Java builds are vulnerable on this host"
else
  echo "CPU does not report AVX-512 VBMI: lower risk, but patch anyway in case workloads move"
fi
find / -xdev -type f -path '*/bin/java' 2>/dev/null | sort -u | while read -r j; do
  # Ask the runtime for its own version property; fall back to parsing the banner
  v=$("$j" -XshowSettings:properties -version 2>&1 | awk -F'= ' '/^[[:space:]]*java\.version =/{print $2; exit}')
  [ -z "$v" ] && v=$("$j" -version 2>&1 | head -n1 | grep -oE '[0-9]+(\.[0-9]+)*([_+][0-9]+)?' | head -n1)
  if [ -z "$v" ]; then
    echo "$j: could not determine version, check manually"
    continue
  fi
  major=${v%%.*}
  case "$major" in
    17) fixed=17.0.21.1 ;; 21) fixed=21.0.13.1 ;; 25) fixed=25.0.5.1 ;; 27) fixed=27.0.1.1 ;;
    1|8) echo "$j ($v) CHECK: standard Java 8 is not affected, but the Java 8 performance pack (8u511b33-perf) is"; continue ;;
    11) echo "$j ($v): Java 11 is not listed as affected"; continue ;;
    *) echo "$j ($v) CHECK: version line not covered by this script, confirm with the vendor"; continue ;;
  esac
  if ver_ge "$v" "$fixed"; then
    echo "$j ($v) OK (Oracle numbering; confirm vendor builds)"
  else
    echo "$j ($v) CHECK: Oracle fixed release is $fixed; Corretto, Zulu and other builds use their own version numbers"
  fi
done
EOF
chmod +x cve-week-check.sh

Appendix B: Finding security groups open to the internet

This read only script lists every security group in every enabled region with an inbound rule open to 0.0.0.0/0 or ::/0, and for each one counts how many attached network interfaces have a public IP address. A group open to the world is not automatically an attack path, because it may be unattached or attached only to private resources, and a group with no public interfaces can still be reachable through a load balancer, NAT or peering, so treat the output as a starting list for review rather than a finding. Load balancers, CloudFront origins and anything behind an edge provider need checking separately.

cat > find-open-security-groups.sh << 'EOF'
#!/usr/bin/env bash
# Lists security groups with inbound rules open to 0.0.0.0/0 or ::/0, with attached and public ENI counts.
# Read only: it makes no changes. An open group is a review item, not proof of an attack path.
set -euo pipefail

printf '%-16s %-22s %-30s %-10s %-8s %s\n' REGION GROUP_ID NAME OPEN_TO ATTACHED PUBLIC_IP
for region in $(aws ec2 describe-regions --query 'Regions[].RegionName' --output text); do
  for filter in "Name=ip-permission.cidr,Values=0.0.0.0/0" "Name=ip-permission.ipv6-cidr,Values=::/0"; do
    aws ec2 describe-security-groups --region "$region" --filters "$filter" \
      --query 'SecurityGroups[].[GroupId,GroupName]' --output text |
    while read -r id name; do
      [ -z "${id:-}" ] && continue
      attached=$(aws ec2 describe-network-interfaces --region "$region" \
        --filters "Name=group-id,Values=$id" --query 'length(NetworkInterfaces)' --output text)
      public=$(aws ec2 describe-network-interfaces --region "$region" \
        --filters "Name=group-id,Values=$id" \
        --query 'length(NetworkInterfaces[?Association.PublicIp])' --output text)
      printf '%-16s %-22s %-30s %-10s %-8s %s\n' "$region" "$id" "${name:0:30}" "${filter##*=}" "$attached" "$public"
    done
  done
done
EOF
chmod +x find-open-security-groups.sh

References

Leave a comment

Your email address will not be published. Your first comment is held for approval.