An Empirical Study on CVE-based Vulnerabilities Propagation from one System to another System (IntraProject vs InterProject)
summary
The gist
Vulnerabilities in applications are often exploited and cause serious damage, making the propagation of software vulnerabilities a critical concern in cybersecurity The study examines the root cause…
In short
The study investigated how software vulnerabilities, specifically those identified by CVEs, spread between different software projects. Experiments showed that high-severity bugs often propagated through code reuse—copying and pasting insecure code—both within a single project (IntraProject) and across multiple independent systems (InterProject). This highlights the critical risk of sharing vulnerable components.
Key concepts
- CVE-based Vulnerabilities
- These are specific identifiers for known security flaws in software, like a bug in Linux or Android. The research tracked how these specific flaws moved from one piece of software to another, showing that simple code copying can spread serious problems.
- IntraProject Propagation
- This refers to vulnerabilities spreading within the same software project. It happens when insecure code is reused across different parts or modules of that single application, meaning a flaw in one area affects others inside the project.
- InterProject Propagation
- This describes vulnerabilities moving between entirely separate software systems. This often occurs when two different projects use the same vulnerable open-source library or framework, allowing a flaw in one to affect the other system.
- CVSS Score
- This is a standardized rating system used to measure how severe a vulnerability is. A score between 8 and 10 indicates a very high-risk issue that requires immediate attention because it can cause significant damage.
Terminology used across episodes
This episode discusses
- An Empirical Study on CVE-based Vulnerabilities Propagation from one System to another System (IntraProject vs InterProject) · Paper Radio
- Evaluating the Code Quality of AI-Assisted Code Generation Tools: An Empirical Study on GitHub Copilot, Amazon CodeWhisperer, and ChatGPT
- DeVAIC: A Tool for Security Assessment of AI-generated Code
The paper
An Empirical Study on CVE-based Vulnerabilities Propagation from one System to another System (IntraProject vs InterProject) · Read on arXiv
Junaid Akram, Ali Hassan, Danish Vasan
School of Computer Science, University of Nottingham Ningbo, China · Software Development and Operations, Punjab Sahulat Bazaars Authority, Lahore, Pakistan · Research Center for Intelligent Secure Systems, King Fahd University of Petroleum & Mineral
Vulnerabilities in applications, including browsers, media players, online services and document readers, etc. are often exploited and cause a serious damage. The vulnerabilities could exist in your system maybe because of some coding errors, design oversights, outdated software, AI generated codes or maybe transferred from another system during development (e.g., code clones). The propagation of software vulnerabilities is a critical concern in cybersecurity. This study examines the root cause problem of vulnerabilities propagation with experiments. We analyzed the propagation of CVE (Common Vulnerabilities and Exposures) based vulnerabilities within and between different software projects (IntraProject vs. InterProject). We performed several experiments on CVE based vulnerability dataset (retrieved from NVD source) by using our vulnerability detection tool (SQVDT). In the results, we discovered similar patterns of vulnerable code in several very famous recently used software, including latest version of Linux, Android operating systems, and in thousands of open source projects available on GitHub. We found several very high severity level (CVSS) vulnerabilities that propagated from one system to another system, just because of copy/paste (reuse) the code. Furthermore, we performed an empirical evaluation and verification of these vulnerable patterns that propagated to other systems by also considering the frequency of their propagation. Finlay, we recommended the impact of these vulnerabilities propagation on the interconnected systems.
Transcript
Introduction to the show: ident: Security Radio. Generated commentary on the latest security and cryptography papers.
Nadia: We're looking at the paper: "An Empirical Study on CVE-based Vulnerabilities Propagation from one System to another System (IntraProject vs InterProject)".
Elias: Here's the gist of the paper. Vulnerabilities in applications are often exploited and cause serious damage, making the propagation of software vulnerabilities a critical concern in cybersecurity The study examines the root cause problem of vulnerabilities propagation with experiments We analyzed the propagation of CVE-based vulnerabilities within and between different software projects (IntraProject vs.
Nadia: InterProject) In the results, we discovered similar patterns of vulnerable code in several very famous recently used software, including latest version of Linux, Android operating systems, and in thousands of open source projects available on GitHub We found several very high severity level (CVSS) vulnerabilities that propagated from one system to another system, just because of copy/paste (reuse) the code Vulnerability Landscape and Motivation The research is motivated by the prevalence and evolution of various types of software vulnerabilities over the years, categorized by common attack vectors such as Overflow, Memory Corruption, SQL Injection, XSS (Cross-Site Scripting), and others The data highlights the persistent and evolving nature of security threats in software Concerns motivating the research include the increase in software re-usability by simply cloning the code, which led to a big threat A lot of old vulnerabilities found in some latest open source software Difficulties to perform an audit on open source software before use their code to quick the process of development Software dependency to use some external components including libraries, utilities, and programs, which can be faulty or vulnerable The study employed several methods to gather data and detect vulnerabilities The methodology involved performing several experiments on CVE based vulnerability dataset (retrieved from NVD source) by using our vulnerability detection tool (SQVDT) We developed a crawler that extracted thousands of CVE based vulnerable source code fragments by tracing their patches The tool SQVDT detects vulnerabilities by employing a code clone and quantitative analysis of source code The methodology involves parsing the source code to create a series of tokens of the code, followed by the algorithms to extract different features from the code SQVDT achieved an exceptionally low false positive rate of just 1%, which reflects the tool’s strong accuracy in identifying true vulnerable instances Propagation Patterns Identified The analysis revealed distinct propagation patterns for IntraProject and InterProject vulnerabilities The root cause of these propagation often lies in the reuse of insecure software, frameworks, or modules across multiple projects without adequate security audits Mostly these vulnerabilities propagate either from code clones (copy/paste code), or code reuse in the software The study identified and categorized the propagation mechanisms of these CVE-based vulnerabilities Key Vulnerability Categories and Risks The analysis focused on several categories of propagated vulnerabilities, including Linux, Android, and Qemu systems as case studies IntraProject propagated vulnerabilities in Linux arise when a single vulnerability within the Linux codebase is inadvertently spread across multiple components or modules of the same project InterProject vulnerabilities often occur in scenarios where open-source libraries or frameworks are used across different software systems without rigorous security checks High risk vulnerabilities are classified based on the Common Vulnerability Scoring System (CVSS), with a CVSS score between 8 and 10 indicating criticality Implications for Security Management The findings reveal critical implications for vulnerability management, especially concerning to InterProject and IntraProject, posing significant risks the systems Proactive monitoring and timely patching are essential to prevent such vulnerabilities from being exploited Organizations must enforce rigorous security policies to ensure that vulnerabilities are not introduced into their systems The lack of coordinated updates and patches across third party libraries, further exacerbates the problem A big need is to analyze some AI-generated code fragments, that are causing the vulnerability propagation Future work should focus on enhancing vulnerability detection tools, particularly for AI-generated code, and developing a robust strategy for managing vulnerabilities in open-source software Code Reuse and AI Influence The propagation of vulnerabilities is often caused by the sharing of vulnerable code between software projects Cloned code can exist across multiple projects (InterProject clones) or within different components of the same project (IntraProject clones) AI-generated code can further complicate the issue of code clones As the AI tools often generate code based on the existing patterns or codebases, they may inadvertently introduce or replicate vulnerabilities found in their training data Systemic Issues and Recommendations Systemic issues are indicated by the presence of older vulnerabilities in the top 20 most propagated CVEs as shown in Figure 4, 10, 11, and 13 Many open-source projects rely on third-party libraries that might contain vulnerabilities The presence of long-known vulnerabilities like CVE-2020 or CVE-2023 in the top 20 list indicates a systemic issue where projects either do not prioritize updates or maybe lack the resources to do so The distribution underscores the need for targeted security efforts on the most propagated and critical vulnerabilities to lower down the widespread risks effectively There is a need for further research into the mechanisms of vulnerability propagation, with an emphasis on developing automated solutions to identify and mitigate these risks The results presented in this study should be interpreted as indicative rather than conclusive, and further research is needed to confirm these observations The growing complexity of software systems and the increasing reliance on open-source software, third-party components have significantly amplified the challenges associated with software security Our research highlights the persistent and evolving nature of software vulnerabilities propagation and emphasize the critical need for effective vulnerability management strategies We found several vulnerabilities that were propagated only because reusing the code through cloning techniques and the integration of third-party libraries into different projects There is a need for further research into the mechanisms of vulnerability propagation, with an emphasis on developing automated solutions to identify and mitigate these risks The study highlights the need for a holistic approach to vulnerability management that considers the broader context of software ecosystems References
Title and authors: Nadia: So, we're looking at this paper today, "An Empirical Study on CVE-based Vulnerabilities Propagation from one System to another System (IntraProject vs InterProject)." It looks like the authors are really digging into how these software flaws actually spread.
Elias: Yeah, they’re focusing on the difference between vulnerabilities that stay inside a single project and those that jump from one project to another. It’s about understanding if this spread is accidental or if there's a real pattern to it.
Priya: I wonder what kind of damage these propagated vulnerabilities actually cause in the real world, because just knowing they spread doesn't tell us much about the risk exposure for users.
Nadia: Exactly. The summary of the paper says they analyzed propagation within and between different software projects using CVE data, finding that similar patterns exist in some very famous recently used software like the latest versions of Linux and Android operating systems, plus thousands of open source projects on GitHub.
Elias: That’s a pretty broad sample size to draw conclusions from. The core discovery they highlight is that high severity level vulnerabilities, scored between eight and ten on the CVSS scale, can propagate from one system to another just because of code copy and paste, or code reuse.
Priya: So it sounds like the mechanism isn't some deep architectural flaw in a single system but rather something happening when developers take existing insecure code and put it somewhere else.
Nadia: That’s the simplest way to put it. The paper points out that this happens often because of how many people are copying and pasting code without doing a proper security audit first, which is a big issue with open source software today.
Elias: They also touched on some categories they looked at, like Linux and Android systems as case studies for IntraProject issues, and interproject issues when using open source libraries across different software systems without rigorous security checks.
Priya: When you look at the CVSS scores between eight and ten, that’s high severity. It means we're talking about vulnerabilities that are quite critical if they get exploited because they have a real chance of causing serious damage.
Title and authors: Nadia: Right. The methodology they used involved running experiments on CVE based vulnerability datasets from the NVD source using their own detection tool called SQVDT, which achieved a very low false positive rate of just one percent.
Elias: That low false positive rate suggests their detection method is quite accurate at finding true vulnerable instances when scanning the code fragments. They developed a crawler that extracted thousands of CVE based vulnerable source code fragments by tracing their patches, and then SQVDT does a code clone and quantitative analysis to detect vulnerabilities.
Priya: So they built a tool specifically designed to find these propagation patterns in the actual source code, rather than just looking at the vulnerability databases themselves. That’s valuable because it connects the abstract CVE ID to concrete code reuse.
Nadia: The paper identified distinct propagation patterns between IntraProject and InterProject vulnerabilities, which they linked mostly to the reuse of insecure software or frameworks across multiple projects without security audits.
Elias: They categorized these mechanisms clearly, showing how code clones and general code reuse in the software are often the root cause of this movement between systems.
Priya: I'm interested in what this means for us when we think about dependency management; it seems like simply having a vulnerable library doesn't matter as much as where that library gets copied next.
Nadia: It does. And they pointed out some systemic issues, showing older vulnerabilities in the top twenty most propagated CVEs, like CVE two thousand twenty or CVE two thousand twenty-three indicating projects aren't prioritizing updates enough <ref:2611.14164#pg3>.
Elias: That points to a need for more targeted security efforts on those specific, highly propagated and critical vulnerabilities to lower down the widespread risks effectively. The paper also suggests a big need for analyzing AI generated code fragments, which can further complicate this code clone issue.
Priya: It’s interesting that they flagged AI-generated code as something that needs extra scrutiny because it might be replicating vulnerabilities found in its training data before it even gets used.
Nadia: So the implication for security management is that proactive monitoring and timely patching are essential, especially when dealing with those interproject issues where you don't have a single codebase to control everything.
Title and authors: Elias: They also noted that the lack of coordinated updates across third party libraries really exacerbates this problem, which is a big systemic issue in the ecosystem right now.
Priya: Before we wrap up this paper, I think it’s important to remember that their study highlights how reliance on open source software and third-party components has amplified the challenges for everyone building software today.
Nadia: And I think the main thing is that while we have good detection tools like SQVDT, the real threat is this widespread code reuse across different systems.
Elias: Yeah, and they are suggesting that future work should focus on enhancing those vulnerability detection tools, especially for AI generated code, and developing a robust strategy for managing vulnerabilities in open source software.
Priya: So it’s not just about fixing the immediate bug but building a better system to prevent this type of contamination from happening in the first place.
Nadia: That seems to be the direction they are pushing toward, moving from reactive patching to more proactive ecosystem management.
Elias: And that brings us to the conclusion of this study, which emphasizes that we need a holistic approach to vulnerability management that considers the broader context of software ecosystems when dealing with CVE-based vulnerabilities propagation from one system to another system (IntraProject vs InterProject).
Priya: It’s a solid piece of empirical evidence showing exactly where the weak points are in the development and reuse pipeline.
Nadia: It definitely shows that the risk isn't just in writing new code, but in what we bring from elsewhere, whether it's a clone or a dependency.
Elias: And they are setting up a clear path forward by suggesting automated solutions to identify and mitigate these risks before they spread further.
Nadia: We’ll be looking at how those suggested improvements—like better clone detection and risk prioritization—can actually translate into practical fixes for organizations.
Priya: It’s a lot of data showing that the problem is systemic, not just isolated mistakes by one developer.
Elias: Exactly. So this paper on CVE-based vulnerabilities propagation from one System to another System (IntraProject vs InterProject) gives us a map of where the most dangerous code reuse is happening across our software projects.
The paper's summary: Nadia: So, we’re looking at how this research boils down to its main findings on CVE propagation between different software systems.
Elias: It really focuses on showing that there are distinct patterns when you look at vulnerabilities moving inside a single project versus moving between separate projects.
Nadia: The core discovery is that the biggest driver for these vulnerabilities spreading is the reuse of insecure code, whether it's copy and paste or just general code reuse across different software.
Elias: They found this happening in some really famous things, like the latest versions of Linux and Android operating systems, plus thousands of open source projects on GitHub.
Nadia: What they highlighted is that vulnerabilities with a high Common Vulnerability Scoring System score, between eight and ten, are the ones that jump systems because of this reuse.
Elias: It’s not just any bug; it’s the high severity stuff that gets propagated.
Nadia: The study sets up a way to measure this movement between IntraProject—vulnerabilities within one project—and InterProject—vulnerabilities jumping from one project to another.
Elias: They categorized these mechanisms clearly, showing exactly how this code reuse causes the spread.
Nadia: The implication for us is that we need better ways to manage the security of those third-party libraries and frameworks you pull in for your projects.
Elias: It points toward a systemic problem where projects aren't doing rigorous security checks before they integrate external components, which makes InterProject risks much higher.
Nadia: They also pointed out that older, known vulnerabilities are still showing up in the top twenty most propagated CVEs, which suggests many projects aren't prioritizing updates enough.
Elias: That means there’s a clear need for targeted security efforts focused on those specific critical vulnerabilities to lower the widespread risk effectively.
Nadia: This research really emphasizes that simply building new software isn't enough; we have to manage the entire ecosystem of code we depend on.
Elias: And they suggested that future work should focus heavily on developing better tools for vulnerability detection, especially for AI generated code fragments, because those can complicate this clone issue further.
Nadia: So the next step isn't just patching; it’s building automated solutions to identify and stop this propagation before it happens across projects.
Elias: We’ll talk more about what those specific proposed improvements mean for practical defense in the next part of the show.
The paper's improvements: Tom: So we’re moving on to what the authors are suggesting they should do next based on their findings about this CVE propagation study.
Nadia: They propose a few specific enhancements to make this whole process better, focusing on how we actually detect and handle these spreads.
Elias: They suggest enhancing the SQVDT tool, meaning it could be trained on patterns from AI code fragments so it can catch security loopholes like buffer overflows or SQL injection before deployment.
Nadia: That’s a smart move because the paper hinted that AI generated code might be complicating this code reuse issue, and training the detector on those patterns would help.
Elias: They also suggest building a propagation mapping system, which means creating a crawler that traces patches linked to CVE entries across multiple software projects.
Nadia: That would let them precisely map out those IntraProject versus InterProject spread mechanisms, giving us a much clearer picture of the routes these bugs take.
Elias: Then they talk about risk prioritization, which is implementing a module that scores detected vulnerabilities based on their CVSS scores and how often they appear in different project types.
Nadia: That would help security teams focus their limited time on the highest risk, most frequently spread issues that are actually causing the most damage.
Elias: They also suggest an automated dependency management system, which would synchronize patch application across all projects using shared libraries to cut down the delay between a vulnerability being found and it being fixed.
Nadia: That addresses the big systemic issue of delayed updates across third party components that we talked about earlier, trying to minimize how long a known vulnerability stays active in the wild.
Elias: Finally, they propose integrating a tool to detect code clones themselves, so developers can be guided to remove those duplicated vulnerable code fragments before they even integrate them into new systems.
Nadia: It sounds like their vision is moving from just reporting the problem to building proactive tools that actively prevent the propagation of bad code in the first place.
Elias: That shifts the goal from reactive patching to a more holistic strategy for managing vulnerability risk across entire software ecosystems.
Conclusion: Tom: So we're wrapping up this discussion on "An Empirical Study on CVE-based Vulnerabilities Propagation from one System to another System (IntraProject vs InterProject)."
Nadia: Basically, the paper confirms that vulnerability spread is a major issue because high severity flaws get copied and pasted across projects.
Elias: It solidifies the idea that code reuse, both intraproject and interproject, is a primary driver for these security issues.
Priya: So what this means practically is that we can't just focus on finding the initial bug; we have to look at how it moves through the software supply chain.
Nadia: Exactly. The paper shows that systemic issues, like projects not prioritizing updates for old vulnerabilities, are what allow these high-risk flaws to spread so widely.
Elias: It’s a clear signal that a holistic approach to vulnerability management is necessary because treating each project in isolation just doesn't work anymore.
Priya: I agree, and I think the focus on AI generated code in their future work is really important because that’s where the next wave of these propagation problems will come from.
Nadia: It points toward a future where we need to be even more proactive in vetting everything we bring into our development pipeline.
Elias: We’ll keep an eye on those proposed solutions, like the better detection tools and automated patching systems they suggested for managing these risks effectively.
More episodes
- 2608.27496-ROPE: Routed Origin Policy Enforcement against Indirect Prompt Injection
- Daily Summary for 2026-11-19
- 2607.07085-Is Randomness Necessary for Adaptive Data Analysis?
- The day in conversation for 2026-11-19
- Daily Summary for 2026-11-19
- 2609.10601-Threshold Choice, Not Sample Size, Bounds Trustless Verification of Nondeterministic Compound AI Workflows
- 2610.38786-Adversarial Process Disturbances at a Deployable Alarm Budget: Detector Evaluation on a Simulator and a Real Plant
- 2511.08660-Binary and Multiclass Cyberattack Classification on GeNIS Dataset
- 2604.27302-Static Attribution of Android Residential Proxy Malware Using Graph Kernels
- Daily Summary for 2026-11-18