USB Shortcut Windows Crypto Clipper Uses Tor SOCKS Backdoor to Steal Wallets

Microsoft said on June 17, 2026, that its threat intelligence teams have tracked a Windows cryptocurrency clipper active since February 2026 that spreads through malicious shortcut files on USB drives, launches a bundled Tor proxy, and uses script-based components to steal wallet data. The important part is not simply that another clipper exists. It is that the malware turns an old Windows infection path into a modern, anonymized control channel. For defenders, this campaign is a reminder that removable media, Windows Script Host, scheduled tasks, and localhost proxy traffic still form a dangerous attack surface when attackers combine them carefully.

Illustration of a USB-based Windows attack chain with deceptive .lnk files, script execution, proxy routing, and data theft.A Clipboard Thief Becomes a Backdoor​

Cryptocurrency clippers are usually described as narrow financial malware. They watch the clipboard, look for wallet addresses, and swap in an attacker-controlled address before the victim pastes and sends funds. That model is ugly but simple: steal the moment of payment, then disappear into the irreversible mechanics of cryptocurrency transfer.
Microsoft’s newly detailed campaign is more ambitious. The malware does perform classic clipper behavior, but it also steals seed phrases and private keys, captures screenshots, polls a command-and-control server, and can execute attacker-supplied JScript through an EVAL-style response. That moves it beyond opportunistic theft and into the territory of a lightweight remote-access tool.
The distinction matters because a clipper that only substitutes wallet addresses is mostly a transaction risk. A clipper that can receive runtime instructions is a foothold. Once an infected Windows machine is beaconing over Tor and accepting code from a hidden service, the attacker has more than a cash register skimmer; they have a small, scriptable beachhead inside the user’s environment.
Microsoft’s write-up frames the campaign around behavior rather than branding, which is the right emphasis. Hashes and filenames will age quickly. The combination of Windows Script Host, ActiveX-driven logic, curl, a local SOCKS5 proxy on port 9050, and scheduled-task persistence is the pattern defenders should remember.

The USB Shortcut Trick Refuses to Die​

The initial access path is almost retro: malicious .lnk files distributed on USB storage devices. In Microsoft’s analyzed cases, the shortcut does not merely launch a payload. It stages a worm component, checks whether the device has already been infected, and then helps the malware spread by manipulating what the user sees on removable media.
That technique works because it attacks user expectation. A person plugs in a drive and sees familiar-looking document names: PDFs, spreadsheets, Word files. The malware hides the original files and creates shortcut files with the same names, so the victim believes they are opening a document when they are actually launching an executable chain.
This is not a new social-engineering idea, but it remains effective because USB drives still occupy a strange trust zone in Windows environments. They are both personal and operational. People move tax documents, wallet backups, driver installers, firmware files, photos, and work material with them, often across machines that have very different security postures.
For enterprises, removable media policy tends to oscillate between blanket bans and quiet exceptions. For home users, the policy is usually hope. This campaign exploits the gap between those worlds: the Windows behavior is familiar, the user interface is plausible, and the infection path does not require a phishing page, a malicious macro, or an exposed internet service.

Microsoft’s Threat Story Is Really About Windows Plumbing​

The malware’s execution chain leans heavily on Windows components that defenders cannot simply delete. Microsoft says the clipper runs as a script-based payload interacting with the operating system through WScript and ActiveXObject. It uses scheduled tasks for persistence. It invokes command-line tooling for network activity. It even performs a basic anti-analysis check by querying running processes and exiting if Task Manager is detected.
None of that is exotic. That is precisely why the campaign is uncomfortable.
Windows Script Host exists for automation. Scheduled tasks exist for maintenance, deployment, and routine operations. Curl is now a normal part of modern Windows administration. PowerShell screen capture or process chains may be suspicious in one context and perfectly legitimate in another. The malware’s strength lies in assembling ordinary parts into an abnormal sequence.
This is why Microsoft’s defensive guidance stresses behavioral detection. If a script interpreter spawns curl, cmd.exe, PowerShell, or an unexpected executable, that process chain deserves attention. If that activity coincides with localhost SOCKS5 traffic, .onion destinations in command lines, clipboard inspection, or screenshot capture, the case becomes far stronger.
The story here is not that Windows has one magic switch that prevents this class of malware. It is that defenders need enough telemetry to connect events that look only mildly suspicious in isolation. A scheduled task may be routine. A script process may be routine. Curl may be routine. A local Tor proxy, clipboard scraping, and script-driven screenshots are not routine when they arrive together.

Tor Gives a Small Stealer Big-Campaign Discipline​

The bundled Tor client is the campaign’s most important architectural choice. Microsoft says the malware launches a renamed Tor binary, ugate.exe, in a hidden window, waits about 60 seconds for Tor to bootstrap, and routes command-and-control traffic through a local SOCKS5 proxy at 127.0.0.1:9050. The destination is a hidden-service C2 server rather than a conventional exposed IP address.
That changes the defender’s problem. Blocking a known IP address is easy if the attacker gives you one. Looking for DNS queries is useful if the malware resolves conventional domains. Tor hidden services weaken both approaches by pushing the useful destination information into a tunnel and leaving defenders to focus on local behavior and process command lines.
The malware still has to make noise on the endpoint. It has to launch Tor. It has to use curl with a SOCKS proxy. It has to poll endpoints such as command retrieval and file upload paths. It has to move stolen data out. But the final C2 infrastructure is deliberately harder to enumerate and block from the network edge alone.
This is a familiar trend in financially motivated malware: attackers borrow operational security ideas from more sophisticated intrusion sets, but apply them to commodity theft. The result is not necessarily elegant. Microsoft describes a Task Manager check that is simple enough to seem almost crude. But the crude parts are wrapped around a more resilient communication model, and that combination is often good enough.

The Malware Steals the Moment Before the Money Moves​

The clipper’s collection logic targets the most sensitive material in cryptocurrency workflows: seed phrases, private keys, and wallet addresses. Microsoft says it monitors the clipboard roughly every 500 milliseconds, looking for wallet-related patterns. When it finds 12- or 24-word BIP39 seed phrases, it saves them locally as a backup, exfiltrates them through Tor, retries until acknowledged, and then deletes the backup after successful transmission.
That workflow reveals the attacker’s priorities. A wallet address substitution can steal a single payment. A seed phrase or private key can empty a wallet, compromise future funds, and bypass the victim’s device entirely once the secret is in the attacker’s hands.
The screenshot behavior is also telling. Microsoft says the malware captures multiple screenshots after stealing certain wallet artifacts, apparently to provide context about the user’s wallet, balances, or on-screen activity. In other words, the attacker is not merely collecting strings. They are collecting situational awareness.
Address replacement remains part of the campaign. The malware probes for several cryptocurrency address formats, including Bitcoin legacy, P2SH, Taproot, Bech32, Tron, and Monero patterns. In some cases, it substitutes attacker addresses that match visible portions of the original address, a small deception meant to defeat the user’s quick glance.
That deception works because many crypto users have been taught to verify the beginning and end of an address, not every character. The attacker’s bet is that a plausible prefix or suffix will pass a hurried check. It is a technical attack on the clipboard, but also a behavioral attack on how people verify risk under routine conditions.

The EVAL Command Is the Line Between Theft and Control​

The most consequential detail in Microsoft’s analysis is the command path. The malware registers the infected device with a victim GUID, polls the C2, and can process an EVAL response that executes arbitrary JScript code at runtime. Microsoft also describes a cfile created on the infected system as output for payload hosted on the C2 domain.
That capability changes incident response. If an organization finds only evidence of clipboard theft, it may be tempted to scope the event as a financial malware incident. But a runtime code execution path means responders must ask what else was delivered, what commands were issued, and whether the host was used for follow-on activity.
The campaign’s worm component adds another complication. The malware creates malicious shortcuts for legitimate files it finds on the device and uses scheduled tasks for both spreading and stealing. That means a single infected workstation may be both victim and distribution point, especially in environments where USB drives pass between kiosks, admin laptops, personal machines, and operational systems.
Microsoft’s observed detections include suspicious JavaScript processes, suspicious Python library loads, suspicious Task Scheduler activity, path and process exclusions, possible exfiltration using curl, and Tor-related curl behavior. The spread of detections reflects the spread of the malware itself: it is not one binary doing one thing. It is a small ecosystem of script, executable, proxy, persistence, and exfiltration activity.
For defenders, the EVAL capability should raise the severity. The financial lure is the visible motive, but remote code execution is the durable risk. Even if the attacker’s primary goal is wallet theft, a machine that accepts arbitrary script from a Tor hidden service cannot be treated as a mere nuisance infection.

Defender Exclusions Are the Alarm Bell Inside the Alarm System​

One of the more pointed details in Microsoft’s report is that the worm excludes staging folders and Windows binaries used in execution from Defender scanning. Malware attempting to tamper with or carve out security exclusions is not unusual, but it is especially important in this campaign because the rest of the chain is intentionally lightweight.
If the attacker can persuade the endpoint to stop inspecting the paths that matter, the scripts and dropped payloads get more room to operate. Microsoft says the malware drops decrypted payloads, including two malicious JavaScript files, under a subfolder of C:\Users\Public\Documents, using a five-character naming convention for both the folder and script names. That public documents path is not inherently suspicious, but the combination of random-looking names, Defender exclusions, and scheduled-task execution is.
This is where home users and small businesses are especially exposed. A large enterprise may have centralized monitoring for Defender policy changes, suspicious exclusions, or attack surface reduction events. A home user may only see that Windows Security is quiet. A small office may assume that if Defender did not show a dramatic alert, nothing serious happened.
The campaign is a case study in why endpoint protection needs policy discipline, not just malware signatures. If users or local scripts can create broad exclusions without scrutiny, the endpoint’s protective model becomes negotiable at the exact moment it needs to be firm.

Static IOCs Are Useful, but the Behavior Is the Product​

Microsoft published hashes, Tor hidden-service domains, and filenames associated with the campaign. Those indicators are useful for immediate hunting, especially for organizations that can sweep endpoint and proxy logs quickly. But the article’s deeper value is behavioral: it describes the shape of the attack in a way that survives the next recompile.
A future sample can rename ugate.exe. It can change five-character folder names. It can rotate .onion services. It can adjust endpoint paths. It can mutate JavaScript obfuscation and packaging. What is harder to hide is the need to launch a local proxy, poll command infrastructure, inspect the clipboard, manipulate wallet strings, persist with scheduled tasks, and exfiltrate screenshots or secrets.
This is the security industry’s recurring problem with financially motivated malware. The cheap parts change constantly, while the operational requirements remain stable. If defenders chase only the cheap parts, they are always late. If they model the operational requirements, they have a chance to catch the next variant.
Microsoft’s recommended hunting logic points in that direction. Look for scheduled tasks created from suspicious public document paths. Look for curl command lines using --socks5-hostname and localhost:9050. Look for script interpreters launching network tooling. Look for PowerShell screen-capture behavior. Those are not perfect signals, but together they narrow the field dramatically.

Where Windows Administrators Should Actually Tighten the Screws​

The practical defense is not glamorous. Disable AutoRun and AutoPlay for removable media. Block .lnk execution from removable drives where possible. Restrict Windows Script Host and related interpreters where the business does not need them. Review Attack Surface Reduction rules for obfuscated scripts and suspicious child-process behavior. Hunt for local Tor proxy activity.
The difficulty is that every one of those recommendations collides with convenience somewhere. Some organizations still rely on USB media for air-gapped workflows, field service, manufacturing equipment, lab instruments, or data transfer from legacy systems. Some line-of-business software still uses scripts in ways that make blanket restrictions politically difficult. Some administrators tolerate broad local rights because support queues are already overloaded.
But this campaign is an argument for narrowing exceptions. If removable media is necessary, it should be governed. If scripts are necessary, they should be scoped and logged. If users handle cryptocurrency wallets or other high-value secrets, those workflows should not take place on general-purpose Windows systems exposed to random USB drives.
The last point may sound severe, but it follows from the threat model. A seed phrase copied to the clipboard is a secret temporarily placed in one of the most accessible interprocess spaces on the desktop. Malware that polls the clipboard twice a second does not need kernel exploits or browser zero-days. It only needs the user to perform a normal wallet operation on a compromised machine.

Crypto Users Are the Canary for Everyone Else​

It is tempting to file this campaign under “crypto problems” and move on. That would be a mistake. Cryptocurrency users are attractive targets because the theft is fast, final, and easy to monetize, but the underlying techniques apply well beyond wallets.
Clipboard theft can target passwords, API keys, recovery codes, bank details, remote-access commands, cloud tokens, and internal URLs. Screenshot capture can reveal dashboards, customer records, SSH sessions, invoices, or privileged admin portals. A Tor-routed backdoor can be used to stage additional payloads long after the original financial theft attempt.
The crypto angle simply makes the attacker’s business model obvious. The malware is built to recognize wallet artifacts because those artifacts are valuable and structured. But the same endpoint foothold could support broader data theft or lateral movement if the operator decided the infected environment was worth more than a one-time wallet hit.
That is why the campaign belongs on the radar of sysadmins who do not personally care about Bitcoin, Tron, Monero, or Ethereum. The malware is abusing Windows behaviors, not blockchain behaviors. The victim’s wallet is the monetization path, but the compromised Windows host is the platform.

The Old Windows Hygiene Lecture Just Got a Tor Proxy​

There is a weary familiarity to the mitigations, but this campaign gives them fresh urgency.
  • Organizations should treat malicious shortcut files on removable media as an active enterprise risk, not a relic of older Windows malware.
  • Endpoint teams should investigate script interpreters that spawn curl, PowerShell, cmd.exe, or unexpected executables, especially when those chains touch public document paths.
  • Local SOCKS5 activity on 127.0.0.1:9050 should be hunted in context, because Tor bundled inside malware is different from a user intentionally running a privacy tool.
  • Devices used for cryptocurrency transactions or other high-value secret handling should not share the same trust level as general browsing, email, and USB workflows.
  • Defender exclusions, scheduled-task creation, clipboard inspection, and screen capture become much stronger signals when they appear together.
  • Static indicators from this campaign are useful for immediate sweeps, but long-term defense depends on detecting the behavior that the next variant will still need.
The broader lesson is not that every Windows machine is doomed by scripts, shortcuts, and Tor. It is that attackers continue to find leverage in the seams between user trust, legacy compatibility, and administrative convenience. Microsoft’s report is a useful warning because it shows a financially motivated campaign modernizing around those seams: old removable-media tricks at the front, anonymized C2 in the middle, and runtime code execution at the back. The next version may change names, hashes, and hidden services, but the defensive challenge will remain the same: make ordinary Windows plumbing visible enough that ordinary abuse no longer looks ordinary.

References​

  1. Primary source: Microsoft
    Published: Wed, 17 Jun 2026 23:11:43 GMT
 

Back
Top