South Africa’s Breach Wave: A Practical Guide to AI Attacks, Daily Patching and Zero Trust
South Africa is seeing near daily breaches because AI tools let almost anyone attack, newly disclosed vulnerabilities are exploited faster than organisations can patch, and local security baselines were set for a gentler era. Most incidents trace back to ordinary failures like reused passwords, plain text credentials, and poorly stored encryption keys.
South Africa’s Breach Wave: A Practical Guide to AI Attacks, Daily Patching and Zero TrustAndrew Baker's Technology Blog Posts, 21/Nov/2026
https://andrewbaker.ninja/2026/11/21/south-africas-breach-wave-a-practical-guide-to-ai-attacks-daily-patching-and-zero-trust/
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.
Three forces are arriving at once: artificial intelligence that has made capable offensive tooling cheap and widely available, a flood of vulnerabilities that are increasingly exploited before defenders have a patch, and a corporate security baseline in South Africa that was set for a much gentler world. But the thing that worries me most is not on the attacker’s side at all. The real crisis is that the speed of attack has overtaken the speed of organisational decision making. Change advisory boards meet weekly, vendors take months to certify a new runtime, procurement takes a quarter, budgets are set annually, and patch approvals wait for a window, while attackers have none of those constraints and AI has removed most of the others they used to have. 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.
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.
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. What We Know, and What We Are Inferring
Because AI features heavily in what follows, I want to be explicit about the evidence. 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 honest argument is not that AI caused this wave. It is that South African organisations are already losing to basic attacks, and AI is making those same attacks cheaper, faster and available to far more people, which widens the gap between attacker speed and defender speed.
3. Force One: Capable Attack Tooling Is Everywhere, and Its Guardrails Are Optional
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. Z.ai 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. Force Two: The CVE Flood, and Exploitation Before the Patch
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 2026 is running well ahead of that, partly because AI models now find bugs faster than human researchers did.
{
"type": "bar",
"data": {
"labels": ["2023", "2024", "2025"],
"datasets": [{
"label": "Published CVEs",
"data": [28800, 40000, 48185],
"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.
This is what one week in November looked like:
| Date | Vulnerability | What it affects | Fix and status when disclosed |
|---|---|---|---|
| 13 Nov | CVE-2026-123039, Check Point Gaia | Check Point firewalls and management servers, R81 to R82.20 | Local privilege escalation to root; added to CISA’s exploited catalogue after attacks on a couple of dozen customers |
| 17 to 18 Nov | CVE-2026-114938, “Java4Shell” | Java 17, 21, 25 and 27 on x86 servers with AVX-512 VBMI; unauthenticated paths into Keycloak, Jira, Confluence, Jenkins, Artifactory and PingFederate | Oracle fixes 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-123007 | nginx 1.9.5 to 1.31.8 and NGINX Plus, mostly through HTTP/2 | Fixed in 1.30.7 (stable) and 1.31.9 (mainline); working exploit code public; no confirmed exploitation |
| 18 Nov | Six critical F5 BIG-IP flaws | BIG-IP in specific iRule and APM configurations | Rated 9.8; not reported as exploited |
| 19 Nov | Eight critical PHP flaws, including CVE-2026-115560 and “phpAfterShell” (CVE-2026-126714) | All supported PHP 8 branches under specific conditions | Fixed in 8.2.36, 8.3.37, 8.4.28, 8.5.13 and the new 8.6.0; not reported as exploited |
That is five emergency patching events in seven days, 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. Force Three: Organisational Latency
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.
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. 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.
7. Step One: Patch or Mitigate Daily
Quarterly patching is now a decision to be exposed for most of every quarter. The target I would set is that internet facing systems with an exploited or publicly weaponised critical vulnerability are patched, or protected by a mitigation you have verified works, within 24 hours, internal systems within 72 hours, and everything else on a rolling weekly cycle. Some systems genuinely will not meet that, 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.
The script below is an indicative check, not a vulnerability scanner. It compares nginx, PHP and Java versions on a Linux host with the fixed releases in the table above, including Java runtimes bundled outside the path, after normalising version strings so that a three part version such as 17.0.21 compares correctly against a four part fix such as 17.0.21.1. Version comparisons still produce false positives and false negatives, because distributions often backport fixes without changing version numbers and vendors such as Corretto and Zulu use their own numbering, so treat every “CHECK” result as a prompt to confirm against the relevant advisory.
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')
case "$v" in 1.31.*) fixed=1.31.9 ;; *) fixed=1.30.7 ;; esac
if ver_ge "$v" "$fixed"; then
echo "nginx $v OK"
else
echo "nginx $v CHECK: upstream fix is $fixed or later; 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, CVE-2026-126714 and related) =="
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 is on an unsupported branch: upgrade to a supported release"
elif ver_ge "$v" "$fixed"; then
echo "PHP $v OK"
else
echo "PHP $v CHECK: upstream fix 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
v=$("$j" -version 2>&1 | sed -n 's/.*version "\([^"]*\)".*/\1/p' | head -n1)
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 ;;
*) echo "$j ($v): standard Java 8 and 11 do not contain the vulnerable code"; continue ;;
esac
if ver_ge "$v" "$fixed"; then
echo "$j ($v) OK"
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.sh8. 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 internet in any form.
9. 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.
10. 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. This script lists every security group in every enabled region that allows inbound traffic from anywhere on IPv4 or IPv6:
cat > find-open-security-groups.sh << 'EOF'
#!/usr/bin/env bash
# Lists security groups in every enabled region with inbound rules open to 0.0.0.0/0 or ::/0.
# Read only: it makes no changes.
set -euo pipefail
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,VpcId]' --output text |
while read -r id name vpc; do
[ -n "${id:-}" ] && echo "$region $id $name $vpc (${filter##*=})"
done
done
done | sort -u
EOF
chmod +x find-open-security-groups.shThe 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. 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.
11. Step Five: Assume Breach and Watch the Inside
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, 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.
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.
12. 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.
| Measure | What it tells you | Suggested target |
|---|---|---|
| Time to identify exposure | Hours from a critical advisory to knowing every affected system | Under 4 hours |
| Time to mitigate exploited internet facing vulnerabilities | Hours from advisory to patch or verified mitigation | Under 24 hours |
| Time to mitigate exploited internal vulnerabilities | Same measure for internal systems | Under 72 hours |
| Origins and admin interfaces reachable from the internet | Whether isolation is real | Zero |
| EDR coverage of servers and laptops | Whether you would see an attacker on a managed device | 100% of managed devices, in prevention mode |
| Users on phishing resistant MFA | How exposed you are to credential theft and reuse | All users |
| Tested lateral movement reachability | How far a compromised laptop can actually get, measured by testing | Tested at least quarterly, shrinking each time |
| Restore tests completed | Whether recovery works | Every critical system, at least twice a year |
Which brings me back to the three questions at the start: how long it takes you to patch or mitigate an exploited vulnerability on an internet facing system, which of your administrative interfaces and origins can be reached from the internet today, and how far someone could get from one compromised laptop before you noticed. 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. Attackers now have cheap and capable tooling, models with the safety removed, packaged frameworks and a steady supply of fresh vulnerabilities, and none of the meetings, approvals and budget cycles that slow defenders down. 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.
References
- MyBroadband, 21 November 2026: Major South African financial technology company suffers data breach that involved personal information
- TechCentral, 12 November 2026: Bob Shop data breach, card numbers and encryption key
- TechCentral, October 2026: Ampath breach, no evidence test results taken
- MyBroadband: Travelstart data breach exposes customer details and flight ticket information
- Help Net Security, 14 October 2026: TFG London cyberattack hits Phase Eight, Hobbs and Whistles
- TechCentral, 23 October 2026: Rand Mutual Assurance data breach claim
- TechCentral: Ransomware gang claims South African client data (LegalWise, Samwumed, Edcon)
- TechCentral: Customers of 45 insurers exposed in cyber breach (MIP Holdings)
- ITWeb, 16 September 2026: Hollard rejects hacking claim, points to MIP cyber breach
- TechCentral: Hackers extort insurers after MIP ransom
- South Africa Cyber Threat Intelligence Report, week 44 2026
- Daily Maverick, 22 September 2026: SA is under cyber siege and the situation will only get worse
- Hugging Face: State of Open Source on Hugging Face, Spring 2026
- DeepLearning.AI The Batch: GLM 5.3 makes cybersecurity gains
- Hugging Face: GLM 5.3 abliterated model card
- Irish Times, 25 May 2026: AI guardrails stripped from Meta and Google models in minutes
- Andrew Baker: ARTEX AI Cyber Attacks (with CrowdStrike, Microsoft, Check Point and FBI sources)
- Andrew Baker: When Critical Infrastructure Cannot Be Patched (CVE totals by year)
- Google Cloud: M-Trends 2026
- Cybersecurity News, 14 November 2026: CISA warns of Check Point zero day exploited to gain root access
- The Hacker News, 18 November 2026: Java4Shell (CVE-2026-114938) enables unauthenticated RCE in Jira, Jenkins, Keycloak and more
- Qualys, 18 November 2026: NGINX2Root, five nginx flaws led by CVE-2026-123007
- The Hacker News, 18 November 2026: F5 warns six critical BIG-IP flaws
- The Hacker News, 19 November 2026: PHP fixes critical flaws including RCE bugs



