angr 9.2.87__py3-none-manylinux2014_x86_64.whl → 9.2.89__py3-none-manylinux2014_x86_64.whl

tests/state_plugins/solver/test_symbolic.py

@@ -1,153 +0,0 @@
-#!/usr/bin/env python3
-# pylint: disable=missing-class-docstring,no-self-use,line-too-long
-__package__ = __package__ or "tests.state_plugins.solver"  # pylint:disable=redefined-builtin
-
-import unittest
-
-import angr
-
-from ...common import broken
-
-
-class TestSymbolic(unittest.TestCase):
-    # @broken
-    # def test_symvalue(self):
-    #   # concrete symvalue
-    #   zero = SimValue(se.BVV(0, 64))
-    #   assert not zero.is_symbolic()
-    #   assert zero.eval() == 0
-    #
-    #   # symbolic symvalue
-    #   x = se.BVS('x', 64)
-    #   sym = SimValue(x, constraints = [ x > 100, x < 200 ])
-    #   assert sym.is_symbolic()
-    #   assert sym.min_int() == 101
-    #   assert sym.max_int() == 199
-    #   assert sym.eval_upto(99) == range(101, 200)
-
-    def test_concretization_strategies(self):
-        initial_memory = {0: b"A", 1: b"B", 2: b"C", 3: b"D"}
-
-        s = angr.SimState(arch="AMD64", dict_memory_backer=initial_memory)
-
-        # sanity check
-        assert s.solver.eval_upto(s.memory.load(3, size=1), 2, cast_to=bytes) == [b"D"]
-
-        x = s.solver.BVS("x", s.arch.bits)
-        s.add_constraints(x >= 1)
-        s.add_constraints(x <= 3)
-
-        ss = s.copy()
-        assert tuple(sorted(ss.solver.eval_upto(ss.memory.load(x, 1), 10, cast_to=bytes))) == (b"B", b"C", b"D")
-
-        ss = s.copy()
-        x = s.solver.BVS("x", s.arch.bits)
-        s.add_constraints(x >= 1)
-        ss.options.add(angr.options.CONSERVATIVE_READ_STRATEGY)
-        ss.memory._create_default_read_strategies()
-        assert "symbolic" in next(iter(ss.memory.load(x, 1).variables))
-
-    # def test_concretization(self):
-    #   s = angr.SimState(arch="AMD64", mode="symbolic")
-    #   dst = s.solver.BVV(0x41424300, 32)
-    #   dst_addr = s.solver.BVV(0x1000, 64)
-    #   s.memory.store(dst_addr, dst, 4)
-
-    #   print "MEM KEYS", s.memory.mem.keys()
-    #   print "REG KEYS", s.registers.mem.keys()
-
-    #   print "TO NATIVE..."
-    #   s.set_native(True)
-    #   print "... done"
-
-    #   vv = s.native_env.vexecute(pyvex.IRExpr.Load("Iend_BE", "Ity_I32",
-    #                              pyvex.IRExpr.Const(pyvex.IRConst.U64(0x1000))))
-    #   assert vv.str[:4] == 'ABC\x00'
-    #   s.native_env.vexecute(pyvex.IRSB(bytes='\xb8\x41\x42\x43\x44'))
-
-    #   #import IPython; IPython.embed()
-    #   print "FROM NATIVE..."
-    #   s.set_native(False)
-    #   print "... done"
-
-    #   assert s.reg_value(16).solver.eval() == 0x44434241
-    #   print "YEAH"
-
-    @broken
-    def test_symbolic_write(self):
-        s = angr.SimState(arch="AMD64", mode="symbolic")
-
-        addr = s.solver.BVS("addr", 64)
-        s.add_constraints(s.solver.Or(addr == 10, addr == 20, addr == 30))
-        assert len(s.solver.eval_upto(addr, 10)) == 3
-
-        s.memory.store(10, s.solver.BVV(1, 8))
-        s.memory.store(20, s.solver.BVV(2, 8))
-        s.memory.store(30, s.solver.BVV(3, 8))
-
-        assert s.solver.unique(s.memory.load(10, 1))
-        assert s.solver.unique(s.memory.load(20, 1))
-        assert s.solver.unique(s.memory.load(30, 1))
-
-        # print "CONSTRAINTS BEFORE:", s.constraints._solver.constraints
-        # s.memory.store(addr, s.solver.BVV(255, 8), strategy=['symbolic','any'], limit=100)
-        s.memory.store(addr, s.solver.BVV(255, 8))
-        assert s.satisfiable()
-
-        assert len(s.solver.eval_upto(addr, 10)) == 3
-        assert s.solver.eval_upto(s.memory.load(10, 1), 3) == [1, 255]
-        assert s.solver.eval_upto(s.memory.load(20, 1), 3) == [2, 255]
-        assert s.solver.eval_upto(s.memory.load(30, 1), 3) == [3, 255]
-        assert len(s.solver.eval_upto(addr, 10)) == 3
-
-        # see if it works when constraining the write address
-        sa = s.copy()
-        sa.add_constraints(addr == 20)
-        assert sa.satisfiable()
-        assert sa.solver.eval_upto(sa.memory.load(10, 1), 3) == [1]
-        assert sa.solver.eval_upto(sa.memory.load(20, 1), 3) == [255]
-        assert sa.solver.eval_upto(sa.memory.load(30, 1), 3) == [3]
-        assert sa.solver.eval_upto(addr, 10) == [20]
-
-        # see if it works when constraining a value to the written one
-        sv = s.copy()
-        sv.add_constraints(sv.memory.load(30, 1) == 255)
-        assert sv.satisfiable()
-        assert sv.solver.eval_upto(sv.memory.load(10, 1), 3) == [1]
-        assert sv.solver.eval_upto(sv.memory.load(20, 1), 3) == [2]
-        assert sv.solver.eval_upto(sv.memory.load(30, 1), 3) == [255]
-        assert sv.solver.eval_upto(addr, 10) == [30]
-
-        # see if it works when constraining a value to the unwritten one
-        sv = s.copy()
-        sv.add_constraints(sv.memory.load(30, 1) == 3)
-        assert sv.satisfiable()
-        assert sv.solver.eval_upto(sv.memory.load(10, 1), 3) == [1, 255]
-        assert sv.solver.eval_upto(sv.memory.load(20, 1), 3) == [2, 255]
-        assert sv.solver.eval_upto(sv.memory.load(30, 1), 3) == [3]
-        assert sv.solver.eval_upto(addr, 10) == [10, 20]
-
-        s = angr.SimState(arch="AMD64", mode="symbolic")
-        s.memory.store(0, s.solver.BVV(0x4141414141414141, 64))
-        length = s.solver.BVS("length", 32)
-        # s.memory.store(0, s.solver.BVV(0x4242424242424242, 64), symbolic_length=length)
-        s.memory.store(0, s.solver.BVV(0x4242424242424242, 64))
-
-        for i in range(8):
-            ss = s.copy()
-            ss.add_constraints(length == i)
-            assert ss.solver.eval(s.memory.load(0, 8), cast_to=bytes) == b"B" * i + b"A" * (8 - i)
-
-    def test_unsat_core(self):
-        s = angr.SimState(arch="AMD64", mode="symbolic", add_options={angr.options.CONSTRAINT_TRACKING_IN_SOLVER})
-        x = s.solver.BVS("x", 32)
-        s.add_constraints(s.solver.BVV(0, 32) == x)
-        s.add_constraints(s.solver.BVV(1, 32) == x)
-
-        assert not s.satisfiable()
-        unsat_core = s.solver.unsat_core()
-        assert len(unsat_core) == 2
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/state_plugins/solver/test_variable_registration.py

@@ -1,46 +0,0 @@
-#!/usr/bin/env python3
-# pylint: disable=missing-class-docstring,no-self-use,line-too-long
-
-import unittest
-
-import angr
-
-
-class TestVariableRegistration(unittest.TestCase):
-    def test_registration(self):
-        s = angr.SimState(arch="AMD64")
-
-        a1 = s.solver.BVS("a", 64, key=(1,), eternal=True)
-        a2 = s.solver.BVS("a", 64, key=(1,), eternal=True)
-        assert a1 is a2
-
-        b1 = s.solver.BVS("b", 64, key=(2,), eternal=False)
-        s1 = s.copy()
-        s2 = s.copy()
-
-        b2 = s1.solver.BVS("b", 64, key=(2,), eternal=False)
-        b3 = s2.solver.BVS("b", 64, key=(2,), eternal=False)
-        assert b1 is not b2
-        assert b2 is not b3
-        assert b1 is not b3
-
-        a3 = s1.solver.BVS("a", 64, key=(1,), eternal=True)
-        a4 = s2.solver.BVS("a", 64, key=(1,), eternal=True)
-        assert a2 is a3
-        assert a3 is a4
-
-        assert len(list(s.solver.get_variables(1))) == 1
-        assert len(list(s1.solver.get_variables(1))) == 1
-        assert len(list(s2.solver.get_variables(1))) == 1
-
-        assert len(list(s.solver.get_variables(2))) == 1
-        assert len(list(s1.solver.get_variables(2))) == 2
-        assert len(list(s2.solver.get_variables(2))) == 2
-
-        assert list(s.solver.describe_variables(a1)) == [(1,)]
-        assert list(s.solver.describe_variables(b1)) == [(2, 1)]
-        assert sorted(list(s.solver.describe_variables(a1 + b1))) == [(1,), (2, 1)]
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/state_plugins/test_callstack.py

@@ -1,54 +0,0 @@
-#!/usr/bin/env python3
-import unittest
-
-from angr.state_plugins.callstack import CallStack
-
-
-# pylint: disable=missing-class-docstring
-# pylint: disable=no-self-use
-class TestCallstack(unittest.TestCase):
-    def test_empty_stack(self):
-        cs = CallStack()
-
-        # Initial setting: just assume the control flow starts from 0x300000
-        cs = cs.call(None, 0x300000, None, 0xFFFFFFF0)
-
-        # Calling 0x401000 from 0x400000. When it returns, it should return to 0x400004.
-        # The stack pointer after entering the new function should be 0xffffff00
-        # Note: this means on platforms like x86 and AMD64 where CALL instruction actually pushes the ret address on to
-        # the stack and modifies the stack pointer, the user should adjust stack pointer accordingly (minus 4 or 8, for
-        # example) before passing to CallStack.call(). CallStack has no way to know what the architecture it is used on.
-        cs = cs.call(0x400000, 0x401000, 0x400004, 0xFFFFFF00)
-
-        cs = cs.call(0x401008, 0x402000, 0x40100C, 0xFFFFFE80)
-
-        assert cs.current_function_address == 0x402000
-        assert cs.current_stack_pointer == 0xFFFFFE80
-
-        # Return to 0x40100c
-        cs = cs.ret(0x40100C)
-
-        assert cs.current_function_address == 0x401000
-        assert cs.current_stack_pointer == 0xFFFFFF00
-
-        cs = cs.ret(0x400004)
-
-        assert cs.current_function_address == 0x300000
-        assert cs.current_stack_pointer == 0xFFFFFFF0
-
-        # We return one more time to see what happens
-        # Ideally nothing should be popped out
-        cs = cs.ret(0x200000)
-
-        assert cs.current_function_address == 0x300000
-        assert cs.current_stack_pointer == 0xFFFFFFF0
-
-        # Final return!
-        cs = cs.ret(None)
-
-        assert cs.current_function_address == 0
-        assert cs.current_stack_pointer == 0
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/state_plugins/test_gdb_plugin.py

@@ -1,35 +0,0 @@
-#!/usr/bin/env python3
-# pylint: disable=missing-class-docstring,disable=no-self-use
-__package__ = __package__ or "tests.state_plugins"  # pylint:disable=redefined-builtin
-
-import os
-import unittest
-
-import angr
-
-from ..common import bin_location
-
-
-test_location = os.path.join(bin_location, "tests")
-data_location = os.path.join(bin_location, "tests_data", "test_gdb_plugin")
-
-
-class TestGdbPlugin(unittest.TestCase):
-    def test_gdb(self):
-        p = angr.Project(os.path.join(test_location, "x86_64", "test_gdb_plugin"), auto_load_libs=False)
-        st = p.factory.blank_state()
-
-        st.gdb.set_stack(os.path.join(data_location, "stack"), stack_top=0x7FFFFFFFF000)
-        st.gdb.set_heap(os.path.join(data_location, "heap"), heap_base=0x601000)
-        st.gdb.set_regs(os.path.join(data_location, "regs"))
-
-        assert st.solver.eval(st.regs.rip) == 0x4005B4
-
-        # Read the byte in memory at $sp + 8
-        loc = st.solver.eval(st.regs.rsp) + 8
-        val = st.memory.load(loc, 8, endness=st.arch.memory_endness)
-        assert st.solver.eval(val) == 0x00601010
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/state_plugins/test_multi_open_file.py

@@ -1,47 +0,0 @@
-#!/usr/bin/env python3
-# pylint: disable=missing-class-docstring,no-self-use,line-too-long
-__package__ = __package__ or "tests.state_plugins"  # pylint:disable=redefined-builtin
-
-import os
-import unittest
-
-import angr
-
-from ..common import bin_location
-
-
-test_location = os.path.join(bin_location, "tests")
-
-
-class TestMultiOpenFile(unittest.TestCase):
-    def test_multi_open_file(self):
-        test_bin = os.path.join(test_location, "x86_64", "test_multi_open_file")
-        # auto_load_libs cannot be disabled as the test fails
-        b = angr.Project(test_bin)
-
-        pg = b.factory.simulation_manager()
-        pg.active[0].options.discard("LAZY_SOLVES")
-        pg.explore()
-
-        assert len(pg.deadended) == 1
-
-        # See the source file in binaries/tests_src/test_multi_open_file.c
-        # for the tests run
-        for p in pg.deadended:
-            assert p.posix.dumps(2) == b""
-
-            # Check that the temp file was deleted
-            assert p.fs._files == {}
-
-            # Check that the deleted temp file contained the appropriate string
-            for event in p.history.events:
-                if event.type == "fs_unlink":
-                    simfile = p.fs.unlinks[event.objects["unlink_idx"]][1]
-                    assert simfile.concretize() == b"foobar and baz"
-                    break
-            else:
-                assert False
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/state_plugins/test_symbolization.py

@@ -1,38 +0,0 @@
-#!/usr/bin/env python3
-# pylint: disable=missing-class-docstring,no-self-use,line-too-long
-__package__ = __package__ or "tests.state_plugins"  # pylint:disable=redefined-builtin
-
-import os
-import unittest
-
-import angr
-
-from ..common import bin_location
-
-
-test_location = os.path.join(bin_location, "tests")
-
-
-class TestSymbolization(unittest.TestCase):
-    def test_fauxware_symbolization(self):
-        p = angr.Project(os.path.join(test_location, "x86_64", "fauxware"), auto_load_libs=False)
-        sm = p.factory.simulation_manager()
-
-        assert not sm.one_active.regs.rsp.symbolic
-
-        sm.one_active.symbolizer.set_symbolization_for_all_pages()
-        sm.one_active.symbolizer.resymbolize()
-
-        # assert sm.one_active.regs.rsp.symbolic
-        assert sm.one_active.symbolizer.symbolized_count
-
-        # make sure pointers get symbolized at runtime
-        n = sm.one_active.symbolizer.symbolized_count
-        sm.run()
-        assert not sm.errored
-        assert not sm.active
-        assert sm.one_deadended.symbolizer.symbolized_count > n
-
-
-if __name__ == "__main__":
-    unittest.main()