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

tests/procedures/test_stub_procedure_args.py

@@ -1,53 +0,0 @@
-#!/usr/bin/env python3
-# pylint: disable=missing-class-docstring,no-self-use,line-too-long
-__package__ = __package__ or "tests.procedures"  # pylint:disable=redefined-builtin
-
-import os
-import unittest
-
-import archinfo
-
-import angr
-from angr.procedures.definitions.user32 import lib
-from angr.sim_type import SimTypeFunction, SimTypeInt, SimTypePointer, SimTypeChar
-from angr.engines.successors import SimSuccessors
-from angr.calling_conventions import SimCCStdcall, SimStackArg
-
-from ..common import bin_location
-
-
-test_location = os.path.join(bin_location, "tests")
-
-
-class TestStubProcedureArgs(unittest.TestCase):
-    def test_stub_procedure_args(self):
-        # stub procedures should have the right number of arguments
-
-        lib.set_prototype(
-            "____a_random_stdcall_function__",
-            SimTypeFunction(
-                [SimTypeInt(signed=True), SimTypeInt(signed=True), SimTypeInt(signed=False)],
-                SimTypePointer(SimTypeChar(), offset=0),
-                arg_names=["_random_arg_0", "_random_arg_1", "_random_arg_2"],
-            ),
-        )
-        stub = lib.get_stub("____a_random_stdcall_function__", archinfo.ArchX86())
-        stub.cc = SimCCStdcall(archinfo.ArchX86())
-        lib._apply_metadata(stub, archinfo.ArchX86())
-        assert len(stub.prototype.args) == 3
-        assert all(isinstance(arg, SimStackArg) for arg in stub.cc.arg_locs(stub.prototype))
-
-        proj = angr.Project(os.path.join(test_location, "i386", "all"), auto_load_libs=False)
-        state = proj.factory.blank_state()
-
-        initial_sp = state.regs.sp
-        stub.state = state
-        stub.successors = SimSuccessors(0, state)
-        stub.ret(0)
-
-        succ = stub.successors.all_successors[0]
-        assert state.solver.eval_one(succ.regs.sp - initial_sp) == 0x10
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/serialization/test_db.py

@@ -1,197 +0,0 @@
-#!/usr/bin/env python3
-# pylint: disable=missing-class-docstring,disable=no-self-use
-__package__ = __package__ or "tests.serialization"  # pylint:disable=redefined-builtin
-
-import os
-import tempfile
-import shutil
-import unittest
-
-import angr
-from angr.angrdb import AngrDB
-
-from ..common import bin_location
-
-
-test_location = os.path.join(bin_location, "tests")
-
-
-class TestDb(unittest.TestCase):
-    def test_angrdb_fauxware(self):
-        bin_path = os.path.join(test_location, "x86_64", "fauxware")
-
-        proj = angr.Project(bin_path, auto_load_libs=False)
-        cfg: angr.analyses.CFGFast = proj.analyses.CFGFast(data_references=True, cross_references=True, normalize=True)
-        proj.kb.comments[proj.entry] = "Entry point"
-
-        dtemp = tempfile.mkdtemp()
-        db_file = os.path.join(dtemp, "fauxware.adb")
-
-        db = AngrDB(proj)
-        db.dump(db_file)
-
-        db1 = AngrDB()
-        new_proj = db1.load(db_file)
-
-        assert len(new_proj.kb.cfgs["CFGFast"].nodes()) == len(cfg.model.nodes())
-        assert len(new_proj.kb.functions) == len(proj.kb.functions)
-
-        # compare each function
-        for func in proj.kb.functions.values():
-            new_func = new_proj.kb.functions[func.addr]
-
-            assert func.addr == new_func.addr
-            assert func.normalized == new_func.normalized
-
-            assert len(func.transition_graph.nodes()) == len(new_func.transition_graph.nodes())
-            assert set(map(lambda x: x.addr, func.transition_graph.nodes())) == set(
-                map(lambda x: x.addr, new_func.transition_graph.nodes())
-            )
-            assert len(func.transition_graph.edges()) == len(new_func.transition_graph.edges())
-
-        # compare call graph
-        callgraph_nodes_old = set(proj.kb.callgraph.nodes)
-        callgraph_nodes_new = set(new_proj.kb.callgraph.nodes)
-        callgraph_edges_old = set(proj.kb.callgraph.edges)
-        callgraph_edges_new = set(new_proj.kb.callgraph.edges)
-
-        assert callgraph_nodes_old == callgraph_nodes_new
-        assert callgraph_edges_old == callgraph_edges_new
-
-        # compare CFG
-        new_cfg = new_proj.kb.cfgs["CFGFast"]
-        for node in cfg.model.nodes():
-            new_node = new_cfg.get_any_node(node.addr)
-
-            assert new_node.addr == node.addr
-            assert new_node.size == node.size
-
-        # compare memory data
-        for addr, memory_data in cfg.model.memory_data.items():
-            new_memory_data = new_cfg.memory_data[addr]
-
-            assert memory_data.addr == new_memory_data.addr
-            assert memory_data.size == new_memory_data.size
-            assert memory_data.reference_size == new_memory_data.reference_size
-            assert memory_data.sort == new_memory_data.sort
-            assert memory_data.content == new_memory_data.content
-
-        assert cfg.model.insn_addr_to_memory_data.keys() == new_cfg.insn_addr_to_memory_data.keys()
-
-        # comments
-        for addr, comment in proj.kb.comments.items():
-            new_comment = new_proj.kb.comments.get(addr, None)
-
-            assert comment == new_comment
-
-    def test_angrdb_open_multiple_times(self):
-        bin_path = os.path.join(test_location, "x86_64", "fauxware")
-
-        proj = angr.Project(bin_path, auto_load_libs=False)
-        _: angr.analyses.CFGFast = proj.analyses.CFGFast(data_references=True, cross_references=True, normalize=True)
-        proj.kb.comments[proj.entry] = "Entry point"
-
-        dtemp = tempfile.mkdtemp()
-        db_file = os.path.join(dtemp, "fauxware.adb")
-
-        db = AngrDB(proj)
-        db.dump(db_file)
-
-        # attempt 0
-        db0 = AngrDB()
-        proj0 = db0.load(db_file)
-
-        # attempt 1
-        db1 = AngrDB()
-        proj1 = db1.load(db_file)
-
-        # attempt 2
-        db2 = AngrDB()
-        proj2 = db2.load(db_file)
-
-        # attempt 3
-        db3 = AngrDB()
-        proj3 = db3.load(db_file)
-
-        # compare functions
-        for func in proj.kb.functions.values():
-            for p in [proj0, proj1, proj2, proj3]:
-                new_func = p.kb.functions[func.addr]
-
-                assert func.addr == new_func.addr
-                assert func.normalized == new_func.normalized
-
-                assert len(func.transition_graph.nodes()) == len(new_func.transition_graph.nodes())
-                assert set(map(lambda x: x.addr, func.transition_graph.nodes())) == set(
-                    map(lambda x: x.addr, new_func.transition_graph.nodes())
-                )
-                assert len(func.transition_graph.edges()) == len(new_func.transition_graph.edges())
-
-    def test_angrdb_save_multiple_times(self):
-        bin_path = os.path.join(test_location, "x86_64", "fauxware")
-
-        proj = angr.Project(bin_path, auto_load_libs=False)
-        _: angr.analyses.CFGFast = proj.analyses.CFGFast(data_references=True, cross_references=True, normalize=True)
-        proj.kb.comments[proj.entry] = "Entry point"
-
-        dtemp = tempfile.mkdtemp()
-        db_file = os.path.join(dtemp, "fauxware.adb")
-
-        # attempt 0
-        db = AngrDB(proj)
-        db.dump(db_file)
-
-        # attempt 1
-        proj0 = AngrDB().load(db_file)
-        assert proj0.kb.comments[proj.entry] == "Entry point"
-        proj0.kb.comments[proj.entry] = "Comment 0"
-        AngrDB(proj0).dump(db_file)
-
-        # attempt 2
-        proj1 = AngrDB().load(db_file)
-        assert proj1.kb.comments[proj.entry] == "Comment 0"
-        proj1.kb.comments[proj.entry] = "Comment 1"
-        AngrDB(proj1).dump(db_file)
-
-        # attempt 3
-        proj1 = AngrDB().load(db_file)
-        assert proj1.kb.comments[proj.entry] == "Comment 1"
-        proj1.kb.comments[proj.entry] = "Comment 22222222222222222222222"
-        AngrDB(proj1).dump(db_file)
-
-        # attempt 4
-        proj1 = AngrDB().load(db_file)
-        assert proj1.kb.comments[proj.entry] == "Comment 22222222222222222222222"
-
-    def test_angrdb_save_without_binary_existence(self):
-        bin_path = os.path.join(test_location, "x86_64", "fauxware")
-
-        with tempfile.TemporaryDirectory() as td:
-            db_file = os.path.join(td, "proj.adb")
-
-            with tempfile.TemporaryDirectory() as td0:
-                tmp_path = os.path.join(td0, os.path.basename(bin_path))
-                shutil.copy(bin_path, tmp_path)
-                proj = angr.Project(tmp_path, auto_load_libs=False)
-
-                AngrDB(proj).dump(db_file)
-
-                del proj
-                os.remove(tmp_path)
-
-            # now that the binary file no longer exists, we should be able to open the angr DB and save it without
-            # raising exceptions.
-
-            proj = AngrDB().load(db_file)
-            os.remove(db_file)
-
-            db_file_new = os.path.join(td, "proj_new.adb")
-            AngrDB(proj).dump(db_file_new)
-
-            # we should be able to load it back!
-            proj_new = AngrDB().load(db_file_new)
-            assert os.path.basename(proj_new.loader.main_object.binary) == "fauxware"
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/serialization/test_pickle.py

@@ -1,95 +0,0 @@
-#!/usr/bin/env python3
-__package__ = __package__ or "tests.serialization"  # pylint:disable=redefined-builtin
-
-from contextlib import suppress
-import gc
-import os
-import pickle
-import shutil
-import unittest
-
-from claripy import BVS
-
-import angr
-from angr.storage import SimFile
-
-from ..common import bin_location
-
-
-test_location = os.path.join(bin_location, "tests")
-
-
-class TestPickle(unittest.TestCase):
-    @classmethod
-    def tearDown(self):
-        shutil.rmtree("pickletest", ignore_errors=True)
-        shutil.rmtree("pickletest2", ignore_errors=True)
-        with suppress(FileNotFoundError):
-            os.remove("pickletest_good")
-        with suppress(FileNotFoundError):
-            os.remove("pickletest_bad")
-
-    def _load_pickles(self):
-        # This is the working case
-        f = open("pickletest_good", "rb")
-        f.close()
-
-        # This will not work
-        f = open("pickletest_bad", "rb")
-        f.close()
-
-    def _make_pickles(self):
-        p = angr.Project(os.path.join(test_location, "i386", "fauxware"))
-
-        fs = {
-            "/dev/stdin": SimFile("/dev/stdin"),
-            "/dev/stdout": SimFile("/dev/stdout"),
-            "/dev/stderr": SimFile("/dev/stderr"),
-        }
-
-        MEM_SIZE = 1024
-        mem_bvv = {}
-        for f in fs:
-            mem = BVS(f, MEM_SIZE * 8)
-            mem_bvv[f] = mem
-
-        f = open("pickletest_good", "wb")
-        pickle.dump(mem_bvv, f, -1)
-        f.close()
-
-        # If you do not have a state you cannot write
-        _ = p.factory.entry_state(fs=fs)
-        for f in fs:
-            mem = mem_bvv[f]
-            fs[f].write(0, mem, MEM_SIZE)
-
-        f = open("pickletest_bad", "wb")
-        pickle.dump(mem_bvv, f, -1)
-        f.close()
-
-    def test_pickling(self):
-        self._make_pickles()
-        self._load_pickles()
-        gc.collect()
-        self._load_pickles()
-
-    def test_project_pickling(self):
-        # AnalysesHub should not be pickled together with the project itself
-        p = angr.Project(os.path.join(test_location, "i386", "fauxware"))
-
-        # make a copy of the active_preset so that we do not touch the global preset object. this is only for writing
-        # this test case.
-        p.analyses._active_preset = pickle.loads(pickle.dumps(p.analyses._active_preset, -1))
-        assert len(p.analyses._active_preset._default_plugins) > 0
-        p.analyses._active_preset = p.analyses._active_preset
-        p.analyses._active_preset._default_plugins = {}
-        assert len(p.analyses._active_preset._default_plugins) == 0
-
-        s = pickle.dumps(p, -1)
-
-        p1 = pickle.loads(s)
-        assert len(p1.analyses._active_preset._default_plugins) > 0
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/serialization/test_serialization.py

@@ -1,132 +0,0 @@
-#!/usr/bin/env python3
-# pylint: disable=missing-class-docstring,no-self-use,line-too-long
-__package__ = __package__ or "tests.serialization"  # pylint:disable=redefined-builtin
-
-import gc
-import os
-import pickle
-import shutil
-import tempfile
-import unittest
-
-import angr
-
-from ..common import bin_location
-
-test_location = os.path.join(bin_location, "tests")
-
-internaltest_files = [
-    "argc_decide",
-    "argc_symbol",
-    "argv_test",
-    "counter",
-    "fauxware",
-    "fauxware.idb",
-    "manysum",
-    "pw",
-    "strlen",
-    "test_arrays",
-    "test_division",
-    "test_loops",
-]
-internaltest_arch = ["i386", "armel"]
-
-
-def internaltest_vfg(p, cfg):
-    vfg = p.analyses.VFG(cfg=cfg)
-    v = angr.vaults.VaultDict()
-    state = v.dumps(vfg)
-    vfg2 = v.loads(state)
-    assert vfg.final_states == vfg2.final_states
-    assert set(vfg.graph.nodes()) == set(vfg2.graph.nodes())
-
-
-def internaltest_cfg(p):
-    state = tempfile.TemporaryFile()
-
-    cfg = p.analyses.CFGEmulated()
-    pickle.dump(cfg, state, -1)
-
-    state.seek(0)
-    cfg2 = pickle.load(state)
-    assert set(cfg.model.nodes()) == set(cfg2.model.nodes())
-    assert cfg.unresolvables == cfg2.unresolvables
-    assert set(cfg.deadends) == set(cfg2.deadends)
-
-    return cfg
-
-
-def internaltest_cfgfast(p):
-    state = tempfile.TemporaryFile()
-
-    cfg = p.analyses.CFGFast()
-
-    # generate capstone blocks
-    main_function = cfg.functions.function(name="main")
-    for b in main_function.blocks:
-        _ = b.capstone
-
-    pickle.dump(cfg, state, -1)
-
-    state.seek(0)
-    cfg2 = pickle.load(state)
-    assert set(cfg.model.nodes()) == set(cfg2.model.nodes())
-
-
-def internaltest_project(fpath):
-    tpath = tempfile.mktemp()
-    shutil.copy(fpath, tpath)
-
-    p = angr.Project(tpath, auto_load_libs=False)
-    state = pickle.dumps(p, -1)
-    loaded_p = pickle.loads(state)
-    assert p is not loaded_p
-    assert p.arch == loaded_p.arch
-    assert p.filename == loaded_p.filename
-    assert p.entry == loaded_p.entry
-
-    simgr = loaded_p.factory.simulation_manager()
-    simgr.run(n=10)
-    assert len(simgr.errored) == 0
-
-
-class TestSerialization(unittest.TestCase):
-    def test_analyses(self):
-        p = angr.Project(os.path.join(test_location, "i386", "fauxware"), load_options={"auto_load_libs": False})
-        cfg = p.analyses.CFG()
-        cfb = p.analyses.CFB(kb=cfg.kb)
-        vrf = p.analyses.VariableRecoveryFast(p.kb.functions["main"])
-
-        assert len(p.kb.functions) > 0
-        assert len(pickle.loads(pickle.dumps(p.kb, -1)).functions) > 0
-
-        state = pickle.dumps((p, cfg, cfb, vrf), -1)
-        del p
-        del cfg
-        del cfb
-        del vrf
-
-        gc.collect()
-
-        p, cfg, cfb, vrf = pickle.loads(state)
-        assert p.kb is not None
-        assert p.kb.functions is not None
-        assert cfg.kb is not None
-        assert len(p.kb.functions) > 0
-
-    def test_serialization(self):
-        for d in internaltest_arch:
-            for f in internaltest_files:
-                fpath = os.path.join(test_location, d, f)
-                if os.path.isfile(fpath) and os.access(fpath, os.X_OK):
-                    internaltest_project(fpath)
-
-        p = angr.Project(os.path.join(test_location, "i386", "fauxware"), load_options={"auto_load_libs": False})
-        internaltest_cfgfast(p)
-
-        cfg = internaltest_cfg(p)
-        internaltest_vfg(p, cfg)
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/serialization/test_vault.py

@@ -1,169 +0,0 @@
-#!/usr/bin/env python3
-__package__ = __package__ or "tests.serialization"  # pylint:disable=redefined-builtin
-
-import os
-import unittest
-
-import claripy
-import angr
-
-from ..common import bin_location
-
-
-class A:
-    n = 0
-
-
-class TestVault(unittest.TestCase):
-    def _do_vault_identity(self, v_factory):
-        v = v_factory()
-        v.uuid_dedup.add(A)
-        assert len(v.keys()) == 0
-
-        a = A()
-        b = A()
-        b.n = 1
-        c = A()
-        c.n = 2
-
-        aid = v.store(a)
-        assert len(v.keys()) == 1, "Current keys: %s" % v.keys()
-        bid = v.store(b)
-        assert len(v.keys()) == 2
-        cid = v.store(c)
-        assert len(v.keys()) == 3
-
-        aa = v.load(aid)
-        bb = v.load(bid)
-        cc = v.load(cid)
-
-        assert aa is a
-        assert bb is b
-        assert cc is c
-
-        bb.n = 1337
-        del bb
-        del b
-        import gc
-
-        gc.collect()
-        bbb = v.load(bid)
-        assert bbb.n == 1
-
-    def _do_vault_noidentity(self, v_factory):
-        v = v_factory()
-        assert len(v.keys()) == 0
-
-        a = A()
-        b = A()
-        b.n = 1
-        c = A()
-        c.n = 2
-
-        aid = v.store(a)
-        assert len(v.keys()) == 1, "Current keys: %s" % v.keys()
-        bid = v.store(b)
-        assert len(v.keys()) == 2
-        cid = v.store(c)
-        assert len(v.keys()) == 3
-
-        aa = v.load(aid)
-        bb = v.load(bid)
-        cc = v.load(cid)
-
-        assert aa is not a
-        assert bb is not b
-        assert cc is not c
-
-        v.store(aa)
-        assert len(v.keys()) == 4
-        v.store(bb)
-        assert len(v.keys()) == 5
-        v.store(cc)
-        assert len(v.keys()) == 6
-
-    def _do_ast_vault(self, v_factory):
-        v = v_factory()
-        x = claripy.BVS("x", 32)
-        y = claripy.BVS("y", 32)
-        z = x + y
-
-        v.store(x)
-        assert len(v.keys()) == 1
-        zid = v.store(z)
-        assert len(v.keys()) == 3
-        zz = v.load(zid)
-        assert z is zz
-
-        zs = v.dumps(z)
-        zzz = v.loads(zs)
-        assert zzz is z
-
-    def test_vault_noidentity_VaultDir(self):
-        self._do_vault_noidentity(angr.vaults.VaultDir)
-
-    def test_vault_noidentity_VaultShelf(self):
-        self._do_vault_noidentity(angr.vaults.VaultShelf)
-
-    def test_vault_noidentity_VaultDict(self):
-        self._do_vault_noidentity(angr.vaults.VaultDict)
-
-    def test_vault_noidentity_VaultDirShelf(self):
-        self._do_vault_noidentity(angr.vaults.VaultDirShelf)
-
-    def test_vault_identity_VaultDir(self):
-        self._do_vault_identity(angr.vaults.VaultDir)
-
-    def test_vault_identity_VaultShelf(self):
-        self._do_vault_identity(angr.vaults.VaultShelf)
-
-    def test_vault_identity_VaultDict(self):
-        self._do_vault_identity(angr.vaults.VaultDict)
-
-    @unittest.expectedFailure
-    def test_vault_identity_VaultDirShelf(self):
-        # VaultDirShelf does not guarantee identity equivalence due to the absence of caching
-        self._do_vault_identity(angr.vaults.VaultDirShelf)
-
-    def test_ast_vault_do_ast_vault_VaultDir(self):
-        self._do_ast_vault(angr.vaults.VaultDir)
-
-    def test_ast_vault_do_ast_vault_VaultShelf(self):
-        self._do_ast_vault(angr.vaults.VaultShelf)
-
-    def test_ast_vault_do_ast_vault_VaultDict(self):
-        self._do_ast_vault(angr.vaults.VaultDict)
-
-    @unittest.expectedFailure
-    def test_ast_vault_VaultDirShelf(self):
-        # VaultDirShelf does not guarantee identity equivalence due to the absence of caching
-        self._do_ast_vault(angr.vaults.VaultDirShelf)
-
-    def test_project(self):
-        v = angr.vaults.VaultDir()
-        p = angr.Project(os.path.join(bin_location, "tests", "x86_64", "fauxware"), auto_load_libs=False)
-        ps = v.store(p)
-        pp = v.load(ps)
-        assert p is pp
-        assert sum(1 for k in v.keys() if k.startswith("Project")) == 1
-
-        pstring = v.dumps(p)
-        assert sum(1 for k in v.keys() if k.startswith("Project")) == 1
-        pp2 = v.loads(pstring)
-        assert sum(1 for k in v.keys() if k.startswith("Project")) == 1
-        assert p is pp
-
-        p._asdf = "fdsa"
-        del pp2
-        del pp
-        del p
-        import gc
-
-        gc.collect()
-
-        v.load(ps)
-        assert sum(1 for k in v.keys() if k.startswith("Project")) == 1
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/sim/__init__.py

@@ -1,3 +0,0 @@
-"""
-Tests related to execution.
-"""