02:00 - 02:30

• Data-Delineation in Software Binaries and its Application to Buffer-Overrun Discovery

  Detecting memory-safety violations in binaries is complicated by the lack of knowledge of the intended data layout, i.e., The locations and sizes of objects. We present lightweight, static, heuristic analyses for recovering the intended layout of data in a stripped binary. Comparison against DWARF debugging information shows high precision and recall rates for inferring source-level object boundaries. On a collection of benchmarks, our analysis eliminates a third to a half of incorrect object boundaries identified by an IDA Pro-inspired heuristic, while retaining nearly all valid object boundaries. In addition to measuring their accuracy directly, we evaluate the effect of using the recovered data for improving the precision of static buffer-overrun detection in the defect-detection tool CodeSonar/x86. We demonstrate that Code Sonar's false-positive rate drops by about 80% across our internal evaluation suite for the tool, while our approximation of Code Sonar's recall only degrades about 25%.

   

  Preprint available:

Denis Gopan; Evan Driscoll; Ducson Nguyen; Dimitri Naydich; Alexey Loginov; David Melski

GrammaTech Inc., USA

02:30 - 03:00

• Measuring Software Redundancy

  Redundancy is the presence of different elements with the same functionality. In software, redundancy is useful (and used) in many ways, for example for fault tolerance and reliability engineering, and in self-adaptive and self-checking programs. However, despite the many uses, we still do not know how to measure software redundancy to support a proper and effective design. If, for instance, the goal is to improve reliability, one might want to measure the redundancy of a solution to then estimate the reliability gained with that solution. Or one might compare alternative solutions to choose the one that expresses more redundancy and therefore, presumably, more reliability. We first formalize a notion of redundancy whereby two code fragments are considered redundant when they achieve the same functionality with different executions. On the basis of this abstract and general notion, we then develop a concrete method to obtain a meaningful quantitative measure of software redundancy. The results we obtain are very positive: we show, through an extensive experimental analysis, that it is possible to distinguish code that is only minimally different, from truly redundant code, and that it is even possible to distinguish low-level code redundancy from high-level algorithmic redundancy. We also show that the measurement is significant and useful for the designer, as it can help predict the effectiveness of techniques that exploit redundancy.

   

  Preprint available:

Antonio Carzaniga; Andrea Mattavelli; Mauro Pezzè

University of Lugano, Switzerland

03:00 - 03:30

• Gray Computing: An Analysis of Computing with Background JavaScript Tasks

  Websites routinely distribute small amounts of work to visitors' browsers in order to validate forms, render animations, and perform other computations. This paper examines the feasibility, cost effectiveness, and approaches for increasing the workloads offloaded to web visitors' browsers in order to turn them into a large-scale distributed data processing engine, which we term gray computing. Past research has looked primarily at either non-browser based volunteer computing or browser-based volunteer computing where the visitors keep their browsers open to a single web page for a long period of time. This paper provides a deep analysis of the architectural, cost effectiveness, user experience, performance, security, and other issues of gray computing distributed data processing engines with high heterogeneity, non-uniform page view times, and high computing pool volatility.

   

  Preprint available:

Yao Pan; Jules White; Yu Sun; Jeff Gray

Vanderbilt University, USA; University of Alabama, USA