Towards LLM-Enhanced Android Taint Analysis
This paper demonstrates that an agentic Large Language Model (LLM) approach significantly outperforms the traditional static analyzer FlowDroid in detecting Android data leaks, particularly in complex scenarios like inter-component communication, implicit flows, and reflection, suggesting that LLM reasoning can effectively complement existing taint analysis techniques.
Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer
In the digital world of mobile applications, a constant, silent battle takes place against the theft of private information. Every time a smartphone app accesses a user's location, contacts, or unique device ID, it touches a sensitive piece of data. The danger arises when that data travels from its source to an unsafe destination, such as a network server or a public log, where it can be intercepted by malicious actors. To stop this, security experts use a technique called taint analysis. Imagine this process as a digital tracking system that marks sensitive data with a virtual stain and follows it through the complex code of an application to see if it ever reaches a dangerous exit. For years, the most reliable way to do this has been through static analysis tools, which are like highly specialized maps that experts have painstakingly drawn to understand how the Android operating system works. These maps allow the tools to predict how data moves, but they are fragile; if the app uses a trick the map doesn't know about, the tracker loses the signal.
Recently, a new kind of intelligence has emerged in the field of software: large language models. These are powerful computer systems trained on vast amounts of text and code, capable of understanding context and reasoning through problems much like a human reader would. A team of researchers from the University of Padova and the University of Luxembourg asked a bold question: could these intelligent systems, without any special training or pre-drawn maps of the Android world, figure out how sensitive data moves through an app on their own? They wanted to see if a machine that understands language could simply read the code, follow the clues, and spot the leaks that traditional tools miss. Their investigation suggests that the answer is yes, and that these new systems might not replace the old tools, but rather work alongside them to catch the most elusive threats.
The researchers set out to test this idea by pitting a standard, well-known security tool against a modern large language model. They used a benchmark called DroidBench, which is a collection of 190 test cases designed specifically to challenge security software with tricky scenarios like hidden code, dynamic loading, and complex communication between different parts of an app. The standard tool, known as FlowDroid, relies on the carefully engineered maps mentioned earlier. When the researchers ran the test, the traditional tool managed to find only about half of the known data leaks, achieving a score that reflected its struggle with the more difficult cases. In contrast, the large language model, specifically a version called Gemini-3 Flash, acted as an autonomous agent. Instead of following a rigid set of rules, it was given the ability to explore the app's code step-by-step, asking questions and tracing paths just as a human analyst would. This approach allowed it to find nearly every single leak in the test set, achieving a success rate that was nearly double that of the traditional tool.
The most striking results appeared in the categories where the traditional tool usually fails. When the data moved through complex internal communications, or when the app used reflection—a technique where code can examine and modify itself at runtime—the traditional tool often saw nothing at all. The large language model, however, successfully navigated these obstacles, identifying the flows with high accuracy. It also performed exceptionally well with implicit flows, where data leaks through subtle side effects rather than direct transfers, and with native code, which is written in a different language and often hidden from standard analysis. The researchers found that while the traditional tool was very careful and rarely made false accusations, it missed too many real problems. The large language model, conversely, was much better at finding the hidden leaks, though it occasionally made mistakes by seeing patterns that weren't there.
To see if this held up in the real world, the team applied the same method to a small selection of actual Android applications downloaded from the Google Play store. Since there is no perfect list of leaks for real apps to compare against, the researchers manually inspected the findings. They discovered that the large language model found 17 potential leaks that the traditional tool had completely missed. Upon close human inspection, 16 of these turned out to be genuine data leaks, proving that the model could uncover risks in live software that had gone undetected. One specific example involved an app where the very method that started the data leak was hidden behind a reflective call, a trick that stopped the traditional tool from even beginning its search. The large language model, however, was able to reason through the confusion and trace the path of the data. This suggests that the new approach is not just a theoretical exercise but a practical tool capable of finding real vulnerabilities.
The study does not claim that large language models are a perfect replacement for existing security tools. The researchers noted that the new approach is not always necessary for simple cases and can be computationally expensive. Furthermore, the models can be inconsistent, sometimes producing different results on the same code, and they can occasionally hallucinate, inventing leaks that do not exist. To handle this, the team ran the analysis multiple times and only accepted findings that appeared consistently across the runs. The ultimate conclusion is that the future of app security likely lies in a hybrid approach. Traditional tools, which are fast and reliable for common problems, could handle the bulk of the work, while large language models could be deployed selectively to tackle the most complex and confusing scenarios where standard maps fail. This combination would leverage the speed of established methods and the reasoning power of artificial intelligence to create a more robust defense against data theft.
Drowning in papers in your field?
Get daily digests of the most novel papers matching your research keywords — with technical summaries, in your language.