One review a year. 113 releases and 21 changes in who publishes, in the same twelve months.
Third-Party Risk Management (TPRM)
Third-party risk management (TPRM) is how an organization assesses, contracts with, and monitors the outside vendors, services, and code it depends on.
Also known as Third Party Risk Management, Vendor Risk Management, VRM, Supplier Risk Management
Third-party risk management (TPRM), also called vendor risk management, is the program an organization uses to find, assess, contract with, monitor, and exit the outside parties it depends on. It scales scrutiny to each party's inherent risk, because a vendor's failure becomes the customer's failure. Open source dependencies are third parties too, yet most TPRM programs never see them.
A TPRM program starts from an inventory, and the inventory usually starts from money: contracts, purchase orders, and accounts payable. Open source code arrives without an invoice, so it never enters the vendor register. We measured what that misses. On November 6, 2026, a fresh install of express@5.3.0 resolved 65 packages maintained by 85 npm accounts. All 65 licenses disclaim every warranty. In the preceding 12 months, those packages shipped 113 releases, and 21 came from an account publishing that package for the first time.
Our position: the TPRM lifecycle is sound, but its clock and its unit of review are wrong for open source. Vendor programs reassess their most critical suppliers once a year. Open source changes code and changes hands on a schedule measured in days. For a dependency, the event that matches onboarding a vendor is resolving a new package version. That is where the assessment belongs: on the code inside the version, before it installs.
What is third-party risk management?
#Third-party risk management is the discipline of treating every outside relationship as a risk the organization still owns. US banking regulators state the principle directly in their 2023 interagency guidance: "A banking organization's use of third parties does not diminish its responsibility to meet these requirements." The Federal Reserve, FDIC, and OCC finalized that guidance on June 6, 2023.
The guidance describes a five-stage life cycle that most TPRM programs follow in any industry:
- Planning: decide whether to use a third party at all, and what could go wrong.
- Due diligence and selection: collect evidence about the candidate's controls and condition.
- Contract negotiation: write security, audit, and notification obligations into the agreement.
- Ongoing monitoring: reassess on a schedule and watch for material changes.
- Termination: exit cleanly, recover data, and move the service elsewhere.
Not every vendor gets the same scrutiny. The guidance notes that "not all relationships present the same level of risk." Programs score each vendor's inherent risk from the data it touches, the systems it reaches, and how critical its service is. A payroll processor holding employee bank details lands in the top tier; an office caterer does not. The tier sets how deep due diligence goes and how often the vendor is reviewed. Venminder, a TPRM vendor, suggests reassessing critical and high-risk vendors annually, moderate-risk vendors every 18 months to two years, and low-risk vendors every two to three years.
Due diligence evidence is mostly documents. Teams collect security questionnaires, SOC 2 Type II audit reports, ISO/IEC 27001 certificates, penetration test summaries, and insurance certificates. Many add outside-in security ratings that scan a vendor's internet-facing hosts. All of it describes an organization's controls at a point in time.
TPRM also reaches past direct vendors. A vendor's own suppliers are fourth parties, which the interagency guidance calls subcontractors. Fourth-party risk is how software components usually enter a TPRM program, as we explain below.
The terms overlap. Vendor risk management (VRM) is usually a synonym. Cyber supply chain risk management (C-SCRM) is the cybersecurity slice, with extra attention to whether the product you received is the one the supplier built. TPRM also covers financial, operational, compliance, privacy, and reputational risk.
Why is third-party risk management important?
#Third-party risk management is important because attackers and regulators both treat a vendor's failure as the customer's failure. Verizon's 2025 Data Breach Investigations Report found third-party involvement in 30% of breaches, double the prior year. The report, published April 23, 2025, analyzed 12,195 confirmed breaches.
Regulators have turned that exposure into obligations:
- US banks: the 2023 interagency guidance covers every third-party relationship, including software purchases.
- EU financial entities: the Digital Operational Resilience Act (DORA) has applied since January 17, 2025, and requires a register of information on contracts with ICT third-party service providers.
- Organizations that adopt NIST CSF 2.0: the framework, released February 26, 2024, moved supply chain risk into its new Govern function. Outcome GV.SC-04 reads: "Suppliers are known and prioritized by criticality."
All three regimes key on relationships. Each asks the organization to know its suppliers, grade them, bind them by contract, and watch them. That design fits a cloud provider with a sales team and an audit report. It assumes things an npm package does not have.
How is third-party risk assessed?
#Third-party risk is assessed as likelihood and impact, applied to each relationship. NIST SP 800-30 Revision 1, the federal guide to risk assessment published in September 2012, defines risk as "a measure of the extent to which an entity is threatened by a potential circumstance or event." It treats risk as a function of the adverse impact and the likelihood of that impact.
Most programs score qualitatively. Questionnaire answers produce an inherent risk tier: critical, high, moderate, or low. Evidence of controls lowers that to a residual rating. The residual rating decides what the business must remediate, accept, or avoid.
FAIR replaces the tiers with money. Factor Analysis of Information Risk (FAIR) is standardized by The Open Group as the Risk Taxonomy (O-RT) 3.0 and Risk Analysis (O-RA) 2.0 standards, both from November 2020. The FAIR Institute defines risk, following the Open FAIR standards, as "the probable frequency and magnitude of future loss." It splits frequency into threat event frequency, how often a threat acts against an asset, multiplied by vulnerability, the share of those events that become losses.
FAIR's factors map onto a dependency better than questionnaires do, because each one points at something observable:
| FAIR factor | For a SaaS vendor | For an open source dependency |
|---|---|---|
| Threat event frequency | Attacks against the vendor's environment | Publish events. Every new version can carry new code, and every account that can publish is a target. |
| Vulnerability | Weak vendor controls | Whether your installs accept the new version (open ranges, no cooldown) and whether it executes (install scripts, build-time imports). |
| Loss magnitude | Data the vendor holds about you | Credentials and data reachable where the code runs: laptops, CI runners, production hosts. |
| Evidence | Questionnaires, SOC 2 reports, ratings | Registry metadata and the package's code. |
Verdict: use FAIR when you must compare dependency risk and vendor risk in one currency. Use the mapping even if you never compute a dollar figure. It shows which levers move the number: fewer accepted versions, fewer places where third-party code executes, and fewer credentials in those places.
Where does open source fit in third-party risk management?
#Open source usually fits nowhere in a third-party risk management program, because the program's inventory is built from commercial relationships. TPRM teams assemble vendor lists from contracts, procurement systems, accounts payable, and single sign-on logs. Venminder suggests pulling the last 24 months of payments to seed the inventory. A package installed from npm, PyPI, or Maven Central creates none of those records.
Open source enters sideways, as a fourth-party question. CISA's Secure by Demand Guide, published in August 2024, lists questions buyers should ask software makers. One reads: "Does the SBOM enumerate all third-party dependencies, including open source software components?" That question makes each vendor answer for its own open source. Code your own engineers and AI coding agents pull in falls to application security tools such as software composition analysis, outside the TPRM register.
The result is inverted. The third parties with the most access run inside your builds, on developer machines, and in CI next to deploy credentials. They are also the ones with no vendor record.
One web framework, 65 third parties
#To make the gap concrete, we installed one web framework into an empty project and treated every resolved package as a third party:
mkdir tprm-demo && cd tprm-demo
npm init -y
npm install --ignore-scripts express@5.3.0The lockfile resolved 65 packages: express and 64 transitive dependencies. We read each resolved version's record from the public npm registry at https://registry.npmjs.org/<name>/<version>, plus each package's full release history. As of November 6, 2026:
| Measure | Value |
|---|---|
| Packages in the lockfile | 65 |
| npm accounts listed as maintainers | 85 |
| Distinct identities that published the resolved versions | 17, including npm's trusted publishing identity |
| Packages with exactly one maintainer | 26 |
| Resolved versions with a provenance attestation | 4 |
| Licenses | 60 MIT, 4 ISC, 1 BSD-3-Clause |
| Licenses that disclaim all warranty | 65 of 65 |
| Releases across the 65 packages, November 2025 to October 2026 | 113, in 26 packages |
| Releases by an account publishing that package for the first time | 21, in 15 packages |
In TPRM terms, one line in package.json created 65 supplier relationships and gave 85 accounts a path into your build. One maintainer account alone published 19 of the 65 resolved versions. A vendor program would call that concentration risk: one phished login reaches nearly a third of the tree.
Each version's registry record carries supplier identity in machine-readable form. Here is the record for express@5.3.0, trimmed:
{
"name": "express",
"version": "5.3.0",
"license": "MIT",
"_npmUser": {
"name": "GitHub Actions",
"trustedPublisher": { "id": "github" }
},
"maintainers": ["wesleytodd", "jonchurch", "ctcpip", "ulisesgascon", "sheplu"],
"dist": {
"attestations": {
"provenance": { "predicateType": "https://slsa.dev/provenance/v1" }
}
}
}The _npmUser field records who published the version. "GitHub Actions" with a trustedPublisher entry means npm trusted publishing: a CI workflow published it with a short-lived OIDC credential instead of a stored token. The attestation ties the tarball to its source repository and build. That record, called package provenance, is the closest open source gets to supplier evidence. Only 4 of the 65 resolved versions carry one.
The contract stage collapses to a license. The express LICENSE file, an MIT License, says: "THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED." There is no right to audit, no breach notification clause, and no service level. Responsibility stays entirely with the user.
What supplier-level checks missed in the Qix compromise
#The Qix compromise shows why supplier-level evidence is not enough. The debug package is a direct dependency of express. On September 8, 2025, an attacker phished the npm account of debug's maintainer and published debug@4.4.2 with a payload that rewrote cryptocurrency transactions in browsers. The registry removed that version, but its publish time is still in the package document:
curl -s https://registry.npmjs.org/debug \
| jq '{published: .time["4.4.2"], still_listed: (.versions | has("4.4.2"))}'{
"published": "2025-09-08T13:12:39.973Z",
"still_listed": false
}A user reported the malicious version on GitHub at 13:35:26 UTC, 23 minutes after it was published. We reported at the time that the affected packages generally receive 2 to 3 billion downloads per week. express@5.1.0, the current release that day, declared "debug": "^4.4.0", a range that accepts 4.4.2. A fresh install of express without a lockfile, during the attack window, would have resolved the malicious version.
Every supplier-level check passed. The publisher was the account that had shipped debug's previous releases. A vendor reviewed last month, last week, or that morning would have looked the same. Only the code in 4.4.2 had changed.
The TPRM lifecycle against an npm dependency
#The TPRM lifecycle against an npm dependency keeps its stages but loses most of its evidence. Here is each stage from the interagency guidance, translated:
| Stage | What a vendor program does | What an npm dependency offers | What to do instead |
|---|---|---|---|
| Planning | Business case, risk appetite, approval | A developer or agent runs npm install | Policy on which registries, scopes, and package ages builds may accept |
| Due diligence | Questionnaires, SOC 2 report, ratings | Registry metadata and the code. Nobody answers questions. | Analyze each version's code and install-time behavior before it runs |
| Contract | Security clauses, audit rights, breach notice | A license that disclaims all warranty | No contractual remedy exists, so the controls must be technical |
| Ongoing monitoring | Reassess every 1 to 3 years | New versions and new publishers at any time | Reassess on every resolved version and every publisher change |
| Termination | Exit plan, data return | Remove or replace the package; override transitive copies | Keep an inventory precise enough to find every copy, including npx and CI runs |
Verdict: keep the vendor lifecycle for commercial suppliers, where contracts and audits are real. For open source, keep the stages and change the trigger. The unit of review is a package version, and the review runs when a version is resolved, not when the calendar says so.
Monitoring shows the mismatch most clearly. In a vendor program, a change of control, such as an acquisition or a new subcontractor, triggers reassessment. On npm, the equivalent is a new account publishing a package. Across the express tree, that happened 21 times in 12 months.
Figure 1 in text: releases per month across the 65 packages, November 2025 through October 2026, were 9, 13, 3, 30, 3, 6, 10, 6, 5, 6, 6, and 16, for 113 in total. Releases by an account publishing that package for the first time were 2 in November, 1 in December, 0 in January and February, 1 in March, 2 in April, 3 in May, 2 in June, 1 in July, 2 in August, 4 in September, and 3 in October. Ten of those 21 came from individual maintainer accounts, all between November and June. The other 11, from June onward, were packages moving to npm trusted publishing. Every one of February's 30 releases came from one package, qs, publishing patches across its older 6.x minor lines. One annual reassessment would have looked at this tree once.
Most of the 21 events were benign: maintainers in the Express project's GitHub organizations taking over releases of individual packages, and packages moving to trusted publishing. That is the problem with change-of-control triggers on npm. They fire about twice a month for one framework, so a human review queue would drown. Socket's New author alert fires on this event, when a collaborator publishes a version of a package for the first time, and because the review behind it is automated, it keeps pace with that rate. It has a blind spot that the Qix compromise exposes. A maintainer account takeover publishes from an account that has published before, so no new author appears. Catching that case takes analysis of what the new code does.
Running TPRM at the speed of publishes
#Running TPRM on open source means keeping the program's structure and moving every control to the moment code is resolved. Each control below has a cost and a blind spot.
Inventory. A software bill of materials (SBOM) generated from lockfiles gives the register its supplier list. It misses code fetched at execution time. After the axios compromise, our follow-up, The Hidden Blast Radius of the Axios Compromise, put it plainly: "Lockfiles make existing installs deterministic. They do not make new installs safe." Tools run through npx and global installs in CI resolve dependencies outside any lockfile, and AI agents install packages in sandboxes that security tools do not watch. A complete register needs telemetry from CI and developer machines, which costs real engineering time.
Tiering. Vendor programs tier the supplier. For open source, tier the execution context instead. The same package is low risk bundled into a static web page and high risk running in a CI job that holds a registry publish token. The cost is that one package can carry several tiers at once.
Due diligence. Put the check where the acquisition happens: dependency resolution. A package firewall inspects each fetch before the package reaches disk. Socket Firewall works this way: it "operates as an HTTP/HTTPS proxy server that sits between package managers and package registries," and blocks packages flagged as malicious, according to its documentation. Its blind spot is the gap between a malicious publish and the finished analysis. A cooldown that refuses very new versions narrows that gap, at the price of delaying urgent security fixes by the same amount.
Supplier evidence. Provenance attestations and trusted publishing are the closest thing open source has to a SOC 2 report. They prove which repository and workflow built a package. They are necessary but not sufficient: a compromised maintainer, or attacker code that reaches a release workflow, publishes through the legitimate pipeline and gets valid provenance.
Concentration. Track publishing accounts as entities in the register, not just packages. An account that published 19 of your 65 resolved versions deserves the attention a vendor program gives a critical supplier. Its next release deserves a closer look than a leaf package's.
The open problem is accountability. The interagency guidance says an organization cannot hand off its responsibility to a third party. The license on every package in our tree says the third party never accepted any. Every npm install sits between those two texts. We think TPRM teams should own that register, with the same rigor they apply to vendors, instead of treating open source as a scanning problem that belongs to someone else.
