Disguised npm Packages and the Install-Time Scan Gap

The Claim

Governance frameworks that scan for malicious behavior only at install time create systemic risk when registries are used as free hosting for artifacts that never touch a build pipeline. Zero Trust for Code addresses this by requiring a pre-execution trust decision on what an artifact does when it runs, regardless of whether it runs during installation, in a browser, or anywhere else code is permitted to execute.

The Incident

Researchers at JFrog identified 141 npm packages in May, later growing to 148 by July, published under names branded as student tools to bypass school web filters. The packages carried no install scripts or lifecycle hooks and were never meant to be imported into a project, instead hosting a client-side proxy web app that visiting browsers loaded directly, using npm purely as a content delivery mechanism. Underneath the proxy sat two hidden modules: one fetched remote JavaScript from a mutable, unpinned GitHub branch and executed it with the site’s full origin privileges, while the other opened up to 1,024 WebSocket connections per browser tab targeting a proxy protocol server, exhausting its resources rather than the visiting student’s own device. A second wave of packages published in July restored the adware
functionality while leaving the remote loader in place, still pointed at the same branch.

The Governance Failure

The governance failure is not that malicious packages reached the registry, but that the entire model of software trust assumed a package’s risk lives at install time. Dependency scanners, install-time sandboxes, and lifecycle hook monitoring are built around a single execution surface: what happens when a package is pulled into a project and run through “npm install”. These packages never triggered that surface at all, because they were never designed to be installed as dependencies in the first place.

This exposes a second, more persistent gap. The remaining packages still load a script from a mutable branch with no integrity verification. Whoever controls that branch can change what every visiting browser executes at any time, without publishing a new package version, without triggering a new npm scan, and without leaving any trace in a lockfile or manifest that a security team would think to review. The registry’s admission process, and any monitoring built around package versions, has no visibility into a artifact that can be silently re-armed downstream of the point where every existing control is watching.

The underlying breakdown is the assumption that an artifact’s trustworthiness is fixed at the moment it is scanned and published. Trust granted to a package version does not account for content the package points to but does not contain, and it does not account for a second execution surface, the browser, that operates entirely outside the tooling built to govern developer environments. As long as an artifact can behave one way during review and a different way once deployed, scanning at any single point in time cannot be the control that decides what is allowed to run.

This gap keeps showing up in different forms across different ecosystems. For a broader look at why origin-based trust controls keep falling short, see Taking Down the Botnet Doesn’t Answer the Harder Question.

The Regulatory and Business Exposure

Execution of unreviewed, remotely mutable code within enterprise or school network browser sessions.
Resource exhaustion and denial-of-service impact carried out through end-user browsers rather than compromised infrastructure.
Continued exposure to artifacts that can be altered after publication without triggering any package-level review or re-scan.

What Your Auditors Will Ask

How do you validate the behavior of artifacts that execute in a browser rather than at install time?
How do you account for registries or repositories being used to host content outside their intended package format?
What controls detect a referenced script changing after the artifact that points to it was last reviewed
How do you determine whether an approved artifact can still alter its own behavior post-publication
What evidence do you maintain that execution behavior was evaluated at the point it runs, not only at the point it was published?

A consistent signal is the disconnect between where an organization’s controls are looking and where an artifact actually executes. Trust concentrated entirely at install time leaves every other execution surface unexamined.

Zero Trust for Code Value

Zero Trust for Code introduces a trust decision at the point where an artifact is about to execute, regardless of whether that execution happens during installation, inside a browser, or through any other surface a registry or repository makes available. This means a package is assessed on what it does when it runs, not on whether it matches the narrow category of behavior a scanner was built to catch.

This directly addresses the governance weakness exposed by the student proxy campaign: the assumption that install-time review is sufficient because it is the only execution surface most controls were designed to watch. By requiring a pre-execution trust decision independent of where or how code runs, organizations can evaluate a referenced script’s behavior at the moment it executes, even when that script can change after the artifact pointing to it was last reviewed.

The result is a governance model where execution is evaluated wherever it occurs, closing the distance between what was published and what actually runs on any given day, rather than assuming the two remain the same after the fact.

Governance Action Brief

Establish governance controls that evaluate artifact behavior at every execution surface, not only at install time.
Require a pre-execution trust decision for any code an artifact references or loads dynamically, including content served from mutable or unpinned sources.
Enforce execution policies for browser-based sessions on managed networks, not solely for developer workstations and CI/CD environments.
Monitor for registries or repositories being used as hosting infrastructure for artifacts outside their intended package format.
Maintain a record of what an artifact was permitted to execute, independent of whether its underlying content has since changed.

Download the PDF

Sources

Analysis based on reporting from The Hacker News (July 14, 2026) and CodeHunter Labs evaluation of governance gaps in post-publication execution trust.