Concolic testing (aportmanteau ofconcrete andsymbolic, also known asdynamic symbolic execution) is a hybridsoftware verification technique that performssymbolic execution, a classical technique that treats program variables as symbolic variables, along aconcrete execution (testing on particular inputs) path. Symbolic execution is used in conjunction with anautomated theorem prover or constraint solver based onconstraint logic programming to generate new concrete inputs (test cases) with the aim of maximizingcode coverage. Its main focus is finding bugs in real-world software, rather than demonstrating program correctness.

A description and discussion of the concept was introduced in "DART: Directed Automated Random Testing" by Patrice Godefroid, Nils Klarlund, and Koushik Sen.^[1] The paper "CUTE: A concolic unit testing engine for C",^[2] by Koushik Sen, Darko Marinov, andGul Agha, further extended the idea to data structures, and first coined the termconcolic testing. Another tool, called EGT (renamed to EXE and later improved and renamed to KLEE), based on similar ideas was independently developed by Cristian Cadar andDawson Engler in 2005, and published in 2005 and 2006.^[3] PathCrawler^[4][5] first proposed to perform symbolic execution along a concrete execution path, but unlike concolic testing PathCrawler does not simplify complex symbolic constraints using concrete values. These tools (DART and CUTE, EXE) applied concolic testing to unit testing ofC programs and concolic testing was originally conceived as awhite box improvement upon establishedrandom testing methodologies. The technique was later generalized to testing multithreadedJava programs with jCUTE,^[6] and unit testing programs from their executable codes (tool OSMOSE).^[7] It was also combined withfuzz testing and extended to detect exploitable security issues in large-scalex86 binaries byMicrosoft Research's SAGE.^[8][9]

The concolic approach is also applicable tomodel checking. In a concolic model checker, the model checker traverses states of the model representing the software being checked, while storing both a concrete state and a symbolic state. The symbolic state is used for checking properties on the software, while the concrete state is used to avoid reaching unreachable states. One such tool is ExpliSAT by Sharon Barner, Cindy Eisner, Ziv Glazberg,Daniel Kroening and Ishai Rabinovitz^[10]

Implementation of traditional symbolic execution based testing requires the implementation of a full-fledged symbolic interpreter for a programming language. Concolic testing implementors noticed that implementation of full-fledged symbolic execution can be avoided if symbolic execution can be piggy-backed with the normal execution of a program throughinstrumentation. This idea of simplifying implementation of symbolic execution gave birth to concolic testing.

An important reason for the rise of concolic testing (and more generally, symbolic-execution based analysis of programs) in the decade since it was introduced in 2005 is the dramatic improvement in the efficiency and expressive power ofSMT Solvers. The key technical developments that lead to the rapid development of SMT solvers include combination of theories, lazy solving, DPLL(T) and the huge improvements in the speed ofSAT solvers. SMT solvers that are particularly tuned for concolic testing includeZ3, STP, Z3str2, andBoolector.

Consider the following simple example, written in C:

voidf(intx,inty){intz=2*y;if(x==100000){if(x<z){assert(0);/* error */}}}

Simple random testing, trying random values ofx andy, would require an impractically large number of tests to reproduce the failure.

We begin with an arbitrary choice forx andy, for examplex = y = 1. In the concrete execution, line 2 setsz to 2, and the test in line 3 fails since 1 ≠ 100000. Concurrently, the symbolic execution follows the same path but treatsx andy as symbolic variables. It setsz to the expression 2y and notes that, because the test in line 3 failed,x ≠ 100000. This inequality is called apath condition and must be true for all executions following the same execution path as the current one.

Since we'd like the program to follow a different execution path on the next run, we take the last path condition encountered,x ≠ 100000, and negate it, givingx = 100000. An automated theorem prover is then invoked to find values for the input variablesx andy given the complete set of symbolic variable values and path conditions constructed during symbolic execution. In this case, a valid response from the theorem prover might bex = 100000,y = 0.

Running the program on this input allows it to reach the inner branch on line 4, which is not taken since 100000 (x) is not less than 0 (z = 2y). The path conditions arex = 100000 andx ≥z. The latter is negated, givingx <z. The theorem prover then looks forx,y satisfyingx = 100000,x <z, andz = 2y; for example,x = 100000,y = 50001. This input reaches the error.

Essentially, a concolic testing algorithm operates as follows:

1. Classify a particular set of variables asinput variables. These variables will be treated as symbolic variables during symbolic execution. All other variables will be treated as concrete values.
2. Instrument the program so that each operation which may affect a symbolic variable value or a path condition is logged to a trace file, as well as any error that occurs.
3. Choose an arbitrary input to begin with.
4. Execute the program.
5. Symbolically re-execute the program on the trace, generating a set of symbolic constraints (including path conditions).
6. Negate the last path condition not already negated in order to visit a new execution path. If there is no such path condition, the algorithm terminates.
7. Invoke an automated satisfiability solver on the new set of path conditions to generate a new input. If there is no input satisfying the constraints, return to step 6 to try the next execution path.
8. Return to step 4.

There are a few complications to the above procedure:

• The algorithm performs adepth-first search over an implicittree of possible execution paths. In practice programs may have very large or infinite path trees – a common example is testing data structures that have an unbounded size or length. To prevent spending too much time on one small area of the program, the search may be depth-limited (bounded).
• Symbolic execution and automated theorem provers have limitations on the classes of constraints they can represent and solve. For example, a theorem prover based on linear arithmetic will be unable to cope with the nonlinear path conditionxy = 6. Any time that such constraints arise, the symbolic execution may substitute the current concrete value of one of the variables to simplify the problem. An important part of the design of a concolic testing system is selecting a symbolic representation precise enough to represent the constraints of interest.

Symbolic-execution based analysis and testing, in general, has witnessed a significant level of interest from industry.^{[citation needed]} Perhaps the most famous commercial tool that uses dynamic symbolic execution (aka concolic testing) is the SAGE tool from Microsoft. The KLEE and S2E tools (both of which are open-source tools, and use the STP constraint solver) are widely used in many companies including Micro Focus Fortify, NVIDIA, and IBM.^{[citation needed]} Increasingly these technologies are being used by many security companies and hackers alike to find security vulnerabilities.

Concolic testing has a number of limitations:

• If the program exhibits nondeterministic behavior, it may follow a different path than the intended one. This can lead to nontermination of the search and poor coverage.
• Even in a deterministic program, a number of factors may lead to poor coverage, including imprecise symbolic representations, incomplete theorem proving, and failure to search the most fruitful portion of a large or infinite path tree.
• Programs which thoroughly mix the state of their variables, such as cryptographic primitives, generate very large symbolic representations that cannot be solved in practice. For example, the conditionif(sha256_hash(input) == 0x12345678) { ... } requires the theorem prover to invertSHA256, which is an open problem.

• pathcrawler-online.com is a restricted version of the current PathCrawler tool which is publicly available as an online test-case server for evaluation and education purposes.
• jCUTE is available as binary under a research-use only license by Urbana-Champaign forJava.
• CREST is an open-source solution forC that replaced^[11] CUTE (modified BSD license).
• KLEE is an open source solution built on-top of theLLVM infrastructure (UIUC license).
• CATG is an open-source solution forJava (BSD license).
• Jalangi is an open-source concolic testing and symbolic execution tool for JavaScript. Jalangi supports integers and strings.
• Microsoft Pex, developed at Microsoft Rise, is publicly available as aMicrosoft Visual Studio 2010 Power Tool for theNET Framework.
• Triton is an open-source concolic execution library for binary code.
• CutEr is an open-source concolic testing tool for the Erlang functional programming language.

Many tools, notably DART and SAGE, have not been made available to the public at large. Note however that for instance SAGE is "used daily" for internal security testing at Microsoft.^[12]

• Automated theorem proving
• Software testing

• Articles with short description
• Short description matches Wikidata
• All articles with unsourced statements
• Articles with unsourced statements from January 2018
• Articles with unsourced statements from March 2017