November 13, 2026
A03: Software Supply Chain Failures — OWASP Top 10 (2025)
Part 3 of my OWASP Top 10 (2025) series. Catch up on A02: Security Misconfiguration and Broken Access Control — the #1 web security risk…

By Shruti Vijay Shinde
2 min read
Part 3 of my OWASP Top 10 (2025) series. Catch up on A02: Security Misconfiguration and Broken Access Control — the #1 web security risk before this one.
When building a web application, do developers write every line of code themselves? Of course not.
Modern applications depend on hundreds of libraries, frameworks, and packages developed by others. These dependencies save time, but they also introduce security risks.
That's where A03: Software Supply Chain Failures comes in.
Understanding Software Supply Chain Failures
Imagine building a house. You purchase cement, steel, wiring, and pipes from different suppliers instead of manufacturing everything yourself.
Now imagine one supplier delivers defective steel. Even if your construction work is perfect, the house can still become unsafe.
Software works the same way.
A Java application might use Spring, Jackson, or Log4j. A Node.js application might depend on Express, Axios, or Lodash. These are called dependencies software your application relies on but doesn't necessarily develop itself.
If one of these dependencies contains a vulnerability, your application may inherit that security risk.
That's the core idea behind Software Supply Chain Failures.
How Does a Pentester Test This?
Step 1: Identify the Technology Stack
First, understand what the application is built with:
- Frontend and backend frameworks
- JavaScript libraries
- CMS platforms
- Server software
- Third-party components
Step 2: Identify the Dependencies
Look for libraries such as:
- jQuery
- Angular
- React
- Lodash
- Moment.js
Sometimes their versions are visible directly in the application. Other times, you need to investigate further.
Step 3: Check for Known Vulnerabilities
Once you identify a library and its version, check whether it has known security issues.
Useful resources include:
Remember: An outdated version is not automatically vulnerable. Always verify the specific version and affected conditions.
Step 4: Look for Exposed Dependency Files
This is where recon gets interesting.
Sometimes developers accidentally expose files that reveal the application's dependencies and versions.
If these files are publicly accessible, they can provide attackers with a detailed roadmap of the application's software components.
My Experience: Finding a Real Supply Chain Issue
During recon on a target, I discovered two exposed files:
package.jsonnpm-shrinkwrap.json
The first listed the project's dependencies. The second revealed the exact resolved versions of those packages, including transitive dependencies. While reviewing the list, one package caught my attention:
Lodash — an outdated version.
Instead of immediately assuming it was vulnerable, I checked its known security issues. That's when I connected it to Prototype Pollution.
What Is Prototype Pollution?
Prototype Pollution is a JavaScript vulnerability where an attacker manipulates an object's prototype, potentially causing attacker-controlled properties to appear on other objects.
For example, if an application processes malicious input containing __proto__ without proper protection, an attacker may be able to modify Object.prototype.
This can become dangerous when application logic trusts inherited properties. Imagine an authorization check like:
if (user.isAdmin)
If isAdmin becomes an inherited attacker-controlled property, the application may incorrectly treat a user as an administrator.
Important: Prototype Pollution does not automatically grant admin access. Its impact depends on how the application handles polluted properties and whether vulnerable code paths can be exploited.
Why This Finding Matters
What made this interesting was that I didn't need to guess the application's dependencies.
The exposed files gave me the information. The dependency version helped me identify a known vulnerability. And that turned an ordinary recon observation into a meaningful security lead. This is exactly why exposed dependency files deserve attention during security testing.
You don't always need to break the application to find a weakness sometimes, it reveals one itself. Thank Your for Reading