Back to Feed

The Reachability Factor - A Critical Method in Analyzing Vulnerable Transitive Packages

Yossi Pik


February 21, 2024


In the rapidly evolving landscape of software development, security has taken center stage. With the increasing reliance on open-source packages and the complexity of software dependencies, the challenge of maintaining a secure codebase has never been more critical. This post delves into the specific challenge of identifying and prioritizing vulnerabilities in transitive dependencies—those packages not directly included by developers but brought in by other packages—and how static code analysis emerges as a powerful ally in this endeavor.

Understanding Transitive Dependencies

Transitive dependencies, while not directly listed in a project's dependencies, play an indispensable role in modern software development, silently providing essential functionality. Despite their utility, the sheer number of these dependencies presents a formidable challenge; with transitive dependencies often outnumbering direct ones by ten to one, the task of identifying and addressing vulnerabilities within this extensive network becomes not just daunting but nearly impossible. This reality necessitates a shift towards strategic prioritization, focusing on mitigating risks posed by the most critical vulnerabilities rather than attempting to fix every identified issue.

The Role of Static Code Analysis

Static code analysis provides a comprehensive snapshot of a project's security posture by examining source code for potential vulnerabilities before execution. This analytical approach offers a proactive defense mechanism, particularly effective for uncovering hidden risks in transitive dependencies. By offering detailed insights into potential security issues without the need to run the code, static code analysis becomes an indispensable tool for AppSec professionals and developers alike, enabling them to identify, prioritize, and address vulnerabilities in an efficient and effective manner.

Identifying Vulnerabilities

Identifying vulnerabilities in software, including both direct and transitive dependencies, is a critical step in safeguarding applications. Static code analysis tools are key in this effort, not only for spotting potential security issues but also for generating a Software Bill of Materials (SBOM). An SBOM lists all components of an application, essential for understanding its security landscape.

These tools then cross-reference the identified components with known vulnerability databases, such as the National Vulnerability Database (NVD) and GitHub Security Advisories (GHSA), pinpointing documented security risks. This step is vital for accurately identifying vulnerabilities that could affect the application, leveraging comprehensive sources to ensure a thorough analysis.

Additionally, the Vulnerability Exploitability Exchange (VEX) format provides context on the relevance and severity of these vulnerabilities in specific applications, guiding prioritization in remediation efforts.

Exploring the generation of SBOMs, the use of vulnerability databases, and the intricacies of VEX is essential for comprehensive vulnerability management, yet these topics exceed the scope of this article.

Prioritization Criteria

When addressing vulnerabilities in transitive dependencies, not all issues warrant the same level of urgency. A systematic approach to prioritization can help focus remediation efforts where they are most needed, based on several key factors.

Objective Factors - General to All Applications

Severity: Utilizing scoring systems like the Common Vulnerability Scoring System (CVSS) provides a numerical indication of the potential impact a vulnerability could have if exploited. This score quantifies the risk and aids in prioritizing vulnerabilities that could cause significant damage.

Exploitability: The likelihood of a vulnerability being exploited can significantly affect prioritization. The Exploit Prediction Scoring System (EPSS) offers a probability score indicating the presence of an exploit for a given vulnerability. A higher EPSS score signals a greater chance of active exploitation, thus a higher priority for remediation.

Subjective Factors - Considering the Impact on the Application

The extent to which a vulnerability affects an application requires a nuanced analysis, as not all vulnerabilities have a direct or significant impact. To assess this, consider:

Development Dependency: Vulnerabilities in packages used only during development and not included in the final production build may have minimal direct impact on application security.

Code Reachability: Assessing whether there's a feasible path from the application's code to the vulnerable package—or more specifically, to the vulnerable function within that package—is crucial. This analysis identifies vulnerabilities that are not just theoretically present but are practically exploitable within the application's context.

Important Note on Malicious Package: For malicious packages, prioritization must immediately shift due to their inherent risk regardless of reachability or use as development dependencies. These packages (codes intended to cause harm, such as data theft or system corruption) require urgent action, emphasizing the need for comprehensive security vigilance.

Applying these criteria enables teams to effectively gauge which vulnerabilities pose the most immediate and severe threat to their applications and prioritize their remediation efforts accordingly. This prioritization ensures efficient allocation of resources, focusing on mitigating vulnerabilities with the potential to significantly impact the application's security posture.

Identifying Reachable Code Flows in Transitive Packages

The final and perhaps most crucial step in securing applications against vulnerabilities in transitive dependencies involves identifying reachable code and analyzing data flows. This process goes beyond merely listing components and their known vulnerabilities. It delves into the application's structure to determine if and how data interacts with potentially vulnerable code paths within transitive packages.

Identifying "Phantom" Packages

Ensuring application security goes beyond merely scanning the manifest for direct dependencies. Surprisingly common are “phantom” (AKA "shadow") packages, not explicitly declared yet utilized by the application, often slipping through due to overlooked development practices. Identifying these hidden dependencies is challenging, yet crucial, because they may embed unseen vulnerabilities within the broad network of an application's dependencies.

Runtime Package Loading

Another layer of complexity is presented by packages that are loaded at runtime, which may not leave explicit code evidence of their presence. Mechanisms such as the Service Provider Interface (SPI) allow for the dynamic discovery and loading of services at runtime, bypassing the static declarations found in code or manifest files.

Data Flow Analysis

Data flow analysis is a critical yet intricate component of security analysis, focusing on tracking how variables traverse the application. This includes, for example, navigating function calls, input parameters, return values, callbacks, events, and when functions are utilized as parameters. Such instances represent just a fraction of the complexities encountered, especially in dynamically typed languages where the lack of static type information further complicates the tracing of data flows. Grasping these data pathways is vital for identifying vulnerabilities that exploit specific data states or paths. Mapping the interaction of data throughout the application, including transitive dependencies, enables security teams to prioritize threats more accurately, concentrating on areas where the movement of sensitive data through vulnerable sections poses a real risk.


In conclusion, the integration of 'reachability' analysis into static code analysis merges the early detection and cost-saving benefits of static analysis with capabilities traditionally reserved for runtime analysis. This advancement ensures vulnerabilities are identified and addressed earlier in the development process, reducing remediation costs and enhancing software security. By leveraging reachability analysis, teams can now uncover hidden dependencies and potential threats with precision, previously only possible through runtime analysis, further optimizing development resources and improving the return on investment in security efforts.