Force-installed extensions: how KREMLIN gets into Chrome and Edge, and how to check your browser
The KREMLIN banking trojan forges Chrome's integrity checks to install a spy extension — no store, no policy, no prompt. Here's how to check your browser.

Your chrome://extensions page carries an implicit promise: everything on it got there because you approved it, and everything you approved came through store review. A Brazilian banking-malware toolkit called KREMLIN doesn't respect that promise. According to research Elastic Security Labs published on September 14, 2026, which BleepingComputer reported two days later, KREMLIN installs a spy extension directly into Chrome and Edge profiles — no Web Store, no enterprise policy, no prompt — and then forges the integrity checks Chromium uses to catch exactly that kind of tampering.
One naming note before you read on — I know what it sounds like, and it's misleading: this has nothing to do with the Russian government. KREMLIN is what the malware's author calls the toolkit. Elastic says nothing about the operation is Russian: the lures impersonate Brazilian banks, and the error messages and code comments are written in Portuguese.
What KREMLIN actually does
Elastic has tracked the operation since May 2025: seven campaigns over 15 months, with lures impersonating twelve Brazilian banks. The extension doesn't always travel alone — earlier campaigns dropped Pulsar RAT onto the machine as well, and more recent ones switched to REMCOS.
The tradecraft is stranger than the payload. The malware finds its servers through dead-drop resolvers written into Ethereum smart contracts, and some payloads were hosted on the Internet Archive, encoded inside JPEG images. Elastic also traced the wallet that deployed those contracts: about 20,800 USDT received and 19,000 USDT sent between June 2025 and August 2026, though the researchers say no individual transfer can be tied directly to funding the operation.
The operation had one soft spot. As one of its anti-analysis checks, the malware requests a domain that shouldn't exist, and quits if it gets an answer — a cheap way to spot a sandbox. Elastic registered that domain. Every copy that reached it decided it was being analyzed and crashed itself before going further, which is also how Elastic could count 1,515 infected systems checking in, 98.75% of them in Brazil. The researchers call the disruption temporary, and say the count was still accelerating when they published.
The extension itself masquerades as software called "AVSync" (earlier campaigns used "FrameSync" names), and once it's in the browser it works as a full-time spy. Per Elastic's analysis, it can take cookies, local and session storage, screenshots, page source, the list of open tabs, and HTTP request bodies and headers, and it logs what you type into forms on the sites its operators target. It can inject attacker-supplied HTML into pages, redirect clicks, and take commands over a WebSocket. That's every capability you need to watch a banking session live — and to reshape what the victim sees while it happens.
An install with no install prompt
Here's the part that deserves your attention. Chromium keeps a set of protected settings — including which extensions are registered — in a per-profile file called Secure Preferences, and guards them with keyed hashes (HMACs) and, in newer versions, encrypted hashes as well. The purpose is simple: if some external program edits the file — say, to register an extension no user ever approved — the browser notices on next launch that the math doesn't add up and resets the tampered value.
Per Elastic's write-up, KREMLIN gets past that without a browser exploit; the analysis mentions no vulnerability anywhere in the sequence. The malware waits until the browser is closed or you've been idle for two minutes — and terminates the browser if it's still running. Then it unpacks its extension into each profile, flips on developer mode, writes its registration into Secure Preferences, and regenerates the integrity values so they match. What it needs for that is a seed that ships inside the browser's own installation files and, on Chromium 144 and later, an encryption key it lifts from the memory of a browser process it launches under a debugger. On the next launch the checks pass, and the browser loads the extension, in Elastic's words, "as though the user approved it."
I'm deliberately describing the mechanism and not the recipe. And the mechanism isn't new. Elastic calls it "a documented technique rarely observed in malware" and points to Synacktiv's September 2025 research, which showed that the ability to write to disk is enough to silently install an extension into Chromium browsers on Windows. Chromium's own engineering notes concede the weak spot: an HMAC, they say, is something "anyone can generate, including attackers seeking to overwrite pref values" — which is why newer versions add hashes encrypted with a key the operating system protects. KREMLIN is what it looks like when a banking-malware crew picks the technique up and gets past that newer layer too.
The fourth door
I count four realistic ways an extension reaches your browser, and each one is stopped by a different defense:
- The store. Malicious listings that pass review — like the GhostPoster campaign that hid payloads inside icon PNGs. The defenses are store review and scanning.
- Policy. Force-install policy keys meant for managed corporate fleets, written locally on unmanaged personal PCs — the trick behind the new-tab and search hijackers Google has been building default blocking for. Those defenses live at the policy layer.
- The launch flag.
--load-extensionsideloaded into a browser the attacker starts — how UNC6692's SNOWBELT runs inside headless Edge processes victims never see. The defense is endpoint monitoring, because the browser UI shows nothing. - The profile itself. KREMLIN's approach: write the registration straight to disk in your own browser profile, then forge the integrity values that are supposed to catch it. The registration is persistent, and the extension loads in the browser you launch yourself.
The taxonomy matters because each door breaks a different assumption, and the fourth one breaks the assumption underneath the other three: if it's in my profile, it got there through a sanctioned path. Store review can't see it — there's no listing. Policy-layer blocking can't see it — there's no policy. What's left is the endpoint. By Elastic's description the install itself is noisy for anything that's watching — a browser killed and then relaunched under a debugger with no window, a non-browser process rewriting Secure Preferences — but once it's done, the extension is loaded by your own browser like any other.
Small campaign, public technique
Let me be careful about scale. 1,515 systems is small next to the store campaigns I usually write about, and nearly all of them were in Brazil. If you don't bank there, your odds of meeting KREMLIN itself are low. Treat the number as a September snapshot, though: Elastic said it was climbing fast when the report went out.
The technique isn't tied to Brazil. It's publicly documented, it needs no browser vulnerability, and KREMLIN's installer handles both Chrome and Edge. Two limits are worth knowing. Elastic's analysis is of Windows malware. And Chromium only enforces these integrity checks on Windows and macOS in the first place — on other platforms its source turns enforcement off, so there's no check to forge.
BleepingComputer's September 16 report carried no comment from Google or Microsoft, so I can't tell you how either vendor reads this. What I can point to is the code: the encrypted hashes are Chromium's hardening against exactly this kind of tampering, and KREMLIN already ships a way around them.
How to check your browser
Because of how KREMLIN installs — flipping developer mode, registering an extension that never passed through a store — an infection leaves traces you can look for. Here's the checklist I'd run:
- Look at the developer-mode toggle. Open
chrome://extensions(oredge://extensions). Top right: a Developer mode switch. If you're not a developer and it's on — or you are one and you know you left it off — treat that as a red flag, not a curiosity. KREMLIN flips it as part of the install. - Check where each extension came from. Open the Details page for anything you don't instantly recognize and read the Source line. In Chrome a store install says "Chrome Web Store"; an extension loaded from a folder says "Unpacked extension" and shows the path it was loaded from. Elastic doesn't publish the exact entry KREMLIN writes, but the technique Synacktiv documented rides the same mechanism as "Load unpacked" — which is why developer mode gets flipped — so an unpacked extension you didn't load yourself is the thing to look for. Remove anything you can't account for.
- Treat a hit as a machine problem, not a browser problem. The extension is the symptom; banking malware running as your user is the disease. Removing an AVSync-style extension doesn't remove what planted it — and per BleepingComputer's summary, the toolkit also copies out browser databases and cookies on its own. Run a full anti-malware scan, then change your passwords and check account activity from a device you trust.
- Automate the inventory.
chrome.management.getAll()gives you a machine-readable list of everything the browser has loaded, and I've built a working audit popup on it — a weekend-scale project. ItsinstallTypefield separates store installs (normal) from unpacked loads (development), policy (admin) and other-program installs (sideload), per the API reference. Anything that isn'tnormaldeserves a question. Neither Elastic nor BleepingComputer says which value KREMLIN's entry reports, so don't readnormalas a clean bill either — every entry should survive the "do I remember installing this?" test. - Enterprises: watch the install, not just the extension. Synacktiv's advice to defenders is to monitor changes to browser preference files made by non-browser processes, and unusual extension registrations. Elastic's analysis adds process-level tells — the browser terminated, then relaunched under a debugger with
--no-startup-window— and its post lists indicators of compromise. Longer term, Google is previewing extension DOM activity telemetry for Chrome Enterprise Premium: signals about code injection and data access by extensions, sent through Chrome's real-time reporting pipeline to your SIEM, and switched on with theExtensionDOMActivityLoggingEnabledpolicy. Per the Chrome Enterprise release notes, it has been an early preview for Trusted Testers since Chrome 148, with wider rollout "at a later date" — so plan for it, don't count on it yet.
Where scanning helps — and where it can't
Honesty time, because I build a catalog that scans store extensions: store-level scanning cannot see this class of threat at all. KREMLIN's extension has no listing, no publisher page, no store ID to look up — there's nothing for a catalog to hold. Anyone who tells you a store-URL checker catches forced installs is selling something.
What does help is inventory: knowing what your browser actually has loaded, and matching the store-installed part of it against known data. That's the split my tools make. npx @extenshi/guard list prints every extension registered in your browser profiles and where each one came from — locally, with no account and nothing leaving your machine. npx @extenshi/guard scan (it needs a free account) then checks the ones installed from a store against the catalog and flags the ones that deserve a second look, while extensions loaded from a local folder are listed rather than analyzed. An unfamiliar name in that second bucket is precisely the signal this article is about. One caveat I owe you: Guard reads the same profile files KREMLIN writes, so the "where it came from" label is whatever the entry declares. Trust the inventory; question the label.
For the store-installed ones, the checker takes a single store URL and gives you that extension's security report: safety score, permissions, and what Extenshi's scans found.
Scan the extensions you installed from a store with Guard → — and browse the catalog to see what the store-installed side of your browser looks like from the outside.
Sources
- The extension you never installed: KREMLIN forges Chrome's own integrity checks to steal banking sessions — Elastic Security Labs (September 14, 2026), the primary research: campaign history, the install sequence, the extension's capabilities, the wallet figures and the canary-domain count.
- Malware bypasses browser checks to force install Chrome, Edge extensions — BleepingComputer (Bill Toulas, September 16, 2026), reporting the Elastic research.
- The Phantom Extension: Backdooring chrome through uncharted pathways — Synacktiv (September 23, 2025), the technique Elastic says KREMLIN uses, and the advice to defenders.
- Tracked preferences README and chrome_pref_service_factory.cc — Chromium source (read November 18, 2026), for how the integrity checks work and which platforms enforce them.
- Snow Flurries: How UNC6692 Employed Social Engineering to Deploy a Custom Malware Suite — Google Threat Intelligence (Mandiant), on the SNOWBELT sideload vector.
- Google Chrome may soon block New Tab hijacker extensions by default — BleepingComputer, on policy-layer abuse and Google's planned defense.
- chrome.management API reference — Chrome Developers, for
getAll()andinstallTypesemantics. - Chrome Enterprise and Education release notes, previous releases — Google, for extension DOM activity telemetry and the
ExtensionDOMActivityLoggingEnabledpolicy (Chrome 146–148 notes).
This article is based on publicly available security research and news reporting. Extenshi does not independently verify all claims made by third-party researchers. References to specific companies or products reflect the findings of cited sources and do not constitute accusations of intentional wrongdoing. If you believe any information is inaccurate, please contact us at [email protected].
Related Articles

Browser extension sideloading attacks: how to detect SNOWBELT before it owns your enterprise
A sideloaded browser extension is how UNC6692's SNOWBELT runs inside headless Edge, skipping Web Store review entirely. Here's how to detect it in your org.

New tab overrides explained: what an extension that replaces your new tab can really see
Replacing your new tab page takes no permission at all. Here's what a new tab override extension can really see, when it's fine, and how to check yours.

chrome.management in browser extensions: build a permission audit popup
A hands-on Manifest V3 tutorial: use the chrome.management API and Chrome's own permission warnings to audit every extension installed. Full runnable code.

Zero-permission malware droppers: how to check if any of your extensions can be weaponized
A zero-permission extension can still drop malware: LayerX Labs showed any extension can silently backdoor your downloads. How to check and stay safe.