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

tests/exploration_techniques/test_driller_core.py

@@ -1,48 +0,0 @@
-#!/usr/bin/env python3
-# pylint: disable=missing-class-docstring,disable=no-self-use
-__package__ = __package__ or "tests.exploration_techniques"  # pylint:disable=redefined-builtin
-
-import os
-import platform
-import sys
-import unittest
-
-import angr
-
-from .test_tracer import tracer_cgc
-from ..common import bin_location
-
-
-test_location = os.path.join(bin_location, "tests")
-
-
-@unittest.skipIf(platform.system() == "Darwin" and platform.machine() == "arm64", "Broken on apple silicon")
-class TestDrillerCore(unittest.TestCase):
-    @unittest.skipIf(sys.platform == "win32", "broken on windows")
-    def test_cgc(self):
-        binary = os.path.join(test_location, "cgc", "sc1_0b32aa01_01")
-        simgr, tracer = tracer_cgc(binary, "driller_core_cgc", b"AAAA", copy_states=True, follow_unsat=True)
-        simgr.use_technique(angr.exploration_techniques.DrillerCore(tracer._trace))
-        simgr.run()
-
-        assert "diverted" in simgr.stashes
-        assert len(simgr.diverted) == 3
-
-    def test_simprocs(self):
-        binary = os.path.join(test_location, "i386", "driller_simproc")
-        memcmp = angr.SIM_PROCEDURES["libc"]["memcmp"]()
-
-        simgr, tracer = tracer_cgc(binary, "driller_core_simprocs", b"A" * 128, copy_states=True, follow_unsat=True)
-        p = simgr._project
-        p.hook(0x8048200, memcmp)
-
-        d = angr.exploration_techniques.DrillerCore(tracer._trace)
-        simgr.use_technique(d)
-
-        simgr.run()
-        assert "diverted" in simgr.stashes
-        assert len(simgr.diverted) > 0
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/exploration_techniques/test_loop_seer.py

@@ -1,158 +0,0 @@
-#!/usr/bin/env python3
-# pylint: disable=missing-class-docstring,no-self-use,line-too-long
-__package__ = __package__ or "tests.exploration_techniques"  # pylint:disable=redefined-builtin
-
-import os
-import unittest
-
-import angr
-
-from ..common import bin_location
-
-
-test_location = os.path.join(bin_location, "tests")
-
-
-class TestLoopSeer(unittest.TestCase):
-    def test_various_loops(self):
-        p = angr.Project(os.path.join(test_location, "x86_64", "various_loops"), auto_load_libs=False)
-
-        cfg = p.analyses.CFGFast(normalize=True)
-
-        state = p.factory.entry_state()
-        state.register_plugin("loop_data", angr.state_plugins.SimStateLoopData())
-
-        dummy = p.loader.main_object.get_symbol("dummy")
-        bvs = state.solver.BVS(dummy.name, 8 * dummy.size)
-        state.memory.store(dummy.rebased_addr, bvs, endness="Iend_LE")
-
-        simgr = p.factory.simulation_manager(state)
-
-        simgr.use_technique(angr.exploration_techniques.LoopSeer(cfg=cfg, functions=None, bound=None))
-
-        simgr.run()
-
-        assert len(simgr.deadended) == 10
-        assert len(simgr.deadended[0].loop_data.back_edge_trip_counts) == 14
-
-        for i, d in enumerate(simgr.deadended):
-            f = p.kb.functions.function(name="symbolic_loop")
-            l = p.analyses.LoopFinder(functions=[f]).loops[0]
-            assert d.loop_data.back_edge_trip_counts[l.entry.addr][0] == i
-
-            f = p.kb.functions.function(name="for_loop")
-            l = p.analyses.LoopFinder(functions=[f]).loops[0]
-            assert d.loop_data.back_edge_trip_counts[l.entry.addr][0] == 9
-
-            f = p.kb.functions.function(name="while_loop")
-            l = p.analyses.LoopFinder(functions=[f]).loops[0]
-            assert d.loop_data.back_edge_trip_counts[l.entry.addr][0] == 9
-
-            f = p.kb.functions.function(name="do_while_loop")
-            l = p.analyses.LoopFinder(functions=[f]).loops[0]
-            assert d.loop_data.header_trip_counts[l.entry.addr][0] == 9
-
-            f = p.kb.functions.function(name="nullify")
-            l = p.analyses.LoopFinder(functions=[f]).loops[0]
-            assert len(d.loop_data.back_edge_trip_counts[l.entry.addr]) == 8
-            assert d.loop_data.back_edge_trip_counts[l.entry.addr][0] == 9
-
-            f = p.kb.functions.function(name="nested_for_loop")
-            ol = p.analyses.LoopFinder(functions=[f]).loops[0]
-            il = ol.subloops[0]
-            assert d.loop_data.back_edge_trip_counts[ol.entry.addr][0] == 3
-            assert len(d.loop_data.back_edge_trip_counts[il.entry.addr]) == 3
-            assert all(s == 3 for s in d.loop_data.back_edge_trip_counts[il.entry.addr])
-
-            f = p.kb.functions.function(name="nested_while_loop")
-            ol = p.analyses.LoopFinder(functions=[f]).loops[0]
-            il = ol.subloops[0]
-            assert d.loop_data.back_edge_trip_counts[ol.entry.addr][0] == 3
-            assert len(d.loop_data.back_edge_trip_counts[il.entry.addr]) == 3
-            assert all(s == 3 for s in d.loop_data.back_edge_trip_counts[il.entry.addr])
-
-            f = p.kb.functions.function(name="nested_do_while_loop")
-            ol = p.analyses.LoopFinder(functions=[f]).loops[0]
-            il = ol.subloops[0]
-            assert d.loop_data.header_trip_counts[ol.entry.addr][0] == 3
-            assert len(d.loop_data.header_trip_counts[il.entry.addr]) == 3
-            assert all(s == 3 for s in d.loop_data.header_trip_counts[il.entry.addr])
-
-            f = p.kb.functions.function(name="break_for_loop")
-            l = p.analyses.LoopFinder(functions=[f]).loops[0]
-            assert d.loop_data.back_edge_trip_counts[l.entry.addr][0] == 9
-
-            f = p.kb.functions.function(name="break_do_while_loop")
-            l = p.analyses.LoopFinder(functions=[f]).loops[0]
-            assert d.loop_data.header_trip_counts[l.entry.addr][0] == 9
-
-    def test_loops_with_invalid_parameter(self):
-        p = angr.Project(os.path.join(test_location, "x86_64", "test_loops"), auto_load_libs=False)
-
-        state = p.factory.entry_state()
-        state.register_plugin("loop_data", angr.state_plugins.SimStateLoopData())
-        simgr = p.factory.simulation_manager(state)
-
-        simgr.use_technique(angr.exploration_techniques.LoopSeer(functions=["main", 0x1234], bound=None))
-
-        simgr.run()
-
-        assert len(simgr.deadended[0].loop_data.back_edge_trip_counts) == 3
-        assert simgr.deadended[0].loop_data.back_edge_trip_counts[0x400665][0] == 10
-        assert len(simgr.deadended[0].loop_data.back_edge_trip_counts[0x400665]) == 10
-        assert simgr.deadended[0].loop_data.back_edge_trip_counts[0x400675][0] == 10
-        assert simgr.deadended[0].loop_data.back_edge_trip_counts[0x4006B2][0] == 100
-
-    def test_arrays(self):
-        p = angr.Project(os.path.join(test_location, "x86_64", "test_arrays"), auto_load_libs=False)
-
-        cfg = p.analyses.CFGFast(normalize=True)
-
-        state = p.factory.entry_state()
-        state.register_plugin("loop_data", angr.state_plugins.SimStateLoopData())
-        simgr = p.factory.simulation_manager(state)
-
-        simgr.use_technique(angr.exploration_techniques.LoopSeer(cfg=cfg, functions="main", bound=None))
-
-        simgr.run()
-
-        assert len(simgr.deadended[0].loop_data.back_edge_trip_counts) == 2
-        assert simgr.deadended[0].loop_data.back_edge_trip_counts[0x400636][0] == 26
-        assert simgr.deadended[0].loop_data.back_edge_trip_counts[0x4005FD][0] == 26
-
-    def test_loop_limiter(self):
-        p = angr.Project(os.path.join(test_location, "x86_64", "test_arrays"), auto_load_libs=False)
-
-        cfg = p.analyses.CFGFast(normalize=True)
-
-        state = p.factory.entry_state()
-        state.register_plugin("loop_data", angr.state_plugins.SimStateLoopData())
-        simgr = p.factory.simulation_manager(state)
-
-        simgr.use_technique(angr.exploration_techniques.LoopSeer(cfg=cfg, functions="main", bound=5))
-
-        simgr.run()
-
-        assert "spinning" in simgr.stashes
-        assert simgr.spinning[0].loop_data.back_edge_trip_counts[0x4005FD][0] == 6
-
-    def test_loop_limiter_constant_loop(self):
-        p = angr.Project(os.path.join(test_location, "x86_64", "constant_loopseer"), auto_load_libs=False)
-
-        cfg = p.analyses.CFGFast(normalize=True)
-
-        state = p.factory.entry_state()
-        simgr = p.factory.simulation_manager(state)
-
-        simgr.use_technique(
-            angr.exploration_techniques.LoopSeer(cfg=cfg, functions="main", bound=5, limit_concrete_loops=False)
-        )
-
-        simgr.run()
-        assert simgr.deadended[0].regs.eax.concrete
-        val = simgr.deadended[0].solver.eval_one(simgr.deadended[0].regs.eax)
-        assert val == 420
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/exploration_techniques/test_memory_watcher.py

@@ -1,46 +0,0 @@
-#!/usr/bin/env python3
-# pylint: disable=missing-class-docstring,no-self-use
-__package__ = __package__ or "tests.exploration_techniques"  # pylint:disable=redefined-builtin
-
-import os
-import unittest
-
-import angr
-import psutil
-
-from ..common import bin_location
-
-
-test_location = os.path.join(bin_location, "tests")
-
-
-class TestMemoryWatcher(unittest.TestCase):
-    def test_memory_watcher(self):
-        binary = os.path.join(test_location, "x86_64", "veritesting_a")
-        proj = angr.Project(binary, auto_load_libs=False)
-        simgr = proj.factory.simulation_manager()
-
-        memory_watcher = angr.exploration_techniques.MemoryWatcher()
-        simgr.use_technique(memory_watcher)
-
-        # Initially build some paths
-        while len(simgr.active) < 32 and simgr.active != []:
-            simgr.step()
-
-        # Something else went wrong..
-        assert simgr.active != []
-
-        # Set fake that memory watcher believes we're too low on memory
-        memory_watcher.min_memory = psutil.virtual_memory().total
-
-        previous_active = len(simgr.active)
-
-        # Step once to move things over
-        simgr.step()
-
-        assert simgr.active == []
-        assert len(getattr(simgr, memory_watcher.memory_stash)) == previous_active
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/exploration_techniques/test_oppologist.py

@@ -1,65 +0,0 @@
-#!/usr/bin/env python3
-# pylint: disable=missing-class-docstring,no-self-use,line-too-long
-__package__ = __package__ or "tests.exploration_techniques"  # pylint:disable=redefined-builtin
-
-import unittest
-import os
-import sys
-
-import angr
-
-from ..common import bin_location
-
-
-test_location = os.path.join(bin_location, "tests")
-
-
-def _ultra_oppologist(p, s):
-    old_ops = dict(angr.engines.vex.claripy.irop.operations)
-    try:
-        angr.engines.vex.claripy.irop.operations.clear()
-        angr.engines.vex.claripy.irop.operations["Iop_Add32"] = old_ops["Iop_Add32"]
-
-        pg = p.factory.simulation_manager(s)
-        pg.use_technique(angr.exploration_techniques.Oppologist())
-        pg.explore()
-
-        return pg
-    finally:
-        angr.engines.vex.claripy.irop.operations.update(old_ops)
-
-
-@unittest.skipIf(sys.platform == "win32", "broken on windows")
-class TestOppologist(unittest.TestCase):
-    def test_fauxware_oppologist(self):
-        p = angr.Project(os.path.join(test_location, "i386", "fauxware"))
-        s = p.factory.full_init_state(remove_options={angr.options.LAZY_SOLVES, angr.options.EXTENDED_IROP_SUPPORT})
-
-        pg = _ultra_oppologist(p, s)
-        assert len(pg.deadended) == 1
-        assert len(pg.deadended[0].posix.dumps(0)) == 18
-        stdout = pg.deadended[0].posix.dumps(1)
-        if b"trusted user" in stdout:
-            assert stdout.count(b"\n") == 3
-        else:
-            assert stdout.count(b"\n") == 2
-
-    def test_cromu_70(self):
-        p = angr.Project(os.path.join(test_location, "cgc", "CROMU_00070"))
-        inp = bytes.fromhex(
-            "030e000001000001001200010000586d616ce000000600030000040dd0000000000600000606000006030e000001000001003200010000586d616ce0030000000000030e000001000001003200010000586d616ce003000000000006000006030e000001000001003200010000586d616ce0030000df020000"
-        )
-        s = p.factory.full_init_state(
-            add_options={angr.options.UNICORN},
-            remove_options={angr.options.LAZY_SOLVES, angr.options.SUPPORT_FLOATING_POINT},
-            stdin=inp,
-        )
-
-        pg = p.factory.simulation_manager(s)
-        pg.use_technique(angr.exploration_techniques.Oppologist())
-        pg.run(n=50)
-        assert pg.one_active.history.block_count > 1500
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/exploration_techniques/test_spiller.py

@@ -1,82 +0,0 @@
-#!/usr/bin/env python3
-__package__ = __package__ or "tests.exploration_techniques"  # pylint:disable=redefined-builtin
-
-import os
-import gc
-import unittest
-
-import claripy
-
-from angr.exploration_techniques.spiller import Spiller
-import angr
-
-from ..common import bin_location
-
-
-test_location = os.path.join(bin_location, "tests")
-
-
-def _bin(*s):
-    return os.path.join(test_location, *s)
-
-
-def pickle_callback(state):
-    state.globals["pickled"] = True
-
-
-def unpickle_callback(sid, state):  # pylint:disable=unused-argument
-    state.globals["unpickled"] = True
-
-
-def priority_key(state):
-    return state.addr * state.history.depth  # to help ensure determinism
-
-
-class TestSpiller(unittest.TestCase):
-    @classmethod
-    def setUp(self):
-        # clean up AST cache in claripy, because a cached AST might believe it
-        # has been stored in ana after we clean up the ana storage
-
-        claripy.ast.bv._bvv_cache.clear()
-        claripy.ast.bv.BV._hash_cache.clear()
-
-    def test_basic(self):
-        project = angr.Project(_bin("cgc", "sc2_0b32aa01_01"), auto_load_libs=False)
-        state = project.factory.entry_state()
-        spiller = Spiller(pickle_callback=pickle_callback, unpickle_callback=unpickle_callback)
-        spiller._pickle([state])
-
-        del state
-        gc.collect()
-        state = spiller._unpickle(1)[0]
-
-        assert state.globals["pickled"]
-        assert state.globals["unpickled"]
-
-    def test_palindrome2(self):
-        project = angr.Project(_bin("cgc", "sc2_0b32aa01_01"), auto_load_libs=False)
-        pg = project.factory.simulation_manager()
-        limiter = angr.exploration_techniques.LengthLimiter(max_length=250)
-        pg.use_technique(limiter)
-
-        spiller = Spiller(
-            pickle_callback=pickle_callback, unpickle_callback=unpickle_callback, priority_key=priority_key
-        )
-        pg.use_technique(spiller)
-        # pg.step(until=lambda lpg: len(lpg.active) == 10)
-        # pg.step(until=lambda lpg: len(lpg.spill_stage) > 15)
-        # pg.step(until=lambda lpg: spiller._pickled_paths)
-        pg.run()
-
-        assert spiller._ever_pickled > 0
-        assert spiller._ever_unpickled == spiller._ever_pickled
-        assert all(
-            ("pickled" not in state.globals and "unpickled" not in state.globals)
-            or (state.globals["pickled"] and state.globals["unpickled"])
-            for state in pg.cut
-        )
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/exploration_techniques/test_stochastic.py

@@ -1,40 +0,0 @@
-#!/usr/bin/env python3
-__package__ = __package__ or "tests.exploration_techniques"  # pylint:disable=redefined-builtin
-
-import os
-import unittest
-
-import angr
-
-from ..common import bin_location
-
-test_location = os.path.join(bin_location, "tests")
-
-find = {"veritesting_a": {"x86_64": 0x40066A}}
-
-criteria = {"veritesting_a": lambda input_found: input_found.count(b"B") == 10}
-
-
-class TestRun(unittest.TestCase):
-    def _run_stochastic(self, binary, arch):
-        proj = angr.Project(os.path.join(test_location, arch, binary), auto_load_libs=False)
-        simgr = proj.factory.simulation_manager()
-        start_state = simgr.active[0]
-        technique = angr.exploration_techniques.StochasticSearch(start_state)
-        simgr.use_technique(technique)
-
-        def found(simgr):
-            return simgr.active[0].addr == find[binary][arch]
-
-        simgr.run(until=found)
-        assert simgr.active[0].addr == find[binary][arch]
-
-        input_found = simgr.active[0].posix.dumps(0)
-        assert criteria[binary](input_found)
-
-    def test_stochastic(self):
-        self._run_stochastic("veritesting_a", "x86_64")
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/exploration_techniques/test_tech_builder.py

@@ -1,61 +0,0 @@
-#!/usr/bin/env python3
-# pylint: disable=missing-class-docstring,no-self-use,line-too-long
-__package__ = __package__ or "tests.exploration_techniques"  # pylint:disable=redefined-builtin
-
-import logging
-import os
-import unittest
-
-import angr
-
-from ..common import bin_location
-
-
-test_location = os.path.join(bin_location, "tests")
-log = logging.getLogger("angr_tests.test_proxy")
-
-
-class TestTechBuilder(unittest.TestCase):
-    def test_tech_builder(self):
-        # pylint:disable=unused-argument
-        class Foo:
-            @staticmethod
-            def setup(*args, **kwargs):
-                log.debug("setup() triggered!")
-
-            @staticmethod
-            def step_state(*args, **kwargs):
-                log.debug("step_state() triggered!")
-
-            @staticmethod
-            def step(simgr, stash, *args, **kwargs):
-                log.debug("step() triggered!")
-                return simgr.step(stash=stash, **kwargs)
-
-            @staticmethod
-            def filter(*args, **kwargs):
-                log.debug("filter() triggered!")
-
-            @staticmethod
-            def complete(*args, **kwargs):
-                log.debug("complete() triggered!")
-                return True
-
-        p = angr.Project(os.path.join(test_location, "x86_64", "fauxware"), load_options={"auto_load_libs": False})
-
-        foo = Foo()
-        proxy_tech = angr.exploration_techniques.TechniqueBuilder(
-            setup=foo.setup,
-            step_state=foo.step_state,
-            step=foo.step,
-            filter=foo.filter,
-            complete=foo.complete,
-        )
-
-        pg = p.factory.simulation_manager()
-        pg.use_technique(proxy_tech)
-        pg.run()
-
-
-if __name__ == "__main__":
-    unittest.main()