Inside Vidar: Reverse Engineering a Protected Infostealer That Hides Its C2 Behind Steam
From social engineering and an astronomy-themed Go loader to encrypted payloads, virtualized strings, credential theft, and dead-drop command-and-control infrastructure.
By Cyberkarta Malware Research Team | November 18, 2026

TL;DR
Our research investigated a Windows malware sample associated with the Vidar 2.x infostealer family. What initially appeared to be an astronomy-themed Go application turned out to be a loader concealing a protected information-stealing payload.
Through static reverse engineering and examination of sandbox evidence, we identified several important characteristics:
- Go-based loader: A 4.8 MB Windows executable disguises itself as an astronomy application while carrying an encrypted second-stage payload.
- Encrypted payload: The loader reconstructs an approximately 1 MB Windows PE using five decoding passes before transferring execution to it.
- String virtualization: The recovered payload implements a custom 14-opcode virtual machine used to hide sensitive strings and configuration data.
- Credential theft capabilities: Recovered code and strings indicate targeting of browser credentials, cookies, cryptocurrency wallets, Telegram, Discord, Steam, FileZilla, and Azure authentication artifacts.
- Dead-drop C2: Vidar uses Telegram and Steam profiles as intermediary locations for discovering command-and-control servers.
Public investigations have also documented Vidar distribution through ClickFix and TermFix social-engineering campaigns, where users are deceived into executing malicious commands disguised as verification procedures.
The most significant discovery is how the malware separates its executable code from its C2 infrastructure, reducing the value of conventional static string searches.
1. Introduction: An Infostealer Behind an Astronomy Application
Information stealers remain a serious threat because a successful infection can expose more than just passwords.
Browser session cookies, authentication tokens, cryptocurrency wallets, and cloud credentials may enable attackers to access accounts without needing the victim’s original password.
Vidar is an information-stealing malware family known for targeting this type of sensitive information.
For this research, we analyzed a Windows executable with the following characteristics:
- SHA-256: d1d7865b26feef581aefde9d2b12cb4e1b420d9fc41adbcf3eb86b65677e32c6
- File type: Windows PE32+ executable
- Architecture: x86–64
- File size: 4,818,944 bytes
- Compiler indicator: Go 1.25.4
- Recovered payload: Windows PE32+ executable
- Malware assessment: Consistent with Vidar 2.x
The executable contained references to an application named Orbital Survey & Astrometry Console, including astronomy-related strings such as Helios Prime and Trajectory previews.
However, reverse engineering revealed a very different purpose.
Rather than functioning solely as an astronomy application, the executable contained an encrypted payload and code responsible for reconstructing and executing it in memory.
This created two distinct layers for analysis: the initial Go loader and the protected second-stage stealer.
2. From Fake Verification to Infection: How TermFix Delivers Vidar
Before investigating what Vidar does after execution, it is important to understand how attackers convince users to execute malicious code in the first place.
Malware delivery does not always require a zero-day vulnerability, browser exploit, or direct compromise of the operating system.
Sometimes, the most effective entry point is the user’s own interaction.

What is ClickFix and TermFix?
ClickFix is a social-engineering technique that tricks users into manually executing malicious commands under the pretense of resolving a technical problem or completing a security verification.
Attackers commonly disguise malicious instructions as:
- Cloudflare security verification.
- CAPTCHA or human-verification checks.
- Browser errors requiring manual intervention.
- Software compatibility or update procedures.
- Missing application components.
TermFix is a variation of this technique that directs victims to execute attacker-supplied commands through Windows Terminal or another command shell.
The critical distinction is that attackers do not necessarily need to exploit the browser.
Instead, they convince the user to transfer an instruction from a webpage into a trusted operating-system tool.
This transforms a seemingly harmless verification process into a malware execution opportunity.
How the infection works
A typical TermFix infection chain begins when a user visits a legitimate website that has been compromised.
The attacker injects malicious JavaScript or other content into the website, causing visitors to encounter a fraudulent verification page.
The page may resemble a familiar Cloudflare security challenge, making it appear credible.
The victim is instructed to complete additional verification steps.
Behind the scenes, malicious JavaScript places a command on the user’s clipboard.
The page then instructs the user to open Windows Terminal, paste the clipboard contents, and execute the command.
Once the command is executed, an additional script or loader may retrieve and launch the malware.
The infection sequence can be summarized as follows:
- Compromised website: The victim visits a legitimate website containing attacker-injected content.
- Fake verification: A fraudulent CAPTCHA or Cloudflare-style security prompt appears.
- Clipboard manipulation: JavaScript places an attacker-controlled command onto the clipboard.
- Terminal execution: The victim follows instructions to paste and execute the command in Windows Terminal or PowerShell.
- Payload delivery: The executed command initiates a malicious script, installer, or loader.
- Vidar execution: The delivered payload eventually launches the Vidar infostealer.
The user believes they are completing a security verification, but the requested action actually initiates malware execution.
Real-world case: ThaiCham website compromise
On August 26, 2026, an independent security researcher published an investigation into a compromised website belonging to the Thai Chamber of Commerce and Industry in Vietnam.
The legitimate WordPress website was displaying a fraudulent Cloudflare verification prompt.
The malicious page instructed Windows visitors to open Terminal and execute a command that had already been placed on the clipboard.
The campaign involved multiple delivery components, including PowerShell staging, a Polygon smart-contract-based resolver, and a packed native loader.
The recovered payload was identified as Vidar Stealer v2.
The investigation also recovered configuration information related to dead-drop resolvers, primary and fallback C2 infrastructure, and information-stealing capabilities.
This case demonstrates that a trusted website can become a malware delivery mechanism without the victim intentionally visiting an obviously malicious destination.
Source: ThaiCham Website Compromise: From a Fake Cloudflare Check to Vidar Stealer v2
Vidar distribution through compromised WordPress websites
The use of ClickFix-style techniques to distribute Vidar has also been documented by Malwarebytes and the Australian Cyber Security Centre.
In March 2026, Malwarebytes reported campaigns involving compromised WordPress websites that displayed fake CAPTCHA pages.
One documented infection chain used an HTA script that downloaded a malicious MSI installer.
The MSI subsequently executed a Go-based loader, which decrypted and launched the Vidar payload in memory.
In June 2026, the Australian Cyber Security Centre warned that threat actors were abusing compromised legitimate websites to distribute Vidar through deceptive verification prompts.
This attack model is particularly dangerous because it combines:
- Legitimate website infrastructure: The victim may trust the website they are visiting.
- Familiar security interfaces: Fake CAPTCHA and Cloudflare prompts create a sense of legitimacy.
- User-driven execution: The attacker persuades the victim to execute the command.
- Multi-stage delivery: Scripts and loaders can conceal the final malware.
- Trusted Windows utilities: Legitimate system tools may be abused to initiate execution.
The technique does not guarantee that endpoint security controls will be bypassed. However, it creates opportunities for attackers to evade controls that focus primarily on malicious file downloads.
Sources:
- Malwarebytes — Hacked Sites Deliver Vidar Infostealer to Windows Users
- Australian Cyber Security Centre — ClickFix Distributing Vidar Stealer
Relationship to our analyzed sample
The delivery techniques described above are documented in external Vidar campaigns.
Our research established the behavior of the recovered Go loader and protected Vidar payload. However, the supplied artifacts do not independently establish that this particular sample was delivered through a TermFix campaign.
We therefore treat TermFix as documented Vidar distribution context, not as a confirmed initial-access mechanism for our sample.
With that distinction established, we can examine the executable itself and understand what happens once the loader is launched.

3. First Stage: A Go Loader Concealing an Encrypted Payload
The first stage was developed in Go, and our analysis recovered approximately 2,196 functions, including 25 application-level functions.
Many functions were associated with the astronomy-themed application, creating substantial noise for anyone attempting to identify malicious functionality through a quick inspection.
A straightforward strings command was insufficient to reveal the complete malware capabilities or its actual C2 configuration.
Identifying the encrypted container
PE analysis identified a high-entropy data region embedded within the executable.
The relevant characteristics were:
- Container offset: 0x2C1918
- Container size: 1,012,436 bytes
- Entropy: 7.9986 bits/byte
- Decoder seed: 0x1344D
- Decoding passes: 5
The entropy measurement approached the theoretical maximum of eight bits per byte.
Although high entropy alone does not prove encryption, the reconstruction of a second PE executable from this region supports the conclusion that the container holds encoded payload data.
Reconstructing the payload
By investigating the application’s execution flow, we identified functions responsible for copying the embedded container, decoding its contents, and validating the reconstructed PE.
The relevant functions included:
- main.main — 0x140146100
- main.vzwdfhvdrtlug — 0x1400E2740
- main.qsfoaapp — 0x140113760
The decoding process applies five transformation passes using the seed 0x1344D.
After reconstructing the second-stage executable, the loader allocates memory with executable permissions and transfers control to the payload’s entry point.
The analysis identified allocation flags corresponding to MEM_COMMIT | MEM_RESERVE and PAGE_EXECUTE_READWRITE.
The resulting execution chain can be summarized as:
This design makes the first-stage executable substantially different from the functionality ultimately delivered to the infected system.
It also explains why analyzing only the original executable’s imports and plaintext strings would provide an incomplete understanding of the malware.
4. Second Stage: A Protected Vidar Infostealer
Once the second-stage payload was recovered, we obtained a Windows PE executable with the following SHA-256:
02ee94dbad4070af0fc115e3483449836a4bc8cfba878221591405e1c6d964f1
Unlike many conventional Windows executables, the recovered payload did not expose a normal import directory.
Instead, our analysis identified techniques associated with dynamic API resolution, encoded strings, and programmatic reconstruction of sensitive information.
These characteristics complicated static analysis because important functionality could not be identified through imports or obvious plaintext strings alone.
A custom virtual machine for string decoding
One of the most interesting discoveries was a custom 14-opcode string virtual machine.
The interpreter was identified at:
0x2400D6BBC
Its initialization routine was identified at:
0x2400D69DC
Rather than storing every important string in a directly readable format, the malware used this interpreter to reconstruct strings when needed.
Our offline analysis evaluated 219 call sites and recovered 123 decoded strings.
These recovered strings exposed information about targeted applications, data collection, anti-analysis routines, and network communication.
For malware researchers, this distinction is important.
A conventional string scanner searches for recognizable sequences already present in the binary. A virtualized decoder can conceal those sequences until the program reconstructs them.
Consequently, a failure to find an important string in the original file does not establish that the corresponding capability is absent.
5. What Information Does Vidar Target?
Our recovered strings and function analysis revealed code associated with multiple categories of sensitive information.
Browser credentials and session cookies
The analyzed payload contained code and strings associated with browser profiles, stored credentials, and cookies.
We also recovered indicators related to Chrome App-Bound Encryption, including:
- v20_com
- ChainingModeGCM
- Process-memory-related references
These findings suggest implementation of functionality relevant to handling Chrome’s newer browser encryption mechanisms.
However, the available evidence does not establish that the malware successfully bypassed Chrome App-Bound Encryption in the supplied execution.
Application and cloud credentials
Additional recovered strings suggested targeting of several applications:
- FileZilla: FileZilla: %s@%s:%s — Potential FTP credential collection.
- Telegram Desktop: tdata — Reference to Telegram's local application data.
- Discord: Discord: BCrypt unavailable — Indicates code interacting with cryptographic functionality associated with Discord data.
- Steam: SteamPath and libraryfolders.vdf — References to Steam installation and library information.
- Microsoft Azure: azureProfile.json — Potential Azure profile targeting.
- MSAL authentication: msal_token_cache.json — Reference to a Microsoft authentication token cache.
- Cryptocurrency wallets: Crypto: copied %d files — Indicates functionality associated with copying cryptocurrency-related files.
The Azure and MSAL findings are particularly noteworthy.
Infostealer activity is not limited to consumer accounts. Cloud authentication caches and application tokens can also become valuable targets, especially when infected endpoints belong to developers, administrators, or employees with privileged access.
An attacker obtaining usable authentication material may be able to compromise additional services beyond the originally infected machine.
Nevertheless, a string referencing an application does not prove that its credentials were successfully stolen.
Our conclusions about these targets are based primarily on reconstructed functionality, not confirmed theft of every data category.
6. Dead-Drop C2: Why Vidar Uses Steam and Telegram
One of the more distinctive aspects of the analyzed malware was its command-and-control discovery mechanism.
Ordinarily, malware may contain an embedded C2 address to which it connects after execution.
For example, the executable could contain a domain or IP address representing the attacker’s infrastructure.
This creates an operational disadvantage for the attacker: defenders may discover that endpoint, block it, or use it to track related infections.
A dead-drop resolver provides an alternative.
Instead of storing the final C2 address directly in the executable, the malware retrieves information from an intermediary resource, potentially hosted on an otherwise legitimate public platform.
The attacker can then modify the published content without necessarily changing the malware executable.
Vidar’s dead-drop mechanism
Our supplied dynamic-analysis artifacts identified attempts to access two resolver locations:
- hxxps://telegram[.]me/j0tt0s
- A Steam Community profile identified in the analysis logs.

The malware was configured to retrieve content from these locations and search for a specific separator word.
That separator word was:
d8b0m
The recovered string-decoding routine also exposed the following diagnostic template:
Dead drop: %s (sw: %s)
Here, sw refers to the separator word.
This gave us stronger evidence than simply observing a repeated string in a public profile.
The malware’s own diagnostic messages identified the marker’s role in its dead-drop processing logic.
What does d8b0m mean?
During the initial investigation, the exact purpose of d8b0m was uncertain.
The string could plausibly have represented a campaign identifier, encoded configuration value, or parsing marker.
The subsequent analysis resolved that uncertainty for this sample.
d8b0m is used as a separator word, or lookup marker, for locating relevant C2 information in dead-drop content.
The supplied Steam profile content followed a recognizable structure:
d8b0m ket.sm188dadu[.]top|
d8b0m jfr.sm188dadu[.]top|
d8b0m nhg.sm188dadu[.]top|
d8b0m ges.sm188dadu[.]top|
d8b0m bob.sm188dadu[.]top|
d8b0m kra.sm188dadu[.]top|
d8b0m sto.sm188dadu[.]top|
d8b0m rex.sm188dadu[.]top|
d8b0m bib.sm188dadu[.]top|
The listed addresses are defanged.
Based on the recovered parsing behavior, the marker identifies relevant entries, while the text following it represents candidate network destinations.
The pipe character (|) appears as a record delimiter.
This approach allows a public profile to function as a simple configuration delivery mechanism.
Importantly, it does not mean Steam itself is malicious or compromised. The technique abuses attacker-controlled content hosted on a legitimate platform.
The significance of this technique
The dead-drop mechanism separates three distinct components:
- The executable: Contains the resolver logic.
- The public resource: Contains candidate C2 information.
- The final C2 infrastructure: Hosts the attacker’s command-and-control services.
A defender examining the executable might initially discover only the public resolver address.
Even if the actual C2 server changes, the attacker may be able to update the external content without rebuilding the original payload.
From a threat-intelligence perspective, this makes the exact profile identifier, separator word, parser behavior, and final resolved endpoint separate pieces of evidence.
They should not be treated as interchangeable indicators.
IOC verification note: The supplied analysis archives and an earlier Steam screenshot contain different Steam profile identifiers and one differing subdomain label (jfr versus ljr). We have retained the archive-derived form above, but these discrepancies should be reconciled before distributing a finalized IOC feed.
7. What We Observed During Dynamic Analysis
The supplied research also included CAPE sandbox artifacts.
These provided additional evidence about the malware’s network behavior, although the environment did not successfully establish communication with a confirmed final C2 server.
The malware attempted to process the dead-drop content but received simulated responses that did not contain the expected separator word.
The diagnostic output included a message indicating that d8b0m could not be found.
The malware then attempted a fallback communication path.
Multipart HTTP requests
The sandbox evidence recorded 433 repeated requests, including multipart POST bodies of approximately 345 bytes.
Recovered fields included:
- hwid: Host identification.
- build_id: Possible build or campaign identifier.
- format: Requested data format, observed as json.
The captured build_id was:
5b1a4dd6b552d719906c7f798a3f7426
Additional static strings referenced token and mode, suggesting other request variants.
These network observations are significant because they establish that the program constructed and attempted outbound requests.
However, they also illustrate an important limitation.
The captured traffic did not demonstrate successful exfiltration of the targeted browser passwords, cookies, cryptocurrency wallets, or cloud tokens.
The observed requests are better characterized as registration, beaconing, or initial communication attempts.
This distinction matters when reporting malware capabilities.
A malware family may be capable of stealing numerous categories of information, but a particular analysis environment may not capture successful extraction or transmission.
A technically defensible report should distinguish implemented functionality from observed outcomes.
8. Detection Engineering: Building YARA and Suricata Rules
Following reverse engineering, we developed detection signatures based on recovered implementation details and network indicators.
The resulting detection package contains four YARA rules and six draft Suricata signatures.
YARA: Detecting the executable
YARA is designed to identify files based on patterns within their content.
For this case, the developed rules covered:
- Specific features of the astronomy-themed Go loader.
- Distinctive bytes associated with the recovered second-stage payload.
- Candidate family-level characteristics of the loader.
- Decoded strings associated with unpacked stealer functionality.
The loader-specific rule successfully matched the analyzed Go executable.
The payload-specific rule successfully matched the recovered PE.
However, these results establish detection against the particular analyzed files, not necessarily all Vidar variants.
The tentative family rules require testing against additional malware variants and representative benign Windows executables.
Suricata: Detecting network characteristics
Suricata detects network traffic based on packet and protocol characteristics.
Our draft signatures addressed:
- Multipart HTTP fields, including hwid, build_id, and format=json.
- Additional request templates referencing token and mode.
- DNS queries associated with the candidate parent domain.
- TLS SNI and HTTP Host indicators associated with the suspected infrastructure.
These signatures offer opportunities for identifying related activity where the relevant network data is visible.
However, an important limitation remains: the supplied Suricata rules have not yet been validated with the Suricata engine.
They should not be considered production-ready solely because their expected strings were found in test fixtures.
Proper validation requires syntax testing, offline traffic replay, and false-positive assessment.
Another consideration is encrypted traffic.
An IDS generally cannot inspect encrypted HTTPS request bodies unless the traffic is decrypted or otherwise made visible to the inspection engine.
Therefore, multipart body signatures may be ineffective against ordinary encrypted connections.
Why the dead-drop itself is a detection opportunity
Searching for all connections to Steam or Telegram would create excessive false positives because both are legitimate services.
More useful detection opportunities include correlating:
- Access to the specific suspicious resolver.
- Unusual process ancestry or unsigned executable activity.
- Subsequent connections to newly resolved network infrastructure.
- Host-side behavior consistent with credential collection.
- Network request formats independently confirmed in the malware.
This type of correlation is more defensible than treating an entire legitimate platform as malicious.
Detecting ClickFix and TermFix delivery
The entry point deserves detection coverage alongside the malware itself.
Organizations should investigate unusual browser-to-shell activity, especially when command execution follows visits to unfamiliar or compromised websites.
Useful behavioral indicators include:
- Unexpected PowerShell or Windows Terminal execution following web browsing.
- Command interpreters launching download utilities, script hosts, or installers.
- Suspicious clipboard-mediated command execution.
- Browser-delivered scripts initiating unexpected executable downloads.
- Unusual process ancestry involving scripting engines and installation utilities.
These indicators require contextual correlation to distinguish malicious activity from legitimate administrative work.
9. MITRE ATT&CK Mapping
The reconstructed implementation, public distribution research, and supplied network observations align with several MITRE ATT&CK techniques.
For the externally documented ClickFix and TermFix delivery campaigns:
- T1189 — Drive-by Compromise: Compromised websites were used to present malicious verification content.
- T1204.004 — User Execution: Malicious Copy and Paste: Victims were directed to paste and execute attacker-supplied commands.
- T1059.001 — Command and Scripting Interpreter: PowerShell: Malicious PowerShell commands initiated payload delivery.
For the analyzed loader and recovered Vidar payload:
- T1027 — Obfuscated Files or Information: The loader contains an encoded payload, while the recovered stealer uses string obfuscation.
- T1140 — Deobfuscate/Decode Files or Information: The loader reconstructs the second-stage executable using its decoding routine.
- T1497.001 — Virtualization/Sandbox Evasion: System Checks: Anti-analysis functionality was identified during reverse engineering.
- T1082 — System Information Discovery: The payload contains functionality associated with collecting information about the infected system.
- T1555.003 — Credentials from Web Browsers: The analyzed code and strings indicate browser credential targeting.
- T1539 — Steal Web Session Cookie: The payload includes functionality associated with accessing browser cookies.
- T1528 — Steal Application Access Token: References to cloud authentication and application token storage suggest this capability.
- T1102.001 — Web Service: Dead Drop Resolver: The malware uses external public services to discover C2 information.
- T1071.001 — Application Layer Protocol: Web Protocols: Captured HTTP requests support the presence of web-based communication.
These mappings represent supported or inferred malware functionality and externally documented distribution behavior.
Not every mapped technique was independently observed during the supplied sandbox run.
10. Defensive Recommendations
The findings from this case suggest several practical defensive measures.
Security awareness against ClickFix and TermFix
Users should be trained to recognize that legitimate CAPTCHA verification does not require executing commands through Windows Terminal, PowerShell, or the Run dialog.
Unexpected requests to paste commands from a webpage should be treated as suspicious, even when displayed on a trusted website.
Endpoint monitoring
Monitor suspicious executable-memory allocation, in-memory PE loading, unusual API resolution, and unexpected access to browser credential stores.
Correlate these events with suspicious script execution and browser activity.
Application control
Restrict the execution of untrusted scripts and downloaded executables.
Apply least-privilege principles and consider limiting scripting tools where they are not required.
Credential and session protection
Organizations should consider browser session tokens, cloud authentication material, and application credentials within the scope of an infostealer investigation.
Password resets alone may not invalidate stolen sessions.
Network correlation
Monitor suspicious resolver-specific activity and investigate subsequent connections to candidate C2 infrastructure.
Avoid broad blocking of legitimate platforms without supporting evidence.
Detection validation
Test YARA rules against representative benign Windows software and additional malware samples.
Validate Suricata signatures using the actual Suricata engine and suitable offline traffic.
Incident response
If Vidar infection is suspected, isolate the endpoint, preserve relevant forensic evidence, investigate credential access, and revoke potentially compromised sessions and tokens according to the exposure assessment.
11. Conclusion: What Vidar Teaches Us About Modern Infostealers
The most important takeaway from this investigation is not simply that Vidar can steal sensitive information.
It is how malware delivery, execution, and communication techniques work together to make an infection harder to prevent and investigate.
Publicly documented ClickFix and TermFix campaigns demonstrate how attackers manipulate users into launching malicious instructions under the appearance of routine security verification.
Once executed, a loader can conceal its real purpose behind legitimate-looking application functionality.
In our analyzed sample, an encoded container prevented the second-stage payload from being immediately visible.
The recovered Vidar payload used virtualized strings and dynamic API resolution to complicate static inspection.
Finally, the dead-drop mechanism separated C2 configuration from the executable, allowing attacker-controlled public content to act as an intermediary for infrastructure discovery.
Our investigation of d8b0m demonstrates the value of combining reverse engineering with recorded behavioral evidence.
What initially appeared to be an unexplained five-character prefix was subsequently identified as a separator word used by the malware’s dead-drop logic.
That conclusion was supported by recovered diagnostic strings and sandbox records, rather than appearance alone.
At the same time, this research highlights the importance of maintaining boundaries between capability, intent, and observed behavior.
We identified extensive information-stealing functionality, but the supplied network evidence did not demonstrate successful exfiltration of the complete targeted dataset.
For defenders, modern infostealer analysis requires more than collecting suspicious hashes and domains. Understanding the social-engineering techniques, loader behavior, protected code, configuration discovery, and communication logic helps produce stronger detections and more reliable threat intelligence.
Malware analysis is not only about discovering what a malicious program can do. It is about establishing how it works, what the evidence actually proves, and how those findings can improve detection and response.
Research by Cyberkarta Malware Research Team.
This article combines original static reverse engineering and supplied sandbox evidence with explicitly attributed public research into Vidar distribution campaigns. Network indicators have been defanged. Findings from separate campaigns should not be assumed to apply to the analyzed sample.
Cyberkarta — Cyber Security Made Simple Made Powerful
Inside Vidar: Reverse Engineering a Protected Infostealer That Hides Its C2 Behind Steam was originally published in Cyberkarta on Medium, where people are continuing the conversation by highlighting and responding to this story.