A Survey of Software Supply-Chain Defenses: Registries, Build Trust, and Language-Level Capabilities
Overview
Software supply-chain security has converged on three layers of defense that map onto three questions a consumer asks before trusting a piece of code: what bytes am I actually installing (registry/package-integrity layer), how were those bytes produced (build/provenance layer), and what can this code do once it runs (language/runtime layer). This survey covers eleven concrete mechanisms across those layers — Go’s module proxy and checksum database, npm provenance/Sigstore, PyPI Trusted Publishing, SLSA, reproducible builds, cargo-vet/cargo-crev, Deno’s permission model, and the capability-safe languages Austral, Pony, E, Wyvern, and Roc’s platforms — drawing on peer-reviewed venues (USENIX Security, IEEE S&P, NDSS, ASIACCS, arXiv) and primary engineering sources.
The throughline across all eleven mechanisms is the same: each closes one specific gap in the chain from source code to running process, and each explicitly documents — often in its own specification — that it does not authenticate intent. A cryptographically perfect, fully-attested, reproducibly-built package can still be malicious if the humans or CI pipelines that produced it were compromised or acted in bad faith. The 2025–2026 incident record (Shai-Hulud, Mini Shai-Hulud, the TanStack/Nx npm worm) shows attackers converging precisely on that residual gap: hijacking a legitimate, already-trusted CI pipeline rather than forging trust from outside it.
Part 1: Registry-Level Integrity Defenses
Three registries have shipped structurally different answers to “how do I know the bytes I install correspond to the code the author published?” Go authenticates content via a global transparency log and moves proxies and code hosts out of the trusted computing base. npm authenticates build context via Sigstore-signed SLSA provenance. PyPI authenticates the publishing act via short-lived OIDC credentials.
1.1 Go’s Module Proxy and Checksum Database (GOSUMDB)
Mechanism. Go’s go.sum file records cryptographic hashes of each dependency’s file tree and go.mod, authenticating repeat builds locally; the gap the design targets is the first download of a new module version, which historically “the go command today blindly trusts” — a model its authors compare explicitly to SSH’s trust-on-first-use (Cox and Valsorda, Secure the Public Go Module Ecosystem). The checksum database publishes go.sum lines for every public module version in a Certificate-Transparency-style log, exposing /latest, /lookup/M@V, and Merkle /tile/H/L/K endpoints; the go command caches signed tree state and “will complain loudly on standard error and fail the build” on any inconsistency (design document). Because verification is content-based rather than signer-based, authentication “effectively moves code hosting servers like rsc.io and github.com out of the trusted computing base,” along with proxies (design document).
What it prevents. Tampering in transit by malicious or compromised proxies/mirrors; compromise of the code host itself, since “even the author of a module should not be able to change the bits associated with a specific version from one day to the next” (design document); retroactive history rewriting, because a forked, victim-specific log view must be served to that victim forever or the consistency check fails loudly and provably; silent downgrade attacks, since a checksum-lookup failure is a hard build failure; and non-reproducible builds across a team.
What it does not prevent. Code that was malicious from its first publish — the scheme authenticates consistency, not intent, and “works without needing to attribute specific archives to specific authors” (design document). A 2026 measurement study found 2,289 malicious versions of repackaged legitimate Go modules under attacker-controlled owners, every one a perfectly valid, fully authenticated log entry (Bae and Yagemann, Beyond Takedown, arXiv:2606.26291). It also does not prevent remediation problems after detection — immutability means the proxy “keeps cached copies of modules long after they disappear from their original hosting repositories,” with at least 99.4% of GitHub-unobservable malicious artifacts still retrievable via the Go proxy (Bae and Yagemann). Author-account compromise leading to a malicious new tag is simply a new logged version. Detection of split-view/log-fork attacks depends on optional gossip that the design itself calls “obviously not the final name” (design document). Privacy of dependency lookups is limited — contacting the database leaks module paths absent GOPRIVATE/GONOSUMDB configuration. And verification code itself has had bugs: CVE-2026-56865 disclosed that a malicious GOPROXY could forge up to two sumdb tiles to bypass the checksum check and persist attacker content into a local module cache undetectably by the transparency log, fixed in Go 1.25.13/1.26.6 (NVD).
Adoption. Default-on since Go 1.13 (2019): “the go command by default downloads and authenticates modules using the Go module mirror and Go checksum database” (Go 1.13 release notes), launched 29 August 2019 (Go blog). This makes it effectively universal across the Go ecosystem absent explicit opt-out. Scale: a peer-reviewed transparency-log paper cites the deployed database at “17M entries” with “~16k entries added” per day (Fang et al., LegoLog, IEEE EuroS&P 2025); an independent 2026 study collected over 12 million index entries for a single year (Bae and Yagemann). The design deliberately uses a single Google-operated log rather than N-of-M independent notaries, judged “significantly more expensive” for no added attack detection (design document).
Strongest published criticism. No peer-reviewed paper’s central contribution is an attack on GOSUMDB specifically; the closest peer-reviewed treatment uses it only as a deployment data point (LegoLog, EuroS&P 2025). The strongest critiques are: (1) Bae and Yagemann’s arXiv measurement showing “Go’s module distribution path actively helps sustain the attacker’s persistence strategy” because the proxy’s permanence works against takedown (arXiv:2606.26291); (2) Meiklejohn et al.’s (Google) general critique of transparency logs, which applies directly: gossip protocols needed to detect split views have “‘next to no deployment in the wild,’” and log-auditor honesty “is not possible to check” (Think Global, Act Local, arXiv:2011.04551); (3) the concrete refutation supplied by CVE-2026-56865, where tile-verification code itself was flawed for years (NVD); and (4) an engineering write-up demonstrating that the checksum database and proxy will fetch and permanently retain arbitrary non-Go repository content on unauthenticated request (Abusing Go’s infrastructure).
1.2 npm Package Provenance and Sigstore
Mechanism. On a supported CI provider, the npm CLI generates a SLSA provenance statement, mints “a single-use keypair to sign the provenance statement,” requests a Fulcio signing certificate binding that key to the CI job’s OIDC identity, then deletes the key (GitHub, Introducing npm package provenance). The attestation is uploaded to Sigstore’s Rekor transparency log, “making it possible to detect if someone later attempts to modify the provenance or the contents of an already published package,” and the registry itself validates the certificate’s identity against the publish context before accepting the version (GitHub). Consumers verify via npm audit signatures (npm docs). Since trusted publishing reached general availability, the CLI generates and publishes provenance automatically without a --provenance flag (GitHub changelog).
What it prevents. Tampering with a published tarball or its provenance after the fact (detectable via Rekor); provenance spoofing at publish time; and — the core value proposition — the gap between trusting source code and trusting the published artifact, since provenance “supplies a verifiable way to link a package back to its source repository and the specific build instructions used to publish it” (GitHub). It effectively blocks dependency-confusion/impostor-package attacks, because SLSA Build L2 provenance “binds a package to its canonical source repository and build system,” which an attacker registering an impostor package cannot forge from the legitimate source (OpenSSF/SLSA, Mini Shai-Hulud). It also eliminates long-lived-key management risk by using ephemeral keys plus workload-identity OIDC, and Fulcio’s requirement that “clients MUST NOT trust certificates that are not in the log” makes CA or identity-provider misissuance detectable, if not preventable (Fulcio security model).
What it does not prevent. npm states plainly that established provenance “does not guarantee the package has no malicious code” (npm docs). Most importantly, it does not prevent a hijacked-but-legitimate pipeline — this is now a demonstrated attack, not a hypothetical: the May 2026 TanStack npm worm chained a pull_request_target “Pwn Request,” GitHub Actions cache poisoning, and extraction of the ambient OIDC token from runner memory to publish 84 malicious versions across 42 packages (spreading to 170+), producing attestations that “accurately reported the builder…, the repository…, and the workflow” and were “indistinguishable from attestations on legitimate packages” (OpenSSF/SLSA; StepSecurity forensics). Sigstore’s own threat model concedes “OIDC account compromise is not handled by Sigstore” and that detecting it “relies on monitoring” (Sigstore threat model). A compromised Fulcio CA enables “arbitrary software attack” recoverable only via the TUF root of trust; log-plus-monitor compromise together makes replay/fork attacks undetected (Sigstore threat model). Verification remains opt-in and out-of-band — npm does not block installs of unattested packages — and coverage is limited to supported cloud CI, unavailable when publishing from private repositories (npm docs).
Adoption. Public beta April 2023 through GA in September 2023; by the end of beta, 3,800+ projects (134 “high-impact”) had adopted provenance, covering 500M+ downloads against a registry doing tens of billions of downloads per month (Sigstore blog). Nearly two years later, provenance reached only 3.72% of the top 5,000 high-impact packages (Socket/vlt) — a striking gap versus the beta’s initial enthusiasm. Trusted publishing (automatic provenance) went GA 31 July 2025 on GitHub Actions and GitLab CI/CD (GitHub changelog), with CircleCI added April 2026 (GitHub changelog). By late 2025, 11,001 of the top 51,370 packages (~25% of download volume) used trusted publishing, with weekly adoption spiking from a ~40/week baseline to 430/week after the May 2026 Nx/AntV attack wave (Aikido). Following the September 2025 Shai-Hulud incident (500+ packages removed), GitHub committed to narrowing publishing to 2FA-required local publishing, 7-day granular tokens, and trusted publishing; classic tokens were permanently revoked on 9 December 2025 (GitHub, Our plan for a more secure npm supply chain; GitHub changelog).
Strongest published criticism. The sharpest analysis is a Red Hat-authored OpenSSF/SLSA post-mortem, precise about the trust boundary: “The issue is not the attestations; it is the build platform behind them… When attacker-controlled code runs inside that platform, the observations are accurate but the build was compromised… npm’s built-in provenance achieves Build L2… What L2 does not require is isolation” (OpenSSF/SLSA). It also notes the most reliable detection signal in the actual incident was operational, not cryptographic: both malicious publishing runs “completed with status: failure, yet packages were published during them… Standard SLSA consumer tooling does not check workflow run status” (OpenSSF/SLSA). Peer-reviewed support comes from two directions: an 18-practitioner USENIX Security 2025 interview study found that “signatures on third-party dependencies are rarely verified in practice,” with only 3 of 18 organizations reporting any verification (Kalu, Singla, Okafor, Torres-Arias and Davis, An Industry Interview Study of Software Signing, USENIX Security 2025); and a large-scale cross-registry measurement finding that “signing adoption is primarily affected by registry policy rather than by public knowledge of attacks” (Schorlemmer et al., IEEE S&P 2024) — exactly the pattern npm’s post-incident mandates produced. A companion interview study on Sigstore adoption itself found practitioners citing rate limiting, transparency-log unsuitability for private/air-gapped setups, and the operational burden of log monitoring as adoption friction (Kalu et al., Why Johnny Signs with Sigstore, arXiv:2503.00271).
1.3 PyPI Trusted Publishing
Mechanism. Trusted Publishing exchanges a short-lived OIDC identity token from a CI provider for a PyPI upload credential. A project registers a publisher configuration (owner, repository, workflow file, optional environment); at release time PyPI matches the workflow’s OIDC token claims against that configuration and, if they match, “mint[s] a short-lived API token… valid for 15 minutes” (PyPI docs). The same identity underlies PEP 740 attestations, where the token is exchanged with Sigstore’s Fulcio for a short-lived certificate binding claims to an ephemeral key (PyPI attestations security model).
What it prevents. Long-lived credential theft: “an attacker who compromises a package’s release token can use it until its legitimate user notices and manually revokes it. Trusted Publishing avoids this problem because the tokens minted expire automatically” (PyPI docs). Credentials at rest in CI — nothing persistent exists to leak in logs or be stolen by malware (PyPI security model). Publishing impersonation across workflows: “a workflow defined at foo.yml in org/repo cannot impersonate a workflow defined at bar.yml in org/repo,” and forked-PR events generally cannot obtain the upstream repository’s token (PyPI security model). Combined with PEP 740 attestations, it also lets verifiers detect post-build tampering and changes in a project’s registered Trusted Publisher that might indicate a hostile takeover (PyPI attestations security model).
What it does not prevent. “Just like normal API authentication, Trusted Publishing does not assert the safety of the code or the trustworthiness of its authors,” and does not address pre- or post-build modification on its own (PyPI security model). It explicitly does not protect against a compromised workflow: “weaknesses in those workflows can be equivalent to credential compromise… treat your Trusted Publishers as if they are API tokens,” and pull_request_target triggers are “fundamentally dangerous by design” — exactly the vector used against TanStack on npm (PyPI security model; OpenSSF/SLSA). It doesn’t stop in-flight token interception during the (short) validity window, nor does it fully protect against identity-provider compromise, since “Trusted Publishing relies on the integrity of that IdP” (PyPI security model). Maintainer offboarding is a gap: “removing a user from a PyPI project does not remove any Trusted Publishers that they might have registered” (PyPI security model). And client-side verification is essentially absent: PEP 740 “concerns only the index itself… downstream clients still need to trust PyPI itself to serve attestations honestly” (Trail of Bits).
Adoption. PyPI pioneered the pattern in April 2023 (PyPI blog). Configured-project counts rose from roughly 45,000 (November 2025) to over 50,000 by year-end 2025, and share of file uploads climbed from ~10% (February 2024) to over 25% of all files uploaded by October 2025, with cumulative uploads via trusted publishing exceeding 2.2 million files since launch (PyPI blog, Nov 2025; PyPI 2025 in review; LWN). PEP 740 attestations reached 17% of all 2025 uploads, though only ~5% of the 360 most-downloaded packages carried attestations shortly after launch (PyPI 2025 in review; Trail of Bits). The pattern spread to RubyGems (December 2023), crates.io and npm (July 2025), and NuGet (September 2025) (GitHub). PyPI has not mandated trusted publishing but mandated 2FA for all accounts effective 1 January 2024, with over 52% of active users on non-phishable 2FA by end-2025 (PyPI blog; PyPI 2025 in review).
Strongest published criticism. No peer-reviewed paper analyzes PyPI Trusted Publishing specifically. The strongest rigorous critique is Trail of Bits’ second independent Warehouse security audit (23 February – 20 March 2026), which found real OIDC claim-verification defects in the live implementation: TOB-PYPI26-1, a Medium-severity anti-replay bug where “the Redis key expired at exp + 5… [while] PyJWT accepted tokens up to 30 seconds past expiration… That created a 25-second window in which Redis had evicted the anti-replay key, while the JWT still passed signature verification,” letting an attacker holding a leaked OIDC JWT mint fresh 15-minute upload tokens repeatedly during that window (PyPI blog; Socket); and TOB-PYPI26-2, a TOCTOU race in the same anti-replay flow letting two concurrent requests with the same token identifier both mint valid tokens (PyPI blog). Both were remediated, but two other findings were accepted rather than fixed, including one that weakens third-party auditability: wheel metadata served to installers is not validated against upload-time metadata, so scanners relying on the JSON API can see a different dependency list than what installers actually honor (PyPI blog). The more fundamental criticism, from the engineers who built PyPI’s own attestation support, is that verification is absent by default: cryptographic attestations “have defensive properties only insofar as they’re actually verified,” yet no default install flow verifies them (Trail of Bits) — the same industry-wide pattern USENIX Security 2025 documented (3 of 18 organizations verify third-party signatures) (Kalu et al.).
1.4 Registry-Level Synthesis
The three mechanisms are non-overlapping and composable: Go authenticates what (content consistency, author-agnostic), npm provenance authenticates whence (source plus builder), and PyPI Trusted Publishing authenticates who/when (the publishing act). None authenticates intent, and each set of docs says so explicitly. Default-on adoption beats opt-in by roughly two orders of magnitude — Go’s checksum verification is effectively universal since 2019, PyPI Trusted Publishing exceeds a quarter of monthly uploads under a default-on GitHub Action, while npm provenance, which required an explicit flag for its first two years, reached only 3.72% of high-impact packages (Socket/vlt) — matching the peer-reviewed finding that “mandating signature adoption improves the quantity of signatures… adoption is primarily affected by registry policy” (Schorlemmer et al., IEEE S&P 2024). The 2026 attack frontier for all three is the build environment rather than the registry itself: once an attacker runs code inside a trusted CI runner, it inherits ambient OIDC identity and produces genuine attestations, which is precisely what happened in the TanStack/Mini Shai-Hulud incident.
Part 2: Build and Artifact Trust Frameworks
2.1 SLSA (Supply-chain Levels for Software Artifacts)
Mechanism. SLSA attaches verifiable provenance to build artifacts so a consumer can compare actual provenance against expectations (SLSA v1.0 “About”). Since v1.0, the spec is organized into tracks and levels rather than a single ladder: the stable Build track runs Build L0 (no guarantees) through L1 (provenance exists, may be unsigned), L2 (signed provenance from a hosted build platform), and L3 (hardened build platform with run isolation and protected signing keys) (SLSA v1.0 levels). Source-track requirements from v0.1 were deliberately removed to focus on the build (SLSA v1.0 levels). Provenance is expressed as an in-toto attestation carrying buildDefinition and runDetails over artifact digests (SLSA v1.0 provenance spec). SLSA was published by Google in June 2021, is stewarded by the OpenSSF, and is modeled on Google’s internal Binary Authorization for Borg, which mandates code review, verifiable builds, containerized deployment, and service identity (Google Cloud: BAB).
What it prevents. Tampering after the build (artifact substitution) via signed provenance at L2; tampering during the build — SolarWinds-style injection, cross-build interference, and build-cache poisoning — since at L3 “the output of the build MUST be identical whether or not the cache is used” (SLSA v1.0 requirements); artifacts built by unexpected platforms or from a commit absent from the upstream repo; forged provenance and hidden build steps, since external inputs must be recorded and verified; and insider risk at the producer, BAB’s original design goal (Google Cloud: BAB).
What it does not prevent. Malicious or vulnerable source code — a malicious producer “cannot be directly mitigated through SLSA controls,” and consumers “must establish some basis to trust the organizations from which they consume software” as “a judgement call with no straightforward answer” (SLSA threats and mitigations). Risky-by-design builds: “Build L3 is limited to ensuring that a well-intentioned build runs securely. It does not require that a build platform prevents a producer from performing a risky or insecure build” (SLSA v1.0 requirements). Transitive dependency risk, since SLSA build levels cover only a single build with no requirement on dependency build levels (SLSA v1.0 FAQ). Complete dependency inventory — resolvedDependencies completeness is “best-effort,” so provenance is not an SBOM substitute (SLSA v1.0 FAQ). Unsafe CI configuration — SLSA “does not evaluate whether a workflow’s trigger configuration is safe,” and a pull_request_target misconfiguration “falls entirely outside SLSA’s scope” (OpenSSF/SLSA). And SLSA does not mandate reproducibility; “verified reproducible builds are one option for implementing the requirements,” not a requirement itself (SLSA v1.0 FAQ).
Adoption. npm’s Sigstore-backed provenance reached over 3,800 projects and 500 million downloads during beta but achieves only SLSA Build L2, since “L2 does not require isolation” (Sigstore blog; OpenSSF/SLSA). PyPI’s PEP 740 attestations, GA’d 14 November 2024, generate automatically only for GitHub Actions publishers using pypa/gh-action-pypi-publish, with over 20,000 attestations published shortly after launch (PyPI blog). GitHub documents reusable workflows plus attestations as a path to SLSA v1 Build Level 3 (GitHub Docs). Internally at Google, BAB applies to “all services running on Borg,” with mandatory per-service policies verified at least daily across hundreds of thousands of jobs — though the same documentation admits Google “often does not have the same review controls in place” for third-party/open-source code, that some services can run with reduced or disabled BAB enforcement, and that emergency response can bypass deploy-time enforcement (Google Cloud: BAB). An academic survey of 1,523 SLSA-related GitHub issues across 233 repositories found that “despite growing interest, the adoption of SLSA is not widespread,” citing complex implementation and unclear communication as the dominant barriers (Tamanna et al., arXiv:2409.05014).
Strongest published criticism. The best academic critique is Analyzing Challenges in Deployment of the SLSA Framework for Software Supply Chain Security (Tamanna, Hamer, Tran, Fahl, Acar, Williams; arXiv:2409.05014), a thematic analysis of 1,523 GitHub issues identifying complex implementation and unclear communication as the two dominant adoption barriers (arXiv:2409.05014) — an arXiv preprint, not a top-tier security venue publication. The strongest overall critique, however, is engineering, not academic: the OpenSSF/SLSA post-mortem of the May 2026 “Mini Shai-Hulud” incident, which dissects how attackers extracted a legitimate OIDC token from runner memory and signed cryptographically valid provenance naming the correct builder, repository, and workflow: “A signed artifact is not necessarily a trustworthy one… Once attacker-controlled code runs inside a trusted workflow, SLSA’s build-time guarantees are already behind them. No amount of policy on the resulting attestation recovers from that.” It further notes both malicious publishes occurred during runs that “completed with status: failure,” yet “standard SLSA consumer tooling does not check workflow run status” (OpenSSF/SLSA). A second, structural criticism is visible in SLSA’s own documents: the aspirational tiers were removed rather than achieved, with v1.0 deferring source-track requirements and SLSA 4 entirely and stating producer-side v0.1 requirements “will be reassessed and re-added as indicated in the future directions” (SLSA v1.0 requirements).
2.2 Reproducible Builds
Mechanism. “A build is reproducible if given the same source code, build environment and build instructions, any party can recreate bit-by-bit identical copies of all specified artifacts” (Fourné et al., IEEE S&P 2023). Determinism requires eliminating environment-dependent inputs — timestamps, build paths, file ordering, locales, ASLR-dependent output — via normalization tooling (strip-nondeterminism, SOURCE_DATE_EPOCH) and controlled environments (reproducible-builds.org history). Verification requires independent rebuilders: “assuming the attacker cannot simultaneously compromise the build systems of all parties, arbitrary subversion of an individual build system can be trivially detected” (Fourné et al.). Debian rebuilds every archive package bit-for-bit against .buildinfo records (reproduce.debian.net); Bitcoin Core builds through Guix with outputs attested in guix.sigs (bitcoin/contrib/guix/README.md); Tor Browser achieves build security “through a reproducible build process,” historically via Gitian, with signatures from multiple independent builders (Tor Project). Reproducibility only yields a trust decision when combined with a binary-transparency/certification-sharing layer that lets independent parties compare rebuild results (reproducible-builds.org: Sharing certifications).
What it prevents. Build-system compromise and SolarWinds-style build injection — the SolarWinds attack “trojaned the build system, transparently injecting malicious logic into the product binary signed with Solarwinds’ official code signing keys,” a divergence reproducible builds make detectable (Fourné et al.). Tampering between source and binary generally, for the vast majority of users who never compile software themselves. Coerced or accidental divergence, not just malice. Hidden build-time inputs and secret leakage — one documented case found a GPG passphrase accidentally embedded in a shipped archive because reproducibility testing surfaced the divergence (Fourné et al.).
What it does not prevent. Malice in the source: both the honest build and the independent rebuild compile the same malicious source to the same bytes, so bit-for-bit agreement says nothing about intent — “reproducible builds do not address source, dependency, or distribution threats” (SLSA v1.0 FAQ). Correlated rebuilder compromise: “reproducers must truly be independent, lest they all be susceptible to the same attack” (SLSA v1.0 FAQ). Trusting-trust attacks in the toolchain itself: a 2026 study built a full trusting-trust attack hidden inside GNU strip across an entire NixOS distribution, noting “reproducible builds confirm that a binary is deterministic and not that its build environment is honest, so a rebuild that reuses the same seed reproduces the same implant bit-for-bit… neither check fires” (Malka, Sharma, Monperrus, Zacchiroli, Zimmermann, arXiv:2607.24888). Closed-source practicality — “closed-source reproducible builds require the code owner to either grant source access to multiple independent rebuilders… or develop multiple, independent in-house rebuilders, which is likely prohibitively expensive” (SLSA v1.0 FAQ). And durability of a “reproducible” verdict — “the most used deployment of reprotest does not check all available mutators,” and one Debian participant summarized the state as “‘we make sure it’s reproducible for now’” (Fourné et al.).
Adoption. Debian is the flagship, rising from 24% reproducible packages in 2013 to 95.2%+ of Bookworm/amd64 by November 2023 (Drexel, Hänggi, Méndez Veiga, SICHERHEIT 2024; Fourné et al.), with Debian trixie on amd64 reported “reproducible for over 95%” by May 2025 and full bootstrap of a minimal 100%-reproducible Debian achieved June 2025 (Debian micronews; reproducible-builds.org history). Arch Linux core packages sit at 88.7% reproducible (Fourné et al.). Nix/nixpkgs, in the first large-scale bitwise-reproducibility study covering 709,816 packages rebuilt from 2017–2023 snapshots, found 69–91% bitwise reproducibility with an upward trend and over 99% rebuildability (Malka, Zacchiroli, Zimmermann, MSR 2025, arXiv:2501.15919). Coverage is far weaker in language package ecosystems: an ICSE’25 study of 4,000 packages per ecosystem found as-is reproducibility of 100% for npm and Cargo, but only 12.2% for PyPI, 2.1% for Maven, and 0% for RubyGems — patched tooling raised PyPI to 98% and RubyGems to 99.9% (Benedetti, Solarin, Miller, Tystahl, Enck, Kästner, Kapravelos, Merlo, Verderame, ICSE 2025). Containers fare worse still: a 2026 study of 2,000 GitHub repositories found only 56% produce a buildable Docker image at all, and only 2.7% of buildable images are bitwise reproducible out of the box (reproducible-builds.org, Feb 2026 report).
Strongest published criticism. The single best critique of the movement’s real-world effectiveness is peer-reviewed: Fourné, Wermke, Enck, Fahl, Acar, It’s like flossing your teeth: On the Importance and Challenges of Reproducible Builds for Software Supply Chain Security, IEEE S&P 2023 — 24 semi-structured interviews with practitioners, coded to saturation. Its central finding undercuts the security case directly: “23 of 24 interviewees could not name a security incident related to reproducible builds, either thwarted or caused by it” — the single exception being a leaked GPG passphrase, not an attack. Eighteen interviewees cited improved software quality, not security, as their main motivator, and thirteen reported decreasing effort over time “due to decreasing enthusiasm and repetitive work,” corresponding with “perceived impracticality of fully reproducible builds” (Fourné et al., IEEE S&P 2023). The ICSE’25 coverage-gap study complements this by showing the movement’s success is concentrated in OS distributions rather than the language ecosystems where most dependencies actually live (Benedetti et al.). The sharpest threat-model criticism is the NixOS trusting-trust attack, which infected 3,790 of 3,791 CLI-invokable binaries via a tampered strip in the bootstrap seed while neither reproducibility checks nor per-step attestations fired (Malka et al., arXiv:2607.24888).
2.3 cargo-vet and cargo-crev
Mechanism. cargo-vet (Mozilla, with Google and other Rust-using organizations) tracks which third-party crate versions have been audited by a trusted organization and fails CI when unaudited code enters the build graph, using criteria labels like safe-to-run and safe-to-deploy (LWN: Vetting the cargo; cargo-vet: How it Works). It bootstraps via exemptions — cargo vet init marks the entire existing dependency tree as unaudited-but-permitted so onboarding “does not require auditing the existing dependencies” — and supports delta (differential) audits between crate versions plus audit-set imports from trusted organizations, explicitly without transitive trust: “there is no notion of transitive trust… it does not have a separate identity and authentication layer” (cargo-vet FAQ; cargo-vet: How it Works). cargo-crev is the decentralized alternative: individuals hold cryptographic identities and publish signed reviews and trust proofs in git repositories, and each user computes a personal, transitively attenuated trust set by graph traversal — “Trust is about people and community, not automatic scans, arbitrary metrics, process or bureaucracy” (cargo-crev trust documentation; web.crev.dev).
What it prevents. Unreviewed dependency code silently entering production: “the tool will indicate that they require auditing and cause the build to fail” when dependencies update (LWN). Malicious updates to previously vetted crates — the dominant real-world Rust attack pattern — since delta audits require a reviewed diff even against an unaudited base, which “still provides meaningful protection against future supply-chain attacks” (cargo-vet: How it Works). Registry-substitution during audit, since cargo-vet fetches source directly from crates.io to match what’s deployed. Known-bad version ranges, via violation entries. Review duplication across the ecosystem, since audits are shared as a commons.
What it does not prevent. Nothing about code that is merely exempted — the default onboarding path marks the entire existing dependency tree unaudited, so “green CI” does not mean “reviewed.” Faithless or forged audits: Mozilla’s own announcement concedes “there is no way to independently verify that an audit was performed faithfully and adequately,” and LWN notes there is “no way… to verify that the person listed in the audits.toml file actually claims to have done an audit” (LWN). A compromised or over-trusted auditing organization, since trust delegation is binary per-org with no transitive trust to limit blast radius, and Google itself states its aggregated audits “should not be construed as reflecting material safety or security properties of Rust crates” (google/rust-crate-audits). Guaranteed depth of review — auditors are “not required to perform a full logic review of the entire crate,” and even the strictest UB-risk criteria concede “a best-effort review is expected to miss at least some possible unsoundness.” Context-dependent, cross-crate vulnerabilities, since “tools like Cargo Vet focus on auditing packages in isolation—and fundamentally this breaks down on many real-world packages” (Zoghbi, Thien, Jhala, Stefan, arXiv:2602.06466). Sparse coverage overall — a survey of 285 Rust contributors found “only 24% of respondents often review dependencies before adding or updating a package” (Hamer, Imtiaz, Tamanna, Shabrina, Williams). And, for crev specifically, transitive trust dilution: default redundancy of 1 means a single trusted review suffices anywhere along a trust path.
Adoption. cargo-vet’s shared registry of well-known audit publishers lists eight organizations: Actix, Bytecode Alliance, Embark Studios, Fermyon, Google, ISRG, Mozilla, and Zcash (cargo-vet registry.toml). Google’s audit repository automatically aggregates from Chromium, ChromiumOS, and Fuchsia and carries 254 GitHub stars (google/rust-crate-audits). cargo-crev’s public dataset shows 2,038 reviews covering 978 crates from 103 reviewers (web.crev.dev) — roughly 1% coverage against a crates.io registry that already exceeded 92,000 packages during the same period (Hamer et al.).
Strongest published criticism. No peer-reviewed paper’s central contribution is a critique of cargo-vet or cargo-crev. The strongest academic critique is Auditing Rust Crates Effectively (Zoghbi, Thien, Jhala, Stefan of UC San Diego; arXiv:2602.06466), which argues the audit-sharing model targets the wrong layer of the problem: “tools like Cargo Vet focus on auditing packages in isolation—and fundamentally this breaks down on many real-world packages,” and Cargo Vet’s unstructured approvals mean “even audited crates can require a look over” since exposed functions may be safe only in specific calling contexts (arXiv:2602.06466). The strongest engineering critique, LWN’s Vetting the cargo, names the trust-bootstrapping problem precisely: “anybody who can write the file can add any text they want,” and “creating a system of sharing audits across the community looks like a difficult task in the absence of some sort of reputation system that lets users decide which audits they should actually trust” (LWN) — exactly the reputation layer cargo-vet dropped for adoptability and cargo-crev kept, without either producing ecosystem-scale audit coverage.
2.4 Build/Audit Cross-Cutting Synthesis
The three mechanisms fail precisely where the next begins along the source → build → artifact axis. SLSA trusts source by design and does not require build-platform isolation below L3; reproducible builds trust source (identical malicious source reproduces identically) but not the build platform, given truly independent rebuilders; cargo-vet/crev is the only one of the three that looks at source code at all, but does not address build-platform or distribution trust. Two convergent lessons recur: the verification side is the weak link everywhere — Debian still asks for more independent rebuilders, 23 of 24 reproducible-builds practitioners could not name a security incident their practice detected, and standard SLSA consumer tooling does not even check whether an attested workflow run succeeded. And all three frameworks are strongest against infrastructure compromise and weakest against a human who intends harm and simply follows the process — precisely the case SLSA’s own threat model calls “a judgement call with no straightforward answer” (SLSA threats).
Part 3: Language- and Runtime-Level Defenses
3.1 Deno’s Permission Model
Mechanism. Deno is secure by default: absent an explicit flag, code has no access to the filesystem, network, environment variables, subprocesses, or FFI, enforced at the runtime level rather than the OS (Deno security documentation). Authority is granted through granular allow-list flags (--allow-read=./data, --allow-net=example.com, --allow-env=API_KEY, --allow-run=git, --allow-ffi) with matching --deny-* overrides, and ungranted operations either raise a NotCapable error or, interactively, prompt the user (Deno permissions reference). Because checks happen at the runtime API boundary, a malicious dependency that tries to read SSH keys or exfiltrate data fails unless the operator granted that specific authority — and Deno removes npm’s single largest attack vector, install-time scripts, from the default path entirely (CISPA research summary).
What it prevents. Arbitrary file reads (SSH keys, .env, source) absent --allow-read or scoped narrowly; data exfiltration absent --allow-net or scoped to an allow-listed domain; credential harvesting from environment variables absent scoped --allow-env; shell-out attacks (crypto miners, reverse shells) absent scoped --allow-run; native-code sandbox escape absent --allow-ffi; and npm-style postinstall malware entirely, by removing install scripts from the default execution path (CISPA research summary). Slack’s 2022 developer platform runs customer-authored code on Deno specifically because “secure-by-default” permissions gave the team confidence to execute untrusted third-party code (Deno’s Slack case study).
What it does not prevent. The model’s central structural limitation: permissions are process-wide, not per-module. Deno documents this directly — “all code in the same thread shares the same privilege level” — and the NDSS 2025 academic study confirms there is “no built-in compartmentalization” mechanism, so once an application needs network access, “every dependency in the process also receives network access” (Deno security documentation; AlHamdan et al., NDSS 2025; safeguard.sh analysis). Permission fatigue is empirically documented: of 5,400 studied deno.land packages, only 53 used fine-grained permissions while 33 instruct users to run with --allow-all (NDSS 2025). Coarse grants leak finer authority — the same study shows --allow-read alone can read /proc/self/environ to bypass --allow-env, and --allow-run amounts to a full sandbox escape (NDSS 2025); fine-grained file permissions were also bypassable via symlinks (CISPA). Subprocesses and native code run entirely outside the sandbox and are “unconstrained on the host” (Abbadini et al., Cage4Deno, ASIACCS 2023). Logic bugs and prototype pollution within a granted scope are untouched — permissions gate resource access, not behavior (CISPA). The static module graph loads with no permission checks at all, and the same NDSS study found 13% of import URLs unversioned and 1,332 packages that had vanished by the study date (NDSS 2025). And Node dependencies loaded via npm compatibility are “automatically granted full access to system I/O” (Deno security documentation) — the single most important caveat for anyone adopting Deno specifically as an npm-ecosystem defense.
Adoption. JSR, Deno’s registry, held 17,375 packages and 21,222 users as of September 2026 (jsr.io metrics API). Deno crossed 100,000 GitHub stars by end of 2024, with named enterprise users including Netlify and Slack (Deno in 2024; Deno for Enterprise). Against this, Stack Overflow’s 2024 developer survey put Deno at 1.9% versus Node.js’s 40.8% (Human Who Codes), and the same source notes adoption “remains limited” seven years on, with Deno Deploy regions decreasing and JSR’s momentum “appear[ing] to have diminished.” Deno’s average package carries roughly six total dependencies versus ~174 per typical Node application (NDSS 2025; Cage4Deno) — a smaller ecosystem that is itself part of Deno’s current attack-surface profile.
Strongest published criticism. The strongest academic critique is AlHamdan et al., “Welcome to Jurassic Park: A Comprehensive Study of Security Risks in Deno and its Ecosystem,” NDSS 2025, which maps 103 Deno APIs to permission types, demonstrates the “shadow permissions” bypass class, quantifies the ecosystem’s overwhelming preference for coarse grants, and concludes Deno needs per-module permission manifests and compartmentalization (NDSS 2025) — disclosure from this work produced two security advisories. Abbadini et al., “Cage4Deno,” ASIACCS 2023, argues the sandbox is incomplete by construction because subprocesses and dynamic libraries execute outside it entirely (Cage4Deno PDF). Most tellingly, Vasilakis, Staicu, Ntousakis, Kallas, Karel, DeHon, Pradel, “Mir,” CCS 2021, built per-module RWX-based privilege reduction for Node.js achieving 15.6×–706× (mean 224.5×) privilege reduction across 50 libraries at only 1.93% runtime overhead (Mir; ACM DL) — direct evidence that Deno’s process-wide granularity is a design choice, not a performance necessity. On the engineering side, per-module permissions were proposed on Deno’s very first week of public existence (denoland/deno issue #171, opened 6 June 2018) but closed within two days as having “way too many holes”; eight years later, NDSS 2025 identifies the same gap.
3.2 Capability-Safe Languages
All five designs below descend from the object-capability model formalized in Mark Miller’s dissertation: a reference “indivisibly combines designation of the object, permission to access it, and the means to access it”; forged pointers and mutable static state are prohibited; and “only connectivity begets connectivity” — new authority arises only through initial conditions, parenthood, endowment, or introduction (Miller, Robust Composition, 2006). The supply-chain argument follows mechanically: if a library cannot obtain filesystem or network authority except by being explicitly handed it, a compromised dependency that suddenly needs network access becomes visible in its type signature rather than hidden in ambient global state.
3.2.1 Austral
Mechanism. Austral’s capability security falls out of linear types: a capability is “an unforgeable proof of authority to perform an action,” and because linear values cannot be duplicated, capabilities can be consumed or surrendered but never copied (Austral language specification). The only built-in primitive is RootCapability, available solely to main; all other capabilities must be derived from a broader one, and the standard library design is hierarchically attenuating — a Filesystem capability yields a root Path, which yields sub-paths but cannot navigate upward to a parent (Austral capability-based security tutorial). Its designer frames the whole motivation as supply-chain risk: under conventional languages “all code has the same permission level: do anything,” whereas in Austral “a string-pad function requesting network access would instantly stand out” (Borretti, “Introducing Austral”).
What it prevents. Ambient authority in library code, since capabilities “cannot be acquired out of thin air; they must be passed by the client” (Austral specification). Authority amplification via copying, blocked by linearity. Directory traversal out of a granted subtree. Signature-invisible authority — the project’s stated claim is that dependencies constrained by explicit capabilities make Austral programs “less vulnerable to supply chain attacks” (austral/austral).
What it does not prevent. This is unusually well documented by the language’s own author, who concludes the model is “good—but not good enough” and that supply-chain attacks remain possible in Austral, with the gain being only that audit scope shrinks to unsafe modules (Borretti, “How Capabilities Work in Austral”). The FFI is a complete escape hatch — the only restriction on foreign calls or unsafe pointer arithmetic is that the enclosing module be marked unsafe, and the maintainer’s own RFC states a compromised package could “completely bypass the capability hierarchy” via Unsafe_Module (Austral RFC #438). Unforgeability is not machine-enforced end to end — it “must be implemented manually by the programmer” as a library-design convention. Capabilities are irrevocable by default, with no built-in revocation primitive. And capability security “is not a first-class feature of Austral; it is mostly a consequence of linear types” (RFC #438).
Adoption. A single-maintainer research/hobby language, near-dormant in release terms: 1,573 GitHub stars, last push 2025-07-28, latest tagged release 0.2.0 dated 27 June 2023, no package manager, and the repository’s own words: “there isn’t enough Austral code out there for it to matter” (austral/austral on GitHub). No production users or download counts exist to report.
Strongest published criticism. No peer-reviewed critique exists. The strongest published assessment is the essay “What Austral Proves”, arguing Austral is more restrictive than Rust, needs verbose explicit destructors and an escape hatch for cyclic data, and has a “nascent” ecosystem — concluding it is too early to assess for production use. The second-strongest critique is the language author’s own self-criticism of the FFI-bypass, irrevocability, and global-uniqueness gaps.
3.2.2 Pony
Mechanism. Pony implements the object-capability model directly: capabilities are unforgeable tokens issued only through constructors, since Pony is memory-safe with no pointer arithmetic, and the language has no global variables or functions, removing ambient authority — while the tutorial itself warns “having no global variables is necessary but not sufficient” (Pony object-capabilities tutorial). System authority enters through Main’s Env, which contains an unforgeable AmbientAuth token whose constructor is private to the builtin package, so only the runtime can create one; authority is then attenuated down a typed hierarchy (AmbientAuth → NetAuth → TCPAuth → TCPConnectAuth) enforced entirely at compile time (Pony derived-authority tutorial). Orthogonally, Pony’s six reference capabilities statically guarantee data-race freedom even across asynchronous actor messages carrying mutable data (Clebsch, PhD thesis, Imperial College London, 2017).
What it prevents. Forged references, via memory safety and the absence of pointer arithmetic. Ambient authority through globals, since the language has none. Over-broad network access, since a library needing only outbound TCP can be handed TCPConnectAuth rather than AmbientAuth, with the tutorial turning this into an explicit auditing rule: “if a library asks for more authority than it needs, do not use the library” (Pony derived-authority tutorial). Data races and lock-based concurrency bugs, statically. Uniquely among the capability languages surveyed here, Pony allows restricting FFI to an explicit allow-list of “safe” packages (ntecs.de).
What it does not prevent. The C-FFI is an explicit trust boundary that voids everything — Pony’s own tutorial states “all Pony guarantees regarding not crashing, memory safety, and concurrent correctness can be voided by calling FFI functions” (Pony C-FFI tutorial); an independent analysis generalizes this into “FFI can circumvent any security architecture,” illustrated with a malicious Rust crate scanning memory via a static initializer (ntecs.de). Over-granting AmbientAuth collapses the model entirely — the documentation warns it “should never be given to code that is not trusted completely” (Pony derived-authority tutorial), and nothing forces attenuation beyond convention. Runtime internals themselves retain ambient authority (the cycle detector’s address is global). And authority is static-only, with no runtime enforcement, audit trail, resource limits, or revocation primitive documented.
Adoption. The healthiest of the five capability-safe languages surveyed, though still a small community: 6,183 GitHub stars, still shipping releases as of this writing (0.72.0, 2026-09-11), 199 contributors, and the project states applications “are currently used in production environments” while also noting it remains “pre-1.0” with “semi-regularly” breaking changes (ponylang/ponyc on GitHub). No named production deployments or user counts were located.
Strongest published criticism. No peer-reviewed paper attacks Pony’s capability model; the peer-reviewed literature on Pony is largely by its own designers. The strongest published criticisms are therefore the FFI trust-boundary critique Pony documents against itself, the generalized ocap-defeating-FFI argument in independent analysis (ntecs.de), the supply-chain-safety-by-default objection raised in community discussion, and the project’s own pre-1.0, breaking-changes posture as an adoption risk.
3.2.3 E
Mechanism. E is the original object-capability programming language, designed by Mark Miller in 1996, whose theory is his dissertation Robust Composition: Towards a Unified Approach to Access Control and Concurrency Control (Johns Hopkins, 2006), which also presents CapDesk, a virus-safe desktop written in E (thesis PDF). Objects interact only by sending messages over references that indivisibly bundle designation with permission; forged pointers and mutable static state are prohibited; connectivity arises only from initial conditions, parenthood, endowment, or introduction. Miller’s sharpest framing of why conventional systems are supply-chain-hostile: operating systems “generally grant nearly every program a user launches the user’s full authority,” where cat handed already-open file descriptors needs only rights to those two files, while cp handed filename strings needs authority over the whole namespace (Miller’s thesis).
What it prevents. Ambient authority in its entirety, by construction. Authority leakage between mutually suspicious components, since disjoint reference-graph subgraphs cannot become connected without an introduction. Virus-style full-authority execution of downloaded programs, demonstrated by CapDesk. Loss of robustness under malice, via “defensive consistency”: reducing a client’s authority reduces the cases an object must defend against.
What it does not prevent. Covert channels and side channels are explicitly out of scope, per Miller and Shapiro’s own canonical limitations list, Paradigm Lost (erights.org). Uncontrolled subjects cannot be confined, since confinement requires the subject’s initial conditions be under the confiner’s control. A raw capability grants “unconditional, full, and perpetual access” that can exceed least authority; narrowing it requires wrapper patterns, and revocation is infeasible without them. Authority is not equal to the permission arrangement — the confused-deputy problem: if Alice holds a file and chooses to forward its contents, Bob obtains the information despite holding no capability to the file itself. Attenuation is only as strong as the wrapper — a full membrane is required whenever a wrapped object is untrusted (Stefan and Mitchell, Stanford). And the Java-subset descendant Joe-E states plainly that the ocap approach “does not limit CPU/memory consumption or nontermination” (Mettler, Wagner, Close, “Joe-E,” NDSS 2010).
Adoption. Historically important, effectively inactive as a working language today. Both the e-lang and cap-talk mailing lists are labeled “historical” on the project wiki (erights.org wiki), and the download page offers no numbered releases, directing users to a stale Subversion trunk. E’s lineage, rather than E itself, is what has real-world adoption: Hardened JavaScript / SES directly inherits the ocap design, shipping as an npm package where Compartments “initially receive no ambient authority” and lockdown() freezes shared intrinsics against prototype pollution (npm ses package); SES is actively released (1.9.0) and feeds TC39 proposals, with Miller presenting Immutable ArrayBuffers reaching Stage 1 (SES 1.9.0 release notes).
Strongest published criticism. Miller and Shapiro’s own Paradigm Lost remains the most authoritative statement of the model’s boundaries. The strongest formal critique is Toby Murray’s PhD thesis, “Analysing the Security Properties of Object-Capability Patterns” (Oxford, 2010), which shows capabilities regulate direct invocation while information still flows through covert channels, that the published Data-Diode pattern actually violated its own non-interference property (an FDR model-checker counterexample), that the Membrane pattern is too expensive for ocap operating systems in practice, and that “no real ocap system has a fairness proof” (Murray thesis). A 2024 Journal of Object Technology paper adds that ocap “only limits the ability to access objects, but not the ability to perform specific operations,” that downcasting defeats narrow interfaces, and that membranes impose “extremely high” programmer burden with no safe way to know a component’s required authority (Wismüller, Ludwig, Breitweiser, JOT 23(1), 2024).
3.2.4 Wyvern
Mechanism. Wyvern makes modules first-class, statically typed capabilities. Its module system splits modules into resource modules (ML-style functors requiring explicit capability arguments before touching system resources) and pure modules (no system resources, no mutable state, freely importable). Authority for resource modules is explicitly non-transitive — a wordCloud module handed a logger does not thereby gain the logger’s file or FFI authority — which is what lets an auditor bound a module’s capability reach by inspecting interfaces alone, “in the style of the E programming language” (Melicher, Shi, Potanin, Aldrich, ECOOP 2017). A working demonstration built a full I/O library with a four-level filesystem capability hierarchy, where reaching Java requires a special java FFI capability the runtime passes only to the top-level script (Fish, Melicher, Aldrich, Onward! 2020).
What it prevents. Transitive authority creep — the defining property. Hidden authority in dependencies, since bounded, inspectable interfaces let an auditor determine what a module can do without reading its body. Ambient system access by ordinary library code, since pure modules provably touch no system resources. Over-broad file access, via strict narrowing from filesystem to directory to file to a read- or write-only handle. Uncontrolled FFI escape, since reaching Java requires an explicitly distributed capability.
What it does not prevent. Anything below the FFI boundary — the I/O library is 1,559 lines, of which 731 (47%) are trusted Java wrapping Java’s own I/O, so the guarantees rest on a trusted native layer and correct capability distribution by the top-level script (Onward! 2020). Coverage gaps in the capability hierarchy itself — the design does not provide read/write/append capabilities for directories or unopened files, leaving that to programmer discretion. Resource exhaustion, nontermination, and covert channels, not addressed in any retrieved Wyvern paper. And attacks on the package/build layer entirely — Wyvern has no package manager or registry.
Adoption. An academic research artifact with no production use, and development appears to have stopped: the project’s publication list runs 2013–2020 and then ends. The repository shows 565 stars and 29 contributors, and the three most recent commits (dated 2026-09-03) are only automated Dependabot npm version bumps to a demo frontend — not language development (wyvernlang/wyvern on GitHub). No production users were found.
Strongest published criticism. No published criticism of Wyvern specifically was located — a direct consequence of its status as a small academic project, and this absence is stated rather than papered over. The strongest available critical evidence is indirect: the authors’ own framing of their evaluation as “preliminary evidence,” the general ocap critiques that apply to Wyvern’s model (Wismüller et al.’s point that ocap restricts reachable objects but not permitted operations, and Murray’s covert-channel results), and the trusted-Java-layer dependency visible in the case study’s own line counts.
3.2.5 Roc’s Platforms
Mechanism. Roc inverts the usual arrangement: the standard library contains no I/O at all, and every application is built against exactly one “platform” — a host, written in another language (commonly Zig), that implements main(), memory allocation, and every effect primitive the application can call (Roc platforms language reference). Because the platform defines the entire effect vocabulary, it can be domain-restricted (a browser platform need not expose filesystem access), and FFI is reachable only through platform-provided primitives. The documentation’s strongest claim: “there are no escape hatches that a malicious program could use to get around these guarantees” (Roc platforms reference). The stated supply-chain vision is a “safe scripting” platform that prompts users like a browser would, making running a downloaded Roc program “as safe as a web browser” (GOTO interview with Richard Feldman). Notably, this is not an object-capability design in the E/Pony sense — there is no unforgeable-reference discipline inside the language itself; the boundary is drawn entirely at the platform/host interface.
What it prevents. Ambient I/O in library code, since no I/O exists in the standard library at all. Domain-inappropriate effects, since a platform can simply not expose filesystem access. Unrestricted native-code escape, since FFI is reachable only through platform-provided, potentially sandboxed or forbidden, primitives.
What it does not prevent. Denial of service — there is “no mechanism for CPU/memory limits, infinite loops, or catastrophic regex” (Lobsters discussion of Roc). Anything at all, if the platform is permissive: the guarantee is entirely a function of which platform is in use, and a general-purpose CLI platform exposing full filesystem and network access gives a dependency exactly the same authority it would have in Node or Python. The restricted “sandbox” platform that would deliver Roc’s supply-chain safety story does not yet exist — Feldman describes it as something he hopes someone will build. Per-dependency attenuation is also absent: the platform grants effects to the application as a whole, with nothing in the documentation describing differential grants to individual dependencies. And the host itself is unverified, trusted native code — the same structural caveat as Wyvern’s Java layer and Austral’s unsafe modules.
Adoption. Pre-0.1 alpha; the repository states Roc is “not ready for a 0.1 release yet,” with 6,043 GitHub stars and only alpha releases published (roc-lang/roc on GitHub). The compiler was rewritten from roughly 300,000 lines of Rust to about 464,000 lines of Zig over 487 days, with 0.1.0 targeted later in 2026. The only named real-world use located is Vendr calling Roc from a Node.js backend via roc-esbuild — a language-embedding use case, not a security deployment. The supply-chain security story should be read as a design direction, not a shipped defense.
Strongest published criticism. No peer-reviewed work exists on Roc’s platform model. The strongest published criticism is community discussion arguing the platform model amounts to “vendor lock-in,” risks incompatible competing platforms, invites semantic drift and undefined behavior across independent platform reimplementations of the same primitives, and produces divergent concurrency semantics between platforms — with the additional observation that making Task a built-in construct lets packages perform I/O portably, which itself weakens the platform-as-gatekeeper story (r/roc_lang discussion).
3.3 Language-Level Synthesis
Every design in this cluster shares the same load-bearing weakness: a native-code boundary. Deno’s --allow-ffi/--allow-run leave subprocesses “unconstrained on the host”; Austral’s unsafe modules can “completely bypass the capability hierarchy”; Pony’s own tutorial says FFI voids all its guarantees; Wyvern’s I/O library is 47% trusted Java; Roc’s host is unverified Zig code. Pony’s package-level FFI allow-list is the single most interesting mitigation found across all five languages. Granularity, not underlying mechanism, is the decisive design variable — Deno’s process-wide grant is exactly what NDSS 2025 flags as the absence of compartmentalization, and what Wyvern’s non-transitive per-module authority solves in principle; Mir’s demonstrated per-module RWX enforcement at ~1.93% overhead in JavaScript shows finer granularity is achievable today and undercuts performance-based objections to it. The security-usability gap is empirically confirmed rather than hypothetical for Deno (only 53 of 1,123 documenting packages used fine-grained permissions), though no comparable ecosystem-scale measurement exists for the capability languages simply because their ecosystems are too small to measure. Adoption is the binding constraint across all five language designs: Pony ships releases and claims production use; Austral, Wyvern, and Roc have none; E is historical, with its lineage living on in SES/Hardened JavaScript and Deno’s imperfect but shipping runtime sandbox. And no design in this cluster addresses resource exhaustion or covert channels — Joe-E states this outright for the ocap family, Murray formally demonstrates covert flows and the failure of a published pattern, Roc lacks CPU/memory limits, and Deno does not stop ReDoS or prototype pollution.
Cross-Cutting Comparison Across All Eleven Mechanisms
| Mechanism | Layer | Prevents (core) | Does not prevent (core) | Adoption (2025–2026) |
|---|---|---|---|---|
| Go checksum DB (GOSUMDB) | Registry | Transit tampering, retroactive tag rewriting, downgrade attacks (design doc) | Malicious-from-first-publish code; remediation after takedown (arXiv:2606.26291) | Default-on since Go 1.13 (2019), effectively universal |
| npm provenance / Sigstore | Registry | Post-publish tampering, dependency confusion, provenance spoofing (GitHub) | Compromised-but-legitimate CI pipeline; unverified installs (OpenSSF/SLSA) | ~25% of top packages by download (trusted publishing, late 2025) (Aikido) |
| PyPI Trusted Publishing | Registry | Long-lived token theft, workflow impersonation (PyPI docs) | Compromised workflow triggers, IdP compromise, offboarding gaps (PyPI security model) | >25% of monthly file uploads (Oct 2025) (PyPI blog) |
| SLSA | Build | Build injection, cache poisoning, forged provenance (SLSA requirements) | Malicious source, unsafe CI triggers, transitive dependency risk (SLSA threats) | Widely referenced, “not widespread” in practice (arXiv:2409.05014) |
| Reproducible builds | Build | Build-system compromise/SolarWinds-style injection (Fourné et al.) | Malicious source (reproduces identically); toolchain trusting-trust (arXiv:2607.24888) | 95%+ in Debian; 0–12% as-is in RubyGems/PyPI/Maven (ICSE 2025) |
| cargo-vet / cargo-crev | Build/audit | Unreviewed code entering builds, malicious version updates (LWN) | Faithless audits, compromised auditing orgs, sparse coverage (arXiv:2602.06466) | ~1% of crates.io reviewed (crev); ~8 trusted orgs (vet) |
| Deno permissions | Runtime | Ungranted file/network/env/subprocess access (Deno docs) | Process-wide (not per-module) grants; FFI/subprocess escape (NDSS 2025) | ~1.9% dev-survey share vs. Node.js’s 40.8% (Human Who Codes) |
| Austral | Language | Ambient authority via linear-type capabilities (Austral spec) | FFI/unsafe-module bypass; no revocation (RFC #438) | Single maintainer, last release 2023 |
| Pony | Language | Ambient authority; forged references; data races (Pony tutorial) | C-FFI voids all guarantees (Pony C-FFI tutorial) | Active releases, claimed production use, small community |
| E | Language | Ambient authority in its entirety; confused deputies (partially) (Miller’s thesis) | Covert channels; confinement of uncontrolled subjects (Murray thesis) | Historical; lineage lives on in SES/Hardened JS |
| Wyvern | Language | Transitive authority creep via non-transitive module capabilities (ECOOP 2017) | Everything below the trusted Java FFI layer | Academic artifact; no production use; inactive |
| Roc platforms | Language | Ambient I/O in library code; domain-inappropriate effects (Roc platforms reference) | Permissive platforms; DoS; host compromise | Pre-0.1 alpha; sandbox platform not yet built |
Conclusion
No single mechanism in this survey closes the supply-chain problem on its own, and each layer’s own documentation says so. Registry-level defenses (Go’s checksum database, npm provenance, PyPI Trusted Publishing) authenticate what was published and how, but not whether it should be trusted. Build-trust frameworks (SLSA, reproducible builds, cargo-vet/crev) authenticate the process that produced an artifact or the fact that a human looked at the source, but concede they cannot mitigate a malicious producer who simply follows the rules. Language- and runtime-level defenses (Deno, and the capability-safe languages) constrain what already-running code can do, but every implementation surveyed has an FFI, subprocess, or native-host escape hatch that voids the guarantee, and none of them addresses resource exhaustion or covert channels. The empirical throughline across the 2025–2026 incident record — Shai-Hulud, Mini Shai-Hulud, the TanStack/Nx npm worm — is that attackers have already adapted to this layered defense stack by targeting its shared blind spot: compromising a legitimate, already-trusted CI pipeline from the inside, where cryptographic attestations remain accurate but the underlying build is not what its producer intended. The strongest recurring criticism across all eleven mechanisms, echoed independently by USENIX Security 2025’s practitioner interviews, is that verification tooling exists but is rarely used — signing and attestation infrastructure has outpaced the organizational discipline to actually check it.