def test_composite_solver():
#pylint:disable=no-member
s = claripy.SolverComposite()
x = claripy.BVS("x", 32)
y = claripy.BVS("y", 32)
z = claripy.BVS("z", 32)
c = claripy.And(x == 1, y == 2, z == 3)
s.add(c)
nose.tools.assert_equal(len(s._solver_list), 3)
nose.tools.assert_true(s.satisfiable())
s.add(x < y)
nose.tools.assert_equal(len(s._solver_list), 2)
nose.tools.assert_true(s.satisfiable())
s.simplify()
nose.tools.assert_equal(len(s._solver_list), 3)
nose.tools.assert_true(s.satisfiable())
s1 = s.branch()
nose.tools.assert_equal(len(s1._solver_list), 3)
s1.add(x > y)
nose.tools.assert_equal(len(s1._solver_list), 2)
nose.tools.assert_false(s1.satisfiable())
nose.tools.assert_equal(len(s._solver_list), 3)
nose.tools.assert_true(s.satisfiable())
s.add(claripy.BVV(1, 32) == claripy.BVV(2, 32))
nose.tools.assert_equal(len(s._solver_list), 3)
nose.tools.assert_false(s.satisfiable())
ss = s.branch()
nose.tools.assert_equal(len(ss._solver_list), 3)
nose.tools.assert_false(ss.satisfiable())
s = claripy.SolverComposite()
x = claripy.BVS("x", 32)
y = claripy.BVS("y", 32)
z = claripy.BVS("z", 32)
c = claripy.And(x == 1, y == 2, z == 3)
s.add(c)
if isinstance(s._template_frontend, claripy.frontend_mixins.ModelCacheMixin):
assert len(s._solver_list) == 3
count = claripy._backends_module.backend_z3.solve_count
assert s.satisfiable()
assert claripy._backends_module.backend_z3.solve_count == count + 3
assert list(s.eval(x+y, 1)) == [3]
assert claripy._backends_module.backend_z3.solve_count == count + 3
def _solver(self):
"""
Creates or gets a Claripy solver, based on the state options.
"""
if self._stored_solver is not None:
return self._stored_solver
track = o.CONSTRAINT_TRACKING_IN_SOLVER in self.state.options
approximate_first = o.APPROXIMATE_FIRST in self.state.options
if o.STRINGS_ANALYSIS in self.state.options:
if 'smtlib_cvc4' in backend_manager.backends._backends_by_name:
our_backend = backend_manager.backends.smtlib_cvc4
elif 'smtlib_z3' in backend_manager.backends._backends_by_name:
our_backend = backend_manager.backends.smtlib_z3
elif 'smtlib_abc' in backend_manager.backends._backends_by_name:
our_backend = backend_manager.backends.smtlib_abc
else:
l.error(
"Cannot find a suitable string solver. Please ensure you have installed a string solver that "
"angr supports, and have imported the corresponding solver backend in claripy. You can try "
"adding \"from claripy.backends.backend_smtlib_solvers import *\" at the beginning of your "
"script.")
raise ValueError("Cannot find a suitable string solver")
if o.COMPOSITE_SOLVER in self.state.options:
self._stored_solver = claripy.SolverComposite(
template_solver_string=claripy.SolverCompositeChild(
backend=our_backend, track=track))
elif o.ABSTRACT_SOLVER in self.state.options:
self._stored_solver = claripy.SolverVSA()
elif o.SYMBOLIC in self.state.options and o.REPLACEMENT_SOLVER in self.state.options:
self._stored_solver = claripy.SolverReplacement(auto_replace=False)
elif o.SYMBOLIC in self.state.options and o.CACHELESS_SOLVER in self.state.options:
self._stored_solver = claripy.SolverCacheless(track=track)
elif o.SYMBOLIC in self.state.options and o.COMPOSITE_SOLVER in self.state.options:
self._stored_solver = claripy.SolverComposite(track=track)
elif o.SYMBOLIC in self.state.options and any(
opt in self.state.options for opt in o.approximation):
self._stored_solver = claripy.SolverHybrid(
track=track, approximate_first=approximate_first)
elif o.HYBRID_SOLVER in self.state.options:
self._stored_solver = claripy.SolverHybrid(
track=track, approximate_first=approximate_first)
elif o.SYMBOLIC in self.state.options:
self._stored_solver = claripy.Solver(track=track)
else:
self._stored_solver = claripy.SolverConcrete()
return self._stored_solver
def get_solver(self):
# Skip these test for now because of a problem with pysmt
raise nose.SkipTest()
solver = claripy.SolverPortfolio(solvers=[
claripy.SolverComposite(
template_solver_string=claripy.SolverCompositeChild(
backend=claripy.backend_manager.backends.smtlib_cvc4)),
claripy.SolverComposite(
template_solver_string=claripy.SolverCompositeChild(
backend=claripy.backend_manager.backends.smtlib_z3)),
claripy.SolverComposite(
template_solver_string=claripy.SolverCompositeChild(
backend=claripy.backend_manager.backends.smtlib_z3str)),
])
return solver
def test_composite_discrepancy():
a = claripy.BVS("a", 8)
b = claripy.BVS("b", 8)
x = claripy.BVS("x", 32)
y = claripy.BVS("y", 32)
z = claripy.BVS("z", 32)
xy = x + y
dst = claripy.BVV(0xbaaaaf50, 32) + xy
constraints = []
constraints.append(x <= 0x1)
constraints.append(x != 0x0)
constraints.append(claripy.SignExt(24, claripy.If(x > 0x0, a, 0)) != 0xa)
constraints.append(x < 0x80)
constraints.append(y <= 0x1)
constraints.append(x == 0x1)
constraints.append((0xbaaaaf50 + x) == 0xbaaaaf51)
constraints.append(y != 0x0)
constraints.append(claripy.SignExt(24, claripy.If(y > 0x0, b, 0)) != 0xa)
constraints.append((x + y) < 0x80)
constraints.append(z <= 0x1)
constraints.append((x + y) == 0x2)
sn = claripy.Solver()
sc = claripy.SolverComposite()
sn.add(constraints)
sc.add(constraints)
print(sn.max(dst), sc.max(dst))
print(sn.min(dst), sc.min(dst))
assert sn.max(dst) == sc.max(dst)
assert sn.min(dst) == sc.min(dst)
def _solver(self):
"""
Creates or gets a Claripy solver, based on the state options.
"""
if self._stored_solver is not None:
return self._stored_solver
track = o.CONSTRAINT_TRACKING_IN_SOLVER in self.state.options
if o.ABSTRACT_SOLVER in self.state.options:
self._stored_solver = claripy.SolverVSA()
elif o.REPLACEMENT_SOLVER in self.state.options:
self._stored_solver = claripy.SolverReplacement(auto_replace=False)
elif o.CACHELESS_SOLVER in self.state.options:
self._stored_solver = claripy.SolverCacheless(track=track)
elif o.COMPOSITE_SOLVER in self.state.options:
self._stored_solver = claripy.SolverComposite(track=track)
elif o.SYMBOLIC in self.state.options and o.approximation & self.state.options:
self._stored_solver = claripy.SolverHybrid(track=track)
elif o.SYMBOLIC in self.state.options:
self._stored_solver = claripy.Solver(track=track)
else:
self._stored_solver = claripy.SolverConcrete()
return self._stored_solver
def test_composite_solver_branching_optimizations():
s = claripy.SolverComposite()
w = claripy.BVS("w", 32)
x = claripy.BVS("x", 32)
y = claripy.BVS("y", 32)
z = claripy.BVS("z", 32)
s.add(w == 10)
assert len(s._unchecked_solvers) == 1
assert s.satisfiable()
s.add(x == 10)
assert len(s._unchecked_solvers) == 1
s2 = s.branch()
assert len(s2._unchecked_solvers) == 1
assert s.satisfiable()
assert len(s._unchecked_solvers) == 0
assert len(s2._unchecked_solvers) == 1
s.add(y == 10)
assert len(s._unchecked_solvers) == 1
assert len(s2._unchecked_solvers) == 1
s2.add(z == 10)
assert len(s._unchecked_solvers) == 1
assert len(s2._unchecked_solvers) == 2
assert s2.satisfiable()
assert len(s._unchecked_solvers) == 1
assert len(s2._unchecked_solvers) == 0
s2.add(z == 12)
assert not s2.satisfiable()
assert not s2.satisfiable()
def _solver(self):
"""
Creates or gets a Claripy solver, based on the state options.
"""
if self._stored_solver is not None:
return self._stored_solver
track = o.CONSTRAINT_TRACKING_IN_SOLVER in self.state.options
approximate_first = o.APPROXIMATE_FIRST in self.state.options
if o.STRINGS_ANALYSIS in self.state.options:
if 'smtlib_cvc4' in backend_manager.backends._backends_by_name:
our_backend = backend_manager.backends.smtlib_cvc4
elif 'smtlib_z3' in backend_manager.backends._backends_by_name:
our_backend = backend_manager.backends.smtlib_z3
elif 'smtlib_abc' in backend_manager.backends._backends_by_name:
our_backend = backend_manager.backends.smtlib_abc
else:
raise ValueError("Could not find suitable string solver!")
if o.COMPOSITE_SOLVER in self.state.options:
self._stored_solver = claripy.SolverComposite(
template_solver_string=claripy.SolverCompositeChild(
backend=our_backend, track=track))
elif o.ABSTRACT_SOLVER in self.state.options:
self._stored_solver = claripy.SolverVSA()
elif o.SYMBOLIC in self.state.options and o.REPLACEMENT_SOLVER in self.state.options:
self._stored_solver = claripy.SolverReplacement(auto_replace=False)
elif o.SYMBOLIC in self.state.options and o.CACHELESS_SOLVER in self.state.options:
self._stored_solver = claripy.SolverCacheless(track=track)
elif o.SYMBOLIC in self.state.options and o.COMPOSITE_SOLVER in self.state.options:
self._stored_solver = claripy.SolverComposite(track=track)
elif o.SYMBOLIC in self.state.options and any(
opt in self.state.options for opt in o.approximation):
self._stored_solver = claripy.SolverHybrid(
track=track, approximate_first=approximate_first)
elif o.HYBRID_SOLVER in self.state.options:
self._stored_solver = claripy.SolverHybrid(
track=track, approximate_first=approximate_first)
elif o.SYMBOLIC in self.state.options:
self._stored_solver = claripy.Solver(track=track)
else:
self._stored_solver = claripy.SolverConcrete()
return self._stored_solver
def test_issue16():
s = claripy.SolverComposite()
c = claripy.BVS('test', 32)
s.add(c[7:0] != 0)
assert s.satisfiable()
s.add(c == 0)
#print s.satisfiable()
assert not s.satisfiable(extra_constraints=[claripy.BVS('lol', 32) == 0])
assert not s.satisfiable()
def test_composite_solver_with_strings():
s = claripy.SolverComposite(
template_solver_string=claripy.SolverCompositeChild(
backend=claripy.backend_manager.backends.smtlib_cvc4))
x = claripy.BVS("x", 32)
y = claripy.BVS("y", 32)
z = claripy.BVS("z", 32)
str_1 = claripy.StringS("sym_str_1", 1024)
c = claripy.And(x == 1, y == 2, z == 3,
str_1 == claripy.StringV("cavallo"))
s.add(c)
nose.tools.assert_equal(len(s._solver_list), 4)
nose.tools.assert_true(s.satisfiable())
nose.tools.assert_equal(list(s.eval(str_1, 1)), ["cavallo"])
def test_datalayer():
l.info("Running test_datalayer")
pickle_dir = tempfile.mkdtemp()
ana.set_dl(ana.DirDataLayer(pickle_dir))
l.debug("Pickling to %s", pickle_dir)
a = claripy.BVV(1, 32)
b = claripy.BVS("x", 32)
c = a + b
d = a + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b
l.debug("Storing!")
a.ana_store()
c_info = c.ana_store()
d_info = d.ana_store()
l.debug("Loading!")
ana.set_dl(ana.DirDataLayer(pickle_dir))
#nose.tools.assert_equal(len(claripy.dl._cache), 0)
cc = claripy.ast.BV.ana_load(c_info)
nose.tools.assert_equal(str(cc), str(c))
cd = claripy.ast.BV.ana_load(d_info)
nose.tools.assert_equal(str(cd), str(d))
l.debug("Time to test some solvers!")
s = claripy.Solver()
x = claripy.BVS("x", 32)
s.add(x == 3)
s.finalize()
ss = claripy.Solver.ana_load(s.ana_store())
nose.tools.assert_equal(str(s.constraints), str(ss.constraints))
nose.tools.assert_equal(str(s.variables), str(ss.variables))
s = claripy.SolverComposite()
x = claripy.BVS("x", 32)
s.add(x == 3)
s.finalize()
ss = claripy.SolverComposite.ana_load(s.ana_store())
old_constraint_sets = [[hash(j) for j in k.constraints]
for k in s._solver_list]
new_constraint_sets = [[hash(j) for j in k.constraints]
for k in ss._solver_list]
nose.tools.assert_equal(old_constraint_sets, new_constraint_sets)
nose.tools.assert_equal(str(s.variables), str(ss.variables))
def _solver(self):
if self._stored_solver is not None:
return self._stored_solver
if o.ABSTRACT_SOLVER in self.state.options:
self._stored_solver = claripy.SolverVSA()
elif o.REPLACEMENT_SOLVER in self.state.options:
self._stored_solver = claripy.SolverReplacement(auto_replace=False)
elif o.CACHELESS_SOLVER in self.state.options:
self._stored_solver = claripy.SolverCacheless()
elif o.COMPOSITE_SOLVER in self.state.options:
self._stored_solver = claripy.SolverComposite()
elif o.SYMBOLIC in self.state.options and o.approximation & self.state.options:
self._stored_solver = claripy.SolverHybrid()
elif o.SYMBOLIC in self.state.options:
self._stored_solver = claripy.Solver()
else:
self._stored_solver = claripy.SolverConcrete()
return self._stored_solver
