Source to Sink Data Flow Analysis

This direction is split into other directions: data flow tracking. Its last version stays readable and citable here.

Version 1 of 1152 papers175 conceptsfrozen 2026-10-04

At its core, most software vulnerabilities are not caused by a single line of broken code, but by a dangerous journey. A vulnerability exists when untrusted data from an external source—like a user's text input, a URL parameter, or a sensor reading—travels through a program's logic and reaches a sensitive sink—such as a database query, a system command, or a network transmission.

Source-to-sink data flow analysis is the systematic process of mapping these journeys. By treating data as a physical object that can be "tainted" or "labeled," researchers can determine if a program's security boundaries are truly airtight or if they contain hidden paths that an attacker could exploit.

The Taint Metaphor

The most intuitive way to understand this research is through "taint analysis." As Wenbing Zhao and Zhi-ming DING describe in their review of web attacks, the system marks untrusted input as "tainted." As this data moves through variables and functions, the taint spreads. If this tainted data ever touches a sensitive sink without being "cleaned" (sanitized), the system flags a vulnerability.

This approach is powerful because it ignores the vast majority of "safe" code. As Cheng Zhou and Yong Li argue, by tracing data flows exclusively from external input points, analyzers can ignore security weaknesses in code paths that an attacker simply cannot reach, drastically reducing the "noise" of false positives.

Static vs. Dynamic Perspectives

Researchers generally approach this mapping in two ways:

  1. Static Analysis: Tools like IccTA, developed by Steven Arzt and Eric Bodden, examine the application's "blueprint" (source code or bytecode) without running it. This allows them to find every possible path data could take. To handle the complexity of modern apps, these tools often "stitch" together disconnected components to track how data flows across different parts of a system.
  2. Dynamic Analysis: Tools like TaintDroid, discussed by Muhammad Haris Mughees and Pan Hui, watch the data move in real-time. This provides high precision because it sees exactly what happens during execution, though it can only find vulnerabilities on the specific paths the software happens to take while being monitored.

Reversing the Search: Sink-Driven Analysis

While many tools start at the source and look forward, a more efficient strategy is often to start at the sink and look backward. Daoyuan Wu and Xiapu Luo pioneered this "sink-driven" approach with ECVDetector.

Instead of tracking every piece of user input, the tool identifies dangerous APIs (sinks) first. It then performs a backward dataflow analysis to see if any external entry point can reach and control that specific sink. This is like starting at a high-value target (a bank vault) and looking for any unlocked doors that lead to it, rather than starting at every door in the city and seeing where they lead.

Bridging Isolated Boundaries

Modern software is rarely a single, monolithic block of code. It is a web of interacting binaries, third-party libraries, and inter-process communications.

  • Inter-Component Communication (ICC): In Android, data often leaks when it moves between different app components. Alexandre Bartel and his team showed that by maintaining the "context" of an object as it moves across these boundaries, analyzers can distinguish between legitimate communication and actual leaks.
  • Multi-Binary Interactions: In IoT devices, a vulnerability might start in a web interface binary and end in a hardware control binary. Nilo Redini and Aravind Machiry developed Karonte to propagate taint labels across these process boundaries, uncovering bugs that span multiple independent programs.

Beyond Traditional Software

The source-to-sink paradigm has proven remarkably adaptable to new domains:

  • Smart Contracts: Wuqi Zhang and Yepang Liu use dynamic taint analysis to track how an attacker's transaction can influence critical financial sinks, such as token transfers, to detect front-running attacks.
  • AI and Data Science: Even in machine learning, where models are often treated as "black boxes," researchers like Jian Zhao use taint analysis to identify malicious code hidden within pre-trained models that exfiltrates credentials to external network sinks.
  • Hardware Security: At the assembly level, Jakub Breier uses data flow graphs to see how physical faults injected into a processor's registers propagate through a cipher's logic to leak cryptographic keys.

By focusing on the movement of information rather than just the structure of code, source-to-sink analysis provides a universal language for understanding how systems fail and how they can be defended.

Papers in this version

Showing 60 of 152 papers.

History & citationVersion 1 · 2026-10-04

Split into other directions · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_source_to_sink_data_flow_analysis_68fc8b55,
  title = {Source to Sink Data Flow Analysis},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/source-to-sink-data-flow-analysis/rdr_68fc8b55cf6d478ea23627abee084979},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-20},
}

This exact version (version 1, frozen text):

@misc{lacuna_source_to_sink_data_flow_analysis_68fc8b55_v1,
  title = {Source to Sink Data Flow Analysis},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/source-to-sink-data-flow-analysis/rdr_68fc8b55cf6d478ea23627abee084979/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-20},
}