DITING: A Static Analyzer for Identifying Bad Partitioning Issues in TEE Applications
summary
The gist
Trusted Execution Environment (TEE) applications still face vulnerabilities stemming from bad partitioning…
In short
DITING is a static analysis tool designed to find security flaws in Trusted Execution Environment (TEE) applications caused by bad partitioning. It analyzes how data flows between the normal world and TEE using input/output and shared memory parameters. The tool uses three specific rules to detect issues like unencrypted data output, weak input validation, and direct shared memory usage.
Key concepts
- Bad Partitioning Issues
- These are security vulnerabilities in TEE apps arising from improper separation between the normal world and the TEE. They occur when parameters passed between these two environments are used insecurely, leading to potential data leaks or malicious manipulation.
- Data Flow Analysis
- This is the core technique DITING uses to trace every path a piece of data takes through a program. It maps how input/output and shared memory parameters move from their source (like user input) to where they are used in the TEE code, helping pinpoint potential security errors.
- Rule-Based Detection Logic
- DITING defines specific rules to check for known bad practices. For example, one rule checks if sensitive output data is sent without encryption, another checks if input parameters are used in memory operations without proper bounds checking. This systematic rule application identifies violations.
- PartitioningE-Bench
- This is the benchmark dataset used to test DITING's effectiveness. It contains 110 test cases covering various types of bad partitioning vulnerabilities, such as unencrypted output, input validation weaknesses, and shared memory misuse. It helps measure how well DITING performs in finding these specific flaws.
Terminology used across episodes
This episode discusses
The paper
DITING: A Static Analyzer for Identifying Bad Partitioning Issues in TEE Applications · Read on arXiv
Singapore Management University
Trusted Execution Environment (TEE) enhances the security of mobile applications and cloud services by isolating sensitive code in the secure world from the non-secure normal world. However, TEE applications are still confronted with vulnerabilities stemming from bad partitioning. Bad partitioning can lead to critical security problems of TEE, such as leaking sensitive data to the normal world or being adversely affected by malicious inputs from the normal world. To address this, we propose an approach to detect partitioning issues in TEE applications. First, we conducted a survey of TEE vulnerabilities caused by bad partitioning and found that the parameters exchanged between the secure and normal worlds often contain insecure usage with bad partitioning implementation. Second, we developed a tool named DITING that can analyze data-flows of these parameters and identify their violations of security rules we defined to find bad partitioning issues. Different from existing research that only focuses on malicious input to TEE, we assess the partitioning issues more comprehensively through input/output and shared memory. Finally, we created the first benchmark targeting bad partitioning, consisting of 110 test cases. Experiments demonstrate that DITING achieves an F1 score of 0.90 in identifying bad partitioning issues.
Transcript
Introduction to the show: ident: Security Radio. Generated commentary on the latest security and cryptography papers.
Nadia: We're looking at the paper: "DITING: A Static Analyzer for Identifying Bad Partitioning Issues in TEE Applications".
Title and authors: Nadia: So this DITING tool, it analyzes the data flows of parameters passed between the normal world and TEE to check them against rules for input/output and shared memory interactions. It’s trying to catch those bad partitioning issues at the source.
Elias: The authors found that bad partitioning often comes down to two main things: first, there's a lack of secure interface components between the normal world and the TEE, like not encrypting output data or not checking bounds on input data. Second is when there are insecure mechanisms inside the TEE code itself.
Priya: So what does this analysis actually look like in practice? Is it just checking if a parameter goes where it's supposed to go, or is it deeper than that?
Nadia: It’s deeper because they constructed data flows using CodeQL to trace every path of input/output and shared memory parameters. They do a preparation step first where they define rules based on sensitive functions and data.
Elias: That preparation step is key, because it lets them set up specific rules for what operations are allowed on that sensitive stuff before they start tracing the actual data paths through the code.
The paper's summary: Nadia: So what’s the core idea of DITING in simple terms? They want to identify where parameters get mishandled when moving between the secure TEE and the untrusted normal world.
Elias: Essentially, they build a system that traces how data flows through input/output and shared memory parameters to see if those flows violate specific security rules they set up. It’s about checking whether these parameters pass through functions or interact with data related to those initial rules.
Priya: When you look at the actual findings, what are the main types of issues DITING is designed to catch? Is it just one kind of vulnerability?
Nadia: They focused on three main threat vectors emerging from bad partitioning practices. First, sensitive data leakage if something sensitive like cryptographic keys or passwords is output to the normal world without encryption. Second, input validation weaknesses where input parameters are used in array accesses or memory copies without checking their boundaries. And third, direct usage of shared memory which lets both partitions access the same physical memory region through shallow copies.
Elias: So they are targeting these specific scenarios: unencrypted data output, lack of bounds checking on inputs, and insecure reliance on shared memory sharing mechanisms. It maps out exactly where the partitioning breaks down based on these three vectors.
The paper's improvements: Nadia: They outlined three specific rules they formulated to detect these issues. Rule one targets unencrypted data output, looking for a sink of an output parameter that doesn't have a source passing through an encryption API.
Elias: That rule is designed to catch when sensitive statements or parameter usage lack the necessary security components for output parameters. It flags situations where sensitive data leaves the TEE without being encrypted.
Priya: And what about input validation? How does Rule two specifically address the risk of buffer overflows?
Nadia: Rule two addresses input validation weaknesses by flagging when input parameters are used in array accesses or memory copies without any preceding conditional checks. They make an exception if the TEE explicitly allocates memory whose size matches the input buffer.
Elias: That rule is looking for sinks that don't come from a source that has gone through a check, which directly relates to potential buffer overflows because it prevents using untrusted input as an index or causing a memory copy to exceed boundaries.
Nadia: Rule three focuses on shared memory integrity by capturing scenarios where shallow copying allows both partitions to access the same physical memory region. They detect this by identifying the presence of insecure components when direct use of shared memory or its shallow copies occurs.
Conclusion: Elias: So to wrap up, DITING’s effectiveness was tested using the PartitioningE-Bench benchmark, which has one hundred ten test cases covering three types of bad partitioning vulnerabilities. They got an F1 score of zero point nine zero in identifying these issues overall.
Nadia: And they showed high precision and recall for detecting unencrypted data output, getting a high F1 score of zero point nine six specifically for that rule violation type. But they also noted some trade-offs in the shared memory detection, achieving a recall above ninety five percent but with lower precision below eighty five percent.
Priya: So what does this mean for us who are trying to trust these TEE applications? It shows that while we can find issues, the detection isn't perfect across all types of bad partitioning.
Elias: The authors acknowledge that most tools need successful compilation and expert customization, and they suggest future work should focus on incorporating semantic context from the code to reduce false positives in their rules.
Nadia: They also mentioned that porting entire programs into TEE significantly increases the Trusted Computing Base, which is a big design consideration for anyone building these systems.
Priya: It’s clear they can find a lot of issues, but the next step must be to fix them automatically and make sure those rules are robust enough for real-world complexity.
Elias: So that’s the rundown on DITING: A Static Analyzer for Identifying Bad Partitioning Issues in TEE Applications. We’ll keep an eye on how they move from detection to fixing these kinds of partitioning errors.
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