9 research outputs found
Symbolic Quantitative Information Flow
acmid: 2382791 issue_date: November 2012 keywords: algorithms, security, verification numpages: 5acmid: 2382791 issue_date: November 2012 keywords: algorithms, security, verification numpages: 5acmid: 2382791 issue_date: November 2012 keywords: algorithms, security, verification numpages: 5acmid: 2382791 issue_date: November 2012 keywords: algorithms, security, verification numpages: 5acmid: 2382791 issue_date: November 2012 keywords: algorithms, security, verification numpages:
Self-composition by Symbolic Execution
This work is licensed under a CC-BY Creative Commons Attribution 3.0 Unported license (http://creativecommons.org/licenses/by/3.0/)urn: urn:nbn:de:0030-drops-42770urn: urn:nbn:de:0030-drops-42770Self-composition is a logical formulation of non-interference, a high-level security property that guarantees the absence of illicit information leakages through executing programs. In order to capture program executions, self-composition has been expressed in Hoare or modal logic, and has been proved (or refuted) by using theorem provers. These approaches require considerable user interaction, and verification expertise. This paper presents an automated technique to prove self-composition. We reformulate the idea of self-composition into comparing pairs of symbolic paths of the same program; the symbolic paths are given by Symbolic Execution. The result of our analysis is a logical formula expressing self-composition in first-order theories, which can be solved by off-the-shelf Satisfiability Modulo Theories solver
Bit-Vector Model Counting using Statistical Estimation
Approximate model counting for bit-vector SMT formulas (generalizing \#SAT)
has many applications such as probabilistic inference and quantitative
information-flow security, but it is computationally difficult. Adding random
parity constraints (XOR streamlining) and then checking satisfiability is an
effective approximation technique, but it requires a prior hypothesis about the
model count to produce useful results. We propose an approach inspired by
statistical estimation to continually refine a probabilistic estimate of the
model count for a formula, so that each XOR-streamlined query yields as much
information as possible. We implement this approach, with an approximate
probability model, as a wrapper around an off-the-shelf SMT solver or SAT
solver. Experimental results show that the implementation is faster than the
most similar previous approaches which used simpler refinement strategies. The
technique also lets us model count formulas over floating-point constraints,
which we demonstrate with an application to a vulnerability in differential
privacy mechanisms
Hyperfuzzing: black-box security hypertesting with a grey-box fuzzer
Information leakage is a class of error that can lead to severe consequences.
However unlike other errors, it is rarely explicitly considered during the
software testing process. LeakFuzzer advances the state of the art by using a
noninterference security property together with a security flow policy as an
oracle. As the tool extends the state of the art fuzzer, AFL++, LeakFuzzer
inherits the advantages of AFL++ such as scalability, automated input
generation, high coverage and low developer intervention.
The tool can detect the same set of errors that a normal fuzzer can detect,
with the addition of being able to detect violations of secure information flow
policies.
We evaluated LeakFuzzer on a diverse set of 10 C and C++ benchmarks
containing known information leaks, ranging in size from just 80 to over 900k
lines of code. Seven of these are taken from real-world CVEs including
Heartbleed and a recent error in PostgreSQL. Given 20 24-hour runs, LeakFuzzer
can find 100% of the leaks in the SUTs whereas existing techniques using such
as the CBMC model checker and AFL++ augmented with different sanitizers can
only find 40% at best.Comment: 11 pages, 4 figure
Model Counting Modulo Theories
PhD finalThis thesis is concerned with the quantitative assessment of security in software.
More specifically, it tackles the problem of efficient computation of channel capacity,
the maximum amount of confidential information leaked by software, measured in
Shannon entropy or RÂČnyi's min-entropy.
Most approaches to computing channel capacity are either efficient and return only
(possibly very loose) upper bounds, or alternatively are inefficient but precise; few
target realistic programs. In this thesis, we present a novel approach to the problem
by reducing it to a model counting problem on first-order logic, which we name Model
Counting Modulo Theories or #SMT for brevity.
For quantitative security, our contribution is twofold. First, on the theoretical side we
establish the connections between measuring confidentiality leaks and fundamental
verification algorithms like Symbolic Execution, SMT solvers and DPLL. Second,
exploiting these connections, we develop novel #SMT-based techniques to compute
channel capacity, which achieve both accuracy and efficiency. These techniques are
scalable to real-world programs, and illustrative case studies include C programs from
Linux kernel, a Java program from a European project and anonymity protocols.
For formal verification, our contribution is also twofold. First, we introduce and
study a new research problem, namely #SMT, which has other potential applications
beyond computing channel capacity, such as returning multiple-counterexamples for
Bounded Model Checking or automated test generation. Second, we propose an
alternative approach for Bounded Model Checking using classical Symbolic Execution,
which can be parallelised to leverage modern multi-core and distributed architecture.
For software engineering, our first contribution is to demonstrate the correspondence
between the algorithm of Symbolic Execution and the DPLL(T ) algorithm used in
state-of-the-art SMT solvers. This correspondence could be leveraged to improve
Symbolic Execution for automated test generation. Finally, we show the relation
between computing channel capacity and reliability analysis in software.School of Electronic Engineering and Computer Science scholarshi
Comparative Analysis of Leakage Tools on Scalable Case Studies
International audienceQuantitative security techniques have been proven effective to measure the security of systems against various types of attackers. However, such techniques are often tested against small-scale academic examples. In this paper we use analyze two scalable, real life privacy case studies: the privacy of the energy consumption data of the users of a smart grid network and the secrecy of the voters' voting preferences with different types of voting protocols. We analyze both case studies with three state-of-the-art information leakage computation tools: LeakWatch, Moped-QLeak, and our tool QUAIL equipped with a new trace analysis algorithm. We highlight the relative advantages and drawbacks of the tools and compare their usability and effectiveness in analyzing the case studies
Recommended from our members
Software Side-Channel Analysis
Software side-channel attacks are able to recover confidential information by observing non-functional computation characteristics of program execution such as elapsed time, amount of allocated memory, or network packet size. The ability to automatically determine the amount of information that a malicious user can gain through side-channel observations allows one to quantitatively assess the security of an application. Since most software that accesses confidential information leaks some amount of information through side channels, it is important to quantify the amount of leakage in order to detect vulnerabilities. In addition, one can prove that a program is vulnerable to side-channel attacks by synthesizing attacks that recover confidential information. In this dissertation, I provide methods for (1) quantifying side-channel vulnerabilities and (2) synthesizing adaptive side-channel attack steps. My approaches advance the state-of-the-art in automatic software side-channel analysis which I summarize as follows. I make use of symbolic execution to extract program constraints that characterize the relationship between secret information, the inputs of a malicious user, and observable program behaviors. By applying model counting constraint solving to these constraints, I compute probabilistic relationships among secrets, attacker inputs, and attacker side-channel observations. These probabilities are used to quantify information leakage for a program by applying methods from the field of quantitative information flow. Moreover, by automatically generating a symbolic expression that quantifies information leakage, I am able to perform numeric maximization over attacker inputs to synthesize optimal attack steps. The sequence of attack steps serves as a proof of exploitability. I give two different automatic attack synthesis techniques: a fully static approach and an online dynamic approach that constructs an attack that takes into account system noise and is able to execute the attack through the network. I demonstrate the effectiveness of my approaches on a set of experimental benchmarks
Automata-based Model Counting String Constraint Solver for Vulnerability Analysis
Most common vulnerabilities in modern software applications are due to errors in string manipulation code. String constraint solvers are essential components of program analysis techniques for detecting and repairing vulnerabilities that are due to string manipulation errors. In this dissertation, we present an automata-based string constraint solver for vulnerability analysis of string manipulating programs.Given a string constraint, we generate an automaton that accepts all solutions that satisfy the constraint. Our string constraint solver can also map linear arithmetic constraints to automata in order to handle constraints on string lengths. By integrating our string constraint solver to a symbolic execution tool, we can check for string manipulation errors in programs. Recently, quantitative and probabilistic program analyses techniques have been proposed which require counting the number of solutions to string constraints. We extend our string constraint solver with model counting capability based on the observation that, using an automata-based constraint representation, model counting reduces to path counting, which can be solved precisely. Our approach is parameterized in the sense that, we do notassume a finite domain size during automata construction, resulting in a potentially infinite set of solutions, and our model counting approach works for arbitrarily large bounds.We have implemented our approach in a tool called ABC (Automata-Based model Counter) using a constraint language that is compatible with the SMTLIB language specification used by satifiabilty-modula-theories solvers. This SMTLIB interface facilitates integration of our constraint solver with existing symbolic execution tools. We demonstrate the effectiveness of ABC on a large set of string constraints extracted from real-world web applications.We also present automata-based testing techniques for string manipulating programs. A vulnerability signature is a characterization of all user inputs that can be used to exploit a vulnerability. Automata-based static string analysis techniques allow automated computation of vulnerability signatures represented as automata. Given a vulnerability signature represented as an automaton, we present algorithms for test case generation based on state, transition, and path coverage. These automaticallygenerated test cases can be used to test applications that are not analyzable statically, and to discover attack strings that demonstrate how the vulnerabilities can be exploited. We experimentally comparedifferent coverage criteria and demonstrate the effectiveness of our test generation approach