Security researchers published an investigation revealing a sustained TeamPCP campaign that exploited the open-source software ecosystem’s prioritization of shipping speed over security, gaining years of access across thousands of organizations through compromised developer accounts, typosquatted packages, and exploitation of the trust relationship between developers and package registries.
The group’s infrastructure was designed to harvest credentials en masse, with targeting spanning enterprise software supply chains and critical infrastructure operators. The investigation documents how TeamPCP’s success reflects a broader industry failure rather than a single technical vulnerability.
TeamPCP’s Three Attack Vectors Against the Open-Source Ecosystem
TeamPCP built its access through three complementary vectors that all targeted the same structural weakness: the trust developers place in the speed of the open-source supply chain.
Compromised developer accounts gave the group direct access to package management infrastructure, allowing it to publish malicious updates that appeared legitimate to downstream consumers. Typosquatted packages exploited the naming conventions and fast-install workflows common in open-source dependencies, catching automated scanners and developers installing packages with minimal verification.
The third vector targeted the trust relationship between package registry maintainers and users. By operating at registry level, TeamPCP was able to harvest credentials from users and automated systems that trusted the registry as an authoritative source for software supplies.
How Compromised Developer Accounts Opened the Supply Chain
The investigation found that TeamPCP obtained developer accounts through credential harvesting campaigns targeting individuals with commit access to popular open-source projects. With those accounts, the group published malicious package updates that bypassed code review requirements, since the group’s accounts were authorized committers.
The malicious updates typically substituted legitimate upstream code with dropper code that reached back to TeamPCP’s credential harvesting infrastructure. Automated dependency pipelines pulling from these packages carried the implants into downstream enterprise environments without triggering any anomalies, which is why the group maintained access for years.
The Structural Flaw: Speed Over Security Controls
The analysis found that TeamPCP’s persistence was not primarily technical. The group succeeded because the industry’s competitive pressure to ship faster has systematically deprioritized the security controls that previously caught supply chain attacks.
Code review requirements were routinely bypassed under time pressure. Dependency scanning was not integrated into CI/CD pipelines. Package signing verification was treated as optional rather than mandatory. Each of these controls can stop a supply chain attack in isolation, but together they were treated as friction rather than essentials.
Impact on Enterprise and Critical Infrastructure
TeamPCP’s targeting of both enterprise software supply chains and critical infrastructure operators means the scope of impact extends far beyond the open-source development community. Organizations that depend on third-party software components for critical operations may have been exposed through the same supply chain pathways the group exploited in open-source.
The investigation provides rare operational detail on how persistent supply chain adversaries think about access, persistence, and scale. The group’s approach of exploiting systemic industry pressures rather than individual technical flaws offers a template for understanding how other threat actors may have followed similar patterns.
