Semi-sparse flow-sensitive pointer analysis

Information flow control (IFC) checks whether a program can leak secret data to public ports, or whether critical computations can be influenced from outside. But many IFC analyses are imprecise, as they are flow-insensitive, context-insensitive, or object-insensitive; resulting in false alarms. We argue that IFC must better exploit modern program analysis technology, and present an approach based on program dependence graphs (PDG). PDGs have been developed over the last 20 years as a standard device to represent information flow in a program, and today can handle realistic programs. In particular, our dependence graph generator for full Java bytecode is used as the basis for an IFC implementation which is more precise and needs less annotations than traditional approaches. We explain PDGs for sequential and multi-threaded programs, and explain precision gains due to flow-, context-, and object-sensitivity. We then augment PDGs with a lattice of security levels and introduce the flow equations for IFC. We describe algorithms for flow computation in detail and prove their correctness. We then extend flow equations to handle declassification, and prove that our algorithm respects monotonicity of release. Finally, examples demonstrate that our implementation can check realistic sequential programs in full Java bytecode.

show abstract

“…On the contrary, empirical studies have validated that flow-sensitivity in program analysis strongly improves precision (see, e.g. [24]). …”

Section: Security Type Systemsmentioning

confidence: 99%

Flow-sensitive, context-sensitive, and object-sensitive information flow control based on program dependence graphs

Hammer

Snelting

2009

Int. J. Inf. Secur.

172

141

View full text Add to dashboard Cite

show abstract

“…(It does not, however, model languages such as C or C++ that can create pointers through an address-of operator. The techniques used in that space are fairly different-e.g., [8,9]although our main hybrid approach is likely to be applicable. Also, even though we model regular object fields and static methods, we omit static fields.…”

Section: Background: Parameterizable Modelmentioning

confidence: 99%

Hybrid context-sensitivity for points-to analysis

KastrinisGeorge¹,

SmaragdakisYannis²

2013

SIGPLAN Not.

View full text Add to dashboard Cite

Context-sensitive points-to analysis is valuable for achieving high precision with good performance. The standard flavors of contextsensitivity are call-site-sensitivity (kCFA) and object-sensitivity. Combining both flavors of context-sensitivity increases precision but at an infeasibly high cost. We show that a selective combination of call-site-and object-sensitivity for Java points-to analysis is highly profitable. Namely, by keeping a combined context only when analyzing selected language features, we can closely approximate the precision of an analysis that keeps both contexts at all times. In terms of speed, the selective combination of both kinds of context not only vastly outperforms non-selective combinations but is also faster than a mere object-sensitive analysis. This result holds for a large array of analyses (e.g., 1-object-sensitive, 2-object-sensitive with a context-sensitive heap, type-sensitive) establishing a new set of performance/precision sweet spots.

show abstract

“…Despite the pessimism, it is shown that a precise pointer analysis helps several clients, such as typestate verification [Fink et al 2008], security analysis [Chang et al 2008], bug detection [Guyer and Lin 2005], and the analysis of multithreaded programs [Salcianu and Rinard 2001]. As a result, there has been renewed interest in the area of flow-sensitive pointer analysis, and the scalability of such analyses, particularly for C programs, has been greatly improved [Hardekopf and Lin 2011;Li et al 2011;Lhoták and Chung 2011;Hardekopf and Lin 2009;Kahlon 2008]. Our bit of contribution here is to improve it further with parallelization and controlled approximation.…”

Section: Related Workmentioning

confidence: 99%

Time- and space-efficient flow-sensitive points-to analysis

Nasre

2013

ACM Trans. Archit. Code Optim.

View full text Add to dashboard Cite

Compilation of real-world programs often requires hours. The term nightly build known to industrial researchers is an artifact of long compilation times. Our goal is to reduce the absolute analysis times for large C codes (of the order of millions of lines). Pointer analysis is one of the key analyses performed during compilation. Its scalability is paramount to achieve the efficiency of the overall compilation process and its precision directly affects that of the client analyses. In this work, we design a time-and space-efficient flow-sensitive pointer analysis and parallelize it on graphics processing units. Our analysis proposes to use an extended bloom filter, called multibloom, to store points-to information in an approximate manner and develops an analysis in terms of the operations over the multibloom. Since bloom filter is a probabilistic data structure, we develop ways to gain back the analysis precision. We achieve effective parallelization by achieving memory coalescing, reducing thread divergence, and improving load balance across GPU warps. Compared to a state-of-the-art sequential solution, our parallel version achieves a 7.8× speedup with less than 5% precision loss on a suite of six large programs. Using two client transformations, we show that this loss in precision only minimally affects a client's precision. ACM Reference Format:Nasre, R. 2013. Time-and space-efficient flow-sensitive points-to analysis. ACM Trans. analysis directly affects the client analyses and transformations [Hind and Pioli 2000].However, industry-strength compilers need to use flow-insensitive pointer analysis because of the high analysis time and memory cost of a flow-sensitive analysis.The benefit of a flow-sensitive pointer analysis over that of a flow-insensitive analysis has not been clear [Hind and Pioli 1998]. However, it has been shown that a precise pointer analysis is helpful to several clients, such as typestate verification [Fink et al. 2008], security analysis [Chang et al. 2008], bug detection [Guyer and Lin 2005], and the analysis of multithreaded programs [Salcianu and Rinard 2001]. As a result, there is a renewed interest in the area of flow-sensitive pointer analysis, and the scalability of such analyses has been greatly improved [Hardekopf and Lin 2011; Li et al. 2011; Yu et al. 2010; Lhoták and Chung 2011; Hardekopf and Lin 2009; Kahlon 2008]. However, despite these efforts, industrial response to the adoption of these analyses has been lukewarm. For instance, widely used compilers like GCC [GCC 2013] and LLVM [Lattner and Adve 2004] rely on flow-insensitive pointer analysis, despite the known advantages of a flow-sensitive analysis. One of the main reasons behind this pessimistic reaction is high absolute running times of several analyses over large-sized codes. As an example, a state-of-the-art flow-sensitive pointer analysis [Hardekopf and Lin 2011] over gs, an open-source postscript viewer, totaling 0.4 million lines of C code, requires more than half an hour to complete! Considering that pointer a...

show abstract

Semi-sparse flow-sensitive pointer analysis

Cited by 82 publications

References 55 publications

Flow-sensitive, context-sensitive, and object-sensitive information flow control based on program dependence graphs

Flow-sensitive, context-sensitive, and object-sensitive information flow control based on program dependence graphs

Hybrid context-sensitivity for points-to analysis

Time- and space-efficient flow-sensitive points-to analysis

Contact Info

Product

Resources

About