Mobile phones have developed into complex platforms with large numbers of installed applications and a wide range of sensitive data. Application security policies limit the permissions of each installed application. As applications may interact, restricting single applications may create a false sense of security for end users, while data may still leave the mobile phone through other applications. Instead, the information flow needs to be policed for the composite system of applications in a transparent manner. In this paper, we propose to employ static analysis, based on the software architecture and focused on data-flow analysis, to detect information flows between components. Specifically, we aim to reveal transitivity-of-trust problems in multi-component mobile platforms. We demonstrate the feasibility of our approach with two Android applications.
In another approach, type-based security combines annotations with dependence graph-based information flow control @cite_20 . Hammer's proposed analysis uses the Java bytecode and a succinct security policy specification that is inserted as annotations in code comments. Although both approaches aim to detect information flow violations of Java-based applications, they differ in the analysis techniques they use. We employ an analysis approach using the RFG to restrict the search space and thereafter carrying out a more focused analysis at the detail level. Hammer uses the complete dependence graph to directly conduct the information flow analysis. In addition, Hammer's method requires code annotations for the security labeling, similar to JFlow. This way, this approach can only be applied by the developer, but neither by the Android Market owner nor the end user.
@cite_20
13082435
Information flow control systems provide the guarantees that are required in today's security-relevant systems. While the literature has produced a wealth of techniques to ensure a given security policy, there is only a small number of implementations, and even these are mostly restricted to theoretical languages or a subset of an existing language. Previously, we presented the theoretical foundations and algorithms for dependence-graph-based information flow control (IFC). As a complement, this paper presents the implementation and evaluation of our new approach, the first implementation of a dependence-graph based analysis that accepts full Java bytecode. It shows that the security policy can be annotated in a succinct manner; and the evaluation shows that the increased runtime of our analysis—a result of being flow-, context-, and object-sensitive—is mitigated by better analysis results and elevated practicability. Finally, we show that the scalability of our analysis is not limited by the sheer size of either the security lattice or the dependence graph that represents the program.