CYBERRAKSHAK LABS · RESEARCH #085

🛡️ Fake Security Tools on GitHub: How Trojanized Developer Projects Deliver Backdoors, Clippers and Infostealers

How trojanized developer projects deliver backdoors, clippers and infostealers

By Vivek Kumar · Published 7 November 2026
RESEARCH#085
CATEGORYMalware / Developer Supply-Chain / Infostealer / Backdoor
CRL ASSESSMENTTHREAT CAMPAIGN ANALYSIS
RESEARCH LEVELPublic Awareness
PUBLISHED2026-11-07
Source & social links:
LinkedIn Post ↗ WhatsApp ↗ YouTube ↗
How CyberRakshakLabs researches threats →
A GitHub repository that looks like a useful security utility can become the first step in a malware infection. Doctor Web describes a campaign that hides execution logic in Visual Studio, Python and Go projects before deploying remote-access, clipboard-stealing and information-stealing payloads.
Source and methodology:

This article follows the supplied report and distinguishes Doctor Web’s documented findings from analytical implications. The reported IOC set is historical; validate indicators against current source data and local telemetry before operational blocking. Doctor Web did not publicly attribute the activity to a named threat group or country.

Executive summary

Doctor Web reported on 5 November 2026 that a long-running campaign distributing trojanized GitHub repositories has shifted from cryptocurrency and gaming lures toward information-security professionals. Malicious code was found in Visual Studio project files (.suo and .csproj), Python scripts and Go source files. More than 2,000 PCs were infected at the time of Doctor Web’s investigation.

The infection chain begins when a user downloads and opens or builds a malicious project. Hidden PowerShell execution retrieves encrypted configuration and a second-stage archive, which installs an Electron-based loader identified as Microsoft.exe / Trojan.Loader.3261. The loader establishes persistence, elevates privileges, weakens Windows security and injects payloads into legitimate processes. Reported final components include AsyncRAT, a cryptocurrency clipboard clipper and JS.Stealer.191. The stealer collects browser and developer-tool configuration data and exfiltrates it through a Telegram bot.

Malicious GitHub repository Source: GitHub

Malicious GitHub repository used as a lure
Malicious GitHub repository · Source: GitHub
1. Campaign history and evolution

Doctor Web dates the first infected repositories to approximately two years before its 5 November 2026 report. Early repositories contained Visual Studio projects associated with blockchain games, game bots and cheating tools and were aimed at cryptocurrency-wallet users and gaming communities. The operators later pivoted to repositories marketed as security utilities for scan automation, security-system testing and log analysis.

The recent lure included a fake Fscan output parser advertised as a lightweight utility to parse, clean and format Fscan network scanner output. This is a supply-chain-style social-engineering technique: the attacker abuses the trust developers place in public source repositories and the assumption that source code is inspectable.

Doctor Web did not publicly identify the operator by name, nationality or formal threat-group designation. The campaign’s two-year duration and changing lures are known from the report; attribution beyond that is not established.

2. Attack classification

Primary classification: trojanized open-source repository / developer supply-chain compromise, delivered through social engineering and malicious project execution.

Execution methods: Visual Studio pre-build event execution, malicious PowerShell, concealed code in Python and Go files, encrypted second-stage retrieval and process injection.

Payload categories: remote-access backdoor (AsyncRAT), cryptocurrency clipper, and information stealer.

Defence evasion: parent-process spoofing, Smart App Control registry modification, ntdll unhooking, direct system calls (Halo’s Gate), ETW and AMSI patching, Defender exclusions and removal of third-party security products.

Developer accessing a weaponized repository and staged malware execution
Source illustration
3. Initial access and repository deception

Visual Studio projects: Doctor Web found .csproj files with a PreBuildEvent routine that runs code before compilation and .suo files containing PowerShell commands. The operator also provided installation and repository-cloning instructions, lowering the technical barrier for less experienced users.

Python and Go source: malicious content was concealed behind large amounts of whitespace. This technique exploits hurried code review and the tendency to trust a repository because it contains plausible utility code.

Trust abuse: the repository is the lure, and executing/building the project is the trigger. GitHub hosting itself is not the vulnerability; the malicious content is placed in user-controlled repositories.

Fake GitHub repository lure leading to an infostealer
4. Technical infection chain
4. Technical infection chain

Stage 1 — Repository acquisition: a developer or security analyst clones/downloads a fake tool, such as an Fscan output parser, or obtains a Visual Studio project.

Stage 2 — Execution trigger: a Visual Studio pre-build event or malicious Python/Go component executes hidden code. Doctor Web identified PowerShell.Packed.270 and example script paths C:\Users\Public\Pictures\t.ps1 and L.ps1.

Stage 3 — Configuration retrieval: PowerShell queries attacker infrastructure and legitimate services including YouTube, Telegram, Google Docs, GitCode and Pastebin. It retrieves an encrypted string which resolves to a download link.

Stage 4 — Archive and loader: Quixo.7z is downloaded from attacker infrastructure or GitHub and unpacked under C:\ProgramData\Windows.Microsoft.Photos. The Electron application Microsoft.exe (Trojan.Loader.3261) then downloads Nexara.7z containing encrypted payloads and configuration.

Stage 5 — Host preparation: the loader collects system information, configures automatic restart/persistence, attempts privilege elevation, disables Windows Defender, UAC, notifications, System Restore and Volume Shadow Copy Service, adds Defender exclusions and modifies the hosts file.

Stage 6 — Defence evasion and injection: Mode3 uses explorer.exe parent-process spoofing, Smart App Control policy modification, ntdll unhooking, Halo’s Gate direct system calls, ETW patching and AMSI patching. It injects modules into processes such as RegAsm.exe, dwwin.exe or dwm.exe. If Mode3 fails, Mode2 uses Defender exclusions and PowerShell to decrypt/inject modules into RegAsm.exe.

Stage 7 — Payload execution: two AsyncRAT instances and Trojan.InjectNET.14 are deployed; the latter injects the clipper. JS.Stealer.191 is unpacked and launched.

Stage 8 — Collection and exfiltration: browser data, VPN settings, FTP client configuration, messenger files, gaming accounts and Discord tokens are compressed and sent to attackers via Telegram bot infrastructure.

Doctor Web infection chain showing loader and payload deployment
Infection chain · Source: Dr. Web
5. Malware components and impact

Microsoft.exe / Trojan.Loader.3261: modular Electron-based loader; persistence, privilege elevation, security impairment, module delivery and process injection.

BackDoor.AsyncRAT.115: remote-access capability giving operators control of the infected host. Doctor Web observed two similar AsyncRAT payload files using different network ports; it suggested this may permit two operators to control one device, but this remains an interpretation.

Trojan.InjectNET.14 / Trojan.Clipper.688: clipboard monitoring and replacement of cryptocurrency wallet addresses. Doctor Web also reported screenshots and contextual details (clipper version, active window title, user login and device IP) sent to a Telegram bot.

JS.Stealer.191: collects browser data, FileZilla XML, MobaXterm.ini, Total Commander wcx_ftp.ini, VPN settings, messenger files, video-game and game-platform account data, and Discord tokens.

Operational impact: stolen VPN and FTP configurations can expose remote-access pathways; browser and messaging data can support account takeover and targeted phishing; Discord and gaming accounts may be monetized or abused; clipboard replacement can redirect cryptocurrency transfers; AsyncRAT can enable further hands-on-keyboard activity.

Infection chain Source: Dr. Web

6. Defence evasion and persistence

Mode3 techniques documented by Doctor Web include PPID spoofing, changing VerifiedAndReputablePolicyState to disable Smart App Control, restoring clean ntdll.dll bytes to remove EDR hooks, Halo’s Gate direct system calls, patching EtwEventWrite to suppress ETW telemetry and patching AmsiScanBuffer to interfere with script scanning.

Mode2 fallback adds RegAsm.exe and dwm.exe to Defender exclusions, decrypts modules through PowerShell and injects them into RegAsm.exe. Doctor Web also observed removal attempts against ESET, McAfee and Malwarebytes, blocking access to antivirus update servers through hosts-file modification and interference with Windows backup files.

An unfinished component in Lodge.7z suggests planned improvements: service-based persistence, checking whether Microsoft.exe remains on disk and downloading it again if missing, application-startup control and updating. Doctor Web described these as possible future features, not all as active behaviours in the observed build.

Code excerpt showing antivirus detection and removal logic
Infection chain · Source: Dr. Web
7. Threat actor assessment

Threat actor identity: unknown in the cited public reporting. Doctor Web described the activity as a threat-actor campaign but did not assign it to a named APT, criminal group, individual or country.

Targeting assessment: the pivot toward security scanning, testing and log-analysis projects indicates deliberate interest in infosec users and developer workstations. These systems may contain VPN profiles, FTP credentials, browser sessions, tokens and access to internal test environments. This is a reasonable risk assessment from the targeted tool themes and collected data types, not proof of a specific espionage objective.

Do not attribute the activity to a known ransomware group or state-sponsored actor without additional evidence.

8. Indicators and detection opportunities

Doctor Web’s public IOC repository lists SHA-1 hashes for malicious .suo, .csproj, resource.go, FscanOutput_v2.2.py, PowerShell scripts, Microsoft.exe app.asar, JS.Stealer.191 and decrypted payloads. It also lists domains muckanthropic[.]com, muckduck.duckdns[.]org, muckcoding[.]com and muckdeveloper[.]com; IP addresses 130[.]12.182[.]172 and 130[.]12.182[.]209; and multiple malicious GitHub repositories and staging URLs.

Useful host hunting themes: unexpected PowerShell launched during Visual Studio build; PreBuildEvent commands in unfamiliar .csproj files; suspicious .suo contents; Python/Go files with unusually large whitespace regions or hidden trailing content; downloads of Quixo.7z or Nexara.7z; Microsoft.exe under unusual paths; execution/injection involving RegAsm.exe, dwwin.exe or dwm.exe; changes to Defender exclusions, Smart App Control policy, hosts file, System Restore/VSS and antivirus installation state.

Network hunting: outbound connections to the domains/IPs and staging services listed in the Doctor Web IOC repository; Telegram bot communications; retrieval of encrypted configuration from Pastebin, Google Docs, YouTube, GitCode or GitHub release assets. Legitimate platform use alone is not an IOC; correlate destination, process lineage and timing.

IOC caveat: indicators can become stale or be shared hosting. Validate hashes and domains against the current Doctor Web feed and local telemetry before blocking.

9. Protection guidance for developers and security teams

Do not execute or build a repository merely because it is hosted on GitHub or has a polished README. Review project files, build scripts, pre-build/post-build events, package scripts and all code paths before execution.

Inspect .csproj and .suo files for commands and unexpected build events. Search Python and Go files for suspicious obfuscated strings, hidden code after whitespace, subprocess calls, PowerShell invocation and remote download logic.

Use disposable, isolated virtual machines or sandboxed build runners for untrusted repositories. Do not expose corporate VPN profiles, SSH keys, browser sessions, cloud credentials, GitHub tokens or production secrets to the test environment.

Run development environments with least privilege. Avoid building unknown code on a workstation with local administrator rights.

Enable endpoint protection with tamper protection and centralized telemetry. Alert on Defender exclusions, Smart App Control policy changes, AMSI/ETW tampering, unusual process injection and security-product removal.

Use application allowlisting, controlled build pipelines, signed internal artifacts, repository allow-lists and peer review for tools used by security operations.

Rotate VPN/FTP credentials, browser sessions, Discord tokens and other secrets from a clean device if compromise is suspected. Revoke active sessions and review access logs.

Check clipboard contents before confirming cryptocurrency transfers; use address allow-lists or hardware-wallet verification for high-value transactions.

10. Incident response checklist

Isolate the endpoint from corporate networks while preserving forensic evidence.

Collect the repository URL, commit/release identifier, files executed, timestamps, Visual Studio build logs, PowerShell logs, EDR telemetry and network/DNS records.

Search for Microsoft.exe, Quixo.7z, Nexara.7z, the named payloads and the paths documented by Doctor Web.

Inspect persistence, scheduled tasks/services, startup entries, Defender exclusions, Smart App Control registry values, hosts file, VSS/System Restore state and antivirus health.

Revoke browser sessions, Discord tokens, VPN credentials, FTP credentials and any exposed API/cloud/GitHub tokens. Rotate secrets from a known-clean device.

Rebuild from trusted media if loader execution or privileged compromise is confirmed; do not rely solely on deleting the visible repository or executable.

Search other developer and analyst workstations for the same repository names, hashes, domains, process chains and credential exposure.

11. Timeline

Approximately November 2024: Doctor Web dates the first infected repositories to around two years before its 5 November 2026 publication. The earliest described lures targeted cryptocurrency wallet users through blockchain game, bot and cheat-tool projects.

Later campaign phase (date not specified by Doctor Web): operators pivot to information-security professionals, embedding malicious code in scanning automation, security testing and log-analysis projects.

5 November 2026: Doctor Web publishes its technical report and IOC set, reporting more than 2,000 infected PCs at the time of its research.

6 November 2026: BleepingComputer reports the findings, including the Fscan-output-parser lure, loader behaviour and payload families.

Operational sequence: repository lure → project clone/download → pre-build/script execution → PowerShell configuration retrieval → encrypted archive/loader → persistence and defence evasion → AsyncRAT/clipper/stealer → data theft and remote access.

12. Conclusion

This campaign demonstrates that developer tooling can be weaponized as an initial-access vector. Security professionals are not immune: tools that automate scans, parse logs or test security controls may have broad local permissions and access to valuable credentials. The safest practice is to treat every unfamiliar repository as untrusted code, inspect build-time execution paths, run it in an isolated environment and protect developer endpoints as high-value assets.

Sources