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

tests/factory/test_callable.py

@@ -1,266 +0,0 @@
-#!/usr/bin/env python3
-__package__ = __package__ or "tests.factory"  # pylint:disable=redefined-builtin
-
-import os
-import unittest
-
-import claripy
-import archinfo
-
-import angr
-from angr.sim_type import SimTypePointer, SimTypeFunction, SimTypeChar, SimTypeInt, parse_defns
-from angr.errors import AngrCallableMultistateError
-
-
-from ..common import bin_location, slow_test
-
-
-test_location = os.path.join(bin_location, "tests")
-
-addresses_fauxware = {
-    "armel": 0x8524,
-    "armhf": 0x104C9,  # addr+1 to force thumb
-    "i386": 0x8048524,
-    "mips": 0x400710,
-    "mipsel": 0x4006D0,
-    "ppc": 0x1000054C,
-    "ppc64": 0x10000698,
-    "x86_64": 0x400664,
-}
-
-addresses_manysum = {
-    "armel": 0x1041C,
-    "armhf": 0x103BD,
-    "i386": 0x80483D8,
-    "mips": 0x400704,
-    "mipsel": 0x400704,
-    "ppc": 0x10000418,
-    "ppc64": 0x10000500,
-    "x86_64": 0x4004CA,
-}
-
-type_cache = None
-
-
-class TestCallable(unittest.TestCase):
-    def run_fauxware(self, arch):
-        addr = addresses_fauxware[arch]
-        p = angr.Project(os.path.join(test_location, arch, "fauxware"))
-        charstar = SimTypePointer(SimTypeChar())
-        prototype = SimTypeFunction((charstar, charstar), SimTypeInt(False))
-        authenticate = p.factory.callable(
-            addr, toc=0x10018E80 if arch == "ppc64" else None, concrete_only=True, prototype=prototype
-        )
-        assert authenticate("asdf", "SOSNEAKY").concrete_value == 1
-        self.assertRaises(AngrCallableMultistateError, authenticate, "asdf", "NOSNEAKY")
-
-    def run_callable_c_fauxware(self, arch):
-        addr = addresses_fauxware[arch]
-        p = angr.Project(os.path.join(test_location, arch, "fauxware"))
-        authenticate = p.factory.callable(
-            addr, toc=0x10018E80 if arch == "ppc64" else None, concrete_only=True, prototype="int f(char*, char*)"
-        )
-        retval = authenticate.call_c('("asdf", "SOSNEAKY")')
-        assert retval.concrete_value == 1
-
-    def run_manysum(self, arch):
-        addr = addresses_manysum[arch]
-        p = angr.Project(os.path.join(test_location, arch, "manysum"))
-        inttype = SimTypeInt()
-        prototype = SimTypeFunction([inttype] * 11, inttype)
-        sumlots = p.factory.callable(addr, prototype=prototype)
-        result = sumlots(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)
-        assert not result.symbolic
-        assert result.concrete_value == sum(range(12))
-
-    def run_callable_c_manysum(self, arch):
-        addr = addresses_manysum[arch]
-        p = angr.Project(os.path.join(test_location, arch, "manysum"))
-        sumlots = p.factory.callable(addr, prototype="int f(int, int, int, int, int, int, int, int, int, int, int)")
-        result = sumlots.call_c("(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)")
-        assert not result.symbolic
-        assert result.concrete_value == sum(range(12))
-
-    def run_manyfloatsum(self, arch):
-        global type_cache
-        if type_cache is None:
-            with open(os.path.join(bin_location, "tests_src", "manyfloatsum.c")) as fp:
-                type_cache = parse_defns(fp.read())
-
-        p = angr.Project(os.path.join(test_location, arch, "manyfloatsum"))
-        for function in (
-            "sum_floats",
-            "sum_combo",
-            "sum_segregated",
-            "sum_doubles",
-            "sum_combo_doubles",
-            "sum_segregated_doubles",
-        ):
-            args = list(range(len(type_cache[function].args)))
-            answer = float(sum(args))
-            addr = p.loader.main_object.get_symbol(function).rebased_addr
-            my_callable = p.factory.callable(addr, prototype=type_cache[function])
-            result = my_callable(*args)
-            assert not result.symbolic
-            result_concrete = result.args[0]
-            assert answer == result_concrete
-
-    @slow_test
-    def run_manyfloatsum_symbolic(self, arch):
-        global type_cache
-        if type_cache is None:
-            with open(os.path.join(bin_location, "tests_src", "manyfloatsum.c")) as fp:
-                type_cache = parse_defns(fp.read())
-
-        p = angr.Project(os.path.join(test_location, arch, "manyfloatsum"))
-        function = "sum_doubles"
-        args = [claripy.FPS("arg_%d" % i, claripy.FSORT_DOUBLE) for i in range(len(type_cache[function].args))]
-        addr = p.loader.main_object.get_symbol(function).rebased_addr
-        my_callable = p.factory.callable(addr, prototype=type_cache[function])
-        result = my_callable(*args)
-        assert result.symbolic
-
-        s = claripy.Solver(timeout=15 * 60 * 1000)
-        for arg in args:
-            s.add(arg > claripy.FPV(1.0, claripy.FSORT_DOUBLE))
-        s.add(result == claripy.FPV(27.7, claripy.FSORT_DOUBLE))
-
-        args_conc = s.batch_eval(args, 1)[0]
-        assert s.eval(result, 1)[0] == 27.7
-        # not almost equal!! totally equal!!! z3 is magic, if kinda slow!!!!!
-        for arg_conc in args_conc:
-            assert arg_conc > 1.0
-        assert sum(args_conc) == 27.7
-
-    def test_fauxware_armel(self):
-        self.run_fauxware("armel")
-
-    def test_fauxware_armhf(self):
-        self.run_fauxware("armhf")
-
-    def test_fauxware_i386(self):
-        self.run_fauxware("i386")
-
-    def test_fauxware_mips(self):
-        self.run_fauxware("mips")
-
-    def test_fauxware_mipsel(self):
-        self.run_fauxware("mipsel")
-
-    def test_fauxware_ppc(self):
-        self.run_fauxware("ppc")
-
-    def test_fauxware_ppc64(self):
-        self.run_fauxware("ppc64")
-
-    def test_fauxware_x86_64(self):
-        self.run_fauxware("x86_64")
-
-    def test_manysum_armel(self):
-        self.run_manysum("armel")
-
-    def test_manysum_armhf(self):
-        self.run_manysum("armhf")
-
-    def test_manysum_i386(self):
-        self.run_manysum("i386")
-
-    def test_manysum_mips(self):
-        self.run_manysum("mips")
-
-    def test_manysum_mipsel(self):
-        self.run_manysum("mipsel")
-
-    def test_manysum_ppc(self):
-        self.run_manysum("ppc")
-
-    def test_manysum_ppc64(self):
-        self.run_manysum("ppc64")
-
-    def test_manysum_x86_64(self):
-        self.run_manysum("x86_64")
-
-    def test_manyfloatsum_i386(self):
-        self.run_manyfloatsum("i386")
-
-    def test_manyfloatsum_x86_64(self):
-        self.run_manyfloatsum("x86_64")
-
-    @slow_test
-    def test_manyfloatsum_symbolic_i386(self):
-        # doesn't have to be slow but it might be
-        # https://github.com/Z3Prover/z3/issues/2584
-        self.run_manyfloatsum_symbolic("i386")
-
-    @slow_test
-    def test_manyfloatsum_symbolic_x86_64(self):
-        # doesn't have to be slow but it might be
-        # https://github.com/Z3Prover/z3/issues/2584
-        self.run_manyfloatsum_symbolic("x86_64")
-
-    def test_callable_c_fauxware_armel(self):
-        self.run_callable_c_fauxware("armel")
-
-    def test_callable_c_fauxware_armhf(self):
-        self.run_callable_c_fauxware("armhf")
-
-    def test_callable_c_fauxware_i386(self):
-        self.run_callable_c_fauxware("i386")
-
-    def test_callable_c_fauxware_mips(self):
-        self.run_callable_c_fauxware("mips")
-
-    def test_callable_c_fauxware_mipsel(self):
-        self.run_callable_c_fauxware("mipsel")
-
-    def test_callable_c_fauxware_ppc(self):
-        self.run_callable_c_fauxware("ppc")
-
-    def test_callable_c_fauxware_ppc64(self):
-        self.run_callable_c_fauxware("ppc64")
-
-    def test_callable_c_fauxware_x86_64(self):
-        self.run_callable_c_fauxware("x86_64")
-
-    def test_callable_c_manyfloatsum_armel(self):
-        self.run_callable_c_manysum("armel")
-
-    def test_callable_c_manyfloatsum_armhf(self):
-        self.run_callable_c_manysum("armhf")
-
-    def test_callable_c_manyfloatsum_i386(self):
-        self.run_callable_c_manysum("i386")
-
-    def test_callable_c_manyfloatsum_mips(self):
-        self.run_callable_c_manysum("mips")
-
-    def test_callable_c_manyfloatsum_mipsel(self):
-        self.run_callable_c_manysum("mipsel")
-
-    def test_callable_c_manyfloatsum_ppc(self):
-        self.run_callable_c_manysum("ppc")
-
-    def test_callable_c_manyfloatsum_ppc64(self):
-        self.run_callable_c_manysum("ppc64")
-
-    def test_callable_c_manyfloatsum_x86_64(self):
-        self.run_callable_c_manysum("x86_64")
-
-    def test_setup_callsite(self):
-        p = angr.load_shellcode(b"b", arch=archinfo.ArchX86())
-
-        s = p.factory.call_state(
-            0, "hello", prototype="void x(char*)", stack_base=0x1234, alloc_base=0x5678, grow_like_stack=False
-        )
-        assert (s.regs.sp == 0x1234).is_true()
-        assert (s.mem[0x1234 + 4].long.resolved == 0x5678).is_true()
-        assert (s.memory.load(0x5678, 5) == b"hello").is_true()
-
-        s = p.factory.call_state(0, "hello", prototype="void x(char*)", stack_base=0x1234)
-        assert (s.regs.sp == 0x1234).is_true()
-        assert (s.mem[0x1234 + 4].long.resolved == 0x1234 + 8).is_true()
-        assert (s.memory.load(0x1234 + 8, 5) == b"hello").is_true()
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/factory/test_windows_args.py

@@ -1,36 +0,0 @@
-#!/usr/bin/env python3
-# pylint: disable=missing-class-docstring,no-self-use,line-too-long
-__package__ = __package__ or "tests.factory"  # 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")
-
-
-class TestWindowsArgs(unittest.TestCase):
-    def test_i386(self):
-        after_puts = 0x40105B
-        else_paths = [0x401062, 0x401009]
-
-        p = angr.Project(os.path.join(test_location, "i386", "simple_windows.exe"), auto_load_libs=False)
-
-        s = p.factory.entry_state(args=("simple_windows.exe", "angr_can_windows?", "1497715489"))
-        simgr = p.factory.simulation_manager(s)
-        simgr.explore(find=after_puts, avoid=else_paths, num_find=10)
-
-        assert len(simgr.avoid) == 0
-        assert len(simgr.found) > 0
-        for f in simgr.found:
-            assert b"ok" in f.posix.dumps(1)
-
-
-if __name__ == "__main__":
-    logging.getLogger("angr.engines").setLevel("INFO")
-    unittest.main()

tests/knowledge_plugins/cfg/test_cfg_manager.py

@@ -1,36 +0,0 @@
-#!/usr/bin/env python3
-from unittest import main, TestCase
-
-from angr.knowledge_plugins.cfg import CFGManager
-
-
-class TestCFGManager(TestCase):
-    def setUp(self):
-        self.cfg_manager = CFGManager(None)
-
-    def test_when_both_cfg_emulated_and_cfg_fast_are_present(self):
-        self.cfg_manager["CFGEmulated"] = "fake CFGEmulated"
-        self.cfg_manager["CFGFast"] = "fake CFGFast"
-
-        result = self.cfg_manager.get_most_accurate()
-        self.assertEqual(result, "fake CFGEmulated")
-
-    def test_when_only_cfg_emulated_is_present(self):
-        self.cfg_manager["CFGEmulated"] = "fake CFGEmulated"
-
-        result = self.cfg_manager.get_most_accurate()
-        self.assertEqual(result, "fake CFGEmulated")
-
-    def test_when_only_cfg_fast_is_present(self):
-        self.cfg_manager["CFGFast"] = "fake CFGFast"
-
-        result = self.cfg_manager.get_most_accurate()
-        self.assertEqual(result, "fake CFGFast")
-
-    def test_when_no_cfg_is_present(self):
-        result = self.cfg_manager.get_most_accurate()
-        self.assertEqual(result, None)
-
-
-if __name__ == "__main__":
-    main()

tests/knowledge_plugins/functions/test_function.py

@@ -1,91 +0,0 @@
-#!/usr/bin/env python3
-from unittest import main, TestCase
-
-import networkx
-
-from angr.knowledge_plugins.functions import Function
-
-
-def makeFunction(function_manager, function_address, function_name):
-    # Fill some value that are not relevant for the tests, but help circumvent a lot of mocking.
-    f = Function(
-        function_manager,
-        function_address,
-        name=function_name,
-        syscall=False,
-        is_simprocedure=False,
-        is_plt=False,
-        binary_name="rpaulson.bin",
-        returning=True,
-    )
-    function_manager._function_map[function_address] = f
-    return f
-
-
-class MockFunctionManager:
-    def __init__(self):
-        self.callgraph = networkx.MultiDiGraph()
-        self._function_map = {}
-
-    def function(self, address):
-        return self._function_map[address]
-
-
-class TestFunction(TestCase):
-    def setUp(self):
-        self.function_manager = MockFunctionManager()
-
-    def test_functions_called_returns_all_functions_that_can_be_reached_from_the_function(self):
-        A = makeFunction(self.function_manager, 0x40, "A")
-        B = makeFunction(self.function_manager, 0x41, "B")
-        function = makeFunction(self.function_manager, 0x42, "function")
-        C = makeFunction(self.function_manager, 0x43, "C")
-        D = makeFunction(self.function_manager, 0x44, "D")
-        E = makeFunction(self.function_manager, 0x45, "E")
-
-        # A -> B
-        # function -> C -> D
-        # function -> E
-        self.function_manager.callgraph.add_edges_from(
-            [
-                (A.addr, B.addr),
-                (function.addr, C.addr),
-                (function.addr, E.addr),
-                (C.addr, D.addr),
-            ]
-        )
-
-        self.assertEqual(function.functions_called(), {C, D, E})
-
-    def test_functions_called_with_recursive_function(self):
-        recursive_function = makeFunction(self.function_manager, 0x40, "recursive_function")
-        B = makeFunction(self.function_manager, 0x41, "B")
-
-        # recursive_function -> B
-        # recursive_function -> recursive_function
-        self.function_manager.callgraph.add_edges_from(
-            [
-                (recursive_function.addr, B.addr),
-                (recursive_function.addr, recursive_function.addr),
-            ]
-        )
-
-        self.assertEqual(recursive_function.functions_called(), {recursive_function, B})
-
-    def test_functions_called_with_cyclic_dependencies(self):
-        function = makeFunction(self.function_manager, 0x42, "function")
-        C = makeFunction(self.function_manager, 0x43, "C")
-
-        # function -> C -> function
-        self.function_manager.callgraph.add_edges_from(
-            [
-                (function.addr, C.addr),
-                (C.addr, function.addr),
-            ]
-        )
-
-        self.assertEqual(function.functions_called(), {function, C})
-
-
-if __name__ == "__main__":
-    main()

tests/knowledge_plugins/functions/test_function2.py

@@ -1,79 +0,0 @@
-#!/usr/bin/env python3
-# pylint: disable=missing-class-docstring,disable=no-self-use
-__package__ = __package__ or "tests.knowledge_plugins.functions"  # pylint:disable=redefined-builtin
-
-import os
-import unittest
-
-import angr
-
-from ...common import bin_location
-
-
-test_location = os.path.join(bin_location, "tests")
-
-
-class TestFunction(unittest.TestCase):
-    def test_function_serialization(self):
-        p = angr.Project(os.path.join(test_location, "x86_64", "fauxware"), auto_load_libs=False)
-        cfg = p.analyses.CFG()
-
-        func_main = cfg.kb.functions["main"]
-        s = func_main.serialize()
-
-        assert type(s) is bytes
-        assert len(s) > 10
-
-        f = angr.knowledge_plugins.Function.parse(s)
-        assert func_main.addr == f.addr
-        assert func_main.name == f.name
-        assert func_main.is_prototype_guessed == f.is_prototype_guessed
-
-    def test_function_definition_application(self):
-        p = angr.Project(os.path.join(test_location, "x86_64", "fauxware"), auto_load_libs=False)
-        cfg = p.analyses.CFG()
-        func_main: angr.knowledge_plugins.Function = cfg.kb.functions["main"]
-
-        func_main.apply_definition("int main(int argc, char** argv)")
-
-        # Check prototype of function
-        assert func_main.prototype.args == [
-            angr.sim_type.SimTypeInt().with_arch(p.arch),
-            angr.sim_type.SimTypePointer(
-                angr.sim_type.SimTypePointer(angr.sim_type.SimTypeChar()).with_arch(p.arch)
-            ).with_arch(p.arch),
-        ]
-        # Check that the default calling convention of the architecture was applied
-        assert isinstance(func_main.calling_convention, angr.calling_conventions.DefaultCC[p.arch.name]["Linux"])
-
-        func_main.apply_definition("int main(int argc, char** argv)")
-
-    def test_function_instruction_addr_from_any_addr(self):
-        p = angr.Project(os.path.join(test_location, "x86_64", "fauxware"), auto_load_libs=False)
-        cfg = p.analyses.CFG()
-
-        func_main = cfg.kb.functions["main"]
-
-        assert func_main.addr_to_instruction_addr(0x400739) == 0x400739
-        assert func_main.addr_to_instruction_addr(0x40073A) == 0x400739
-        assert func_main.addr_to_instruction_addr(0x40073D) == 0x400739
-        assert func_main.addr_to_instruction_addr(0x400742) == 0x400742
-        assert func_main.addr_to_instruction_addr(0x400743) == 0x400742
-
-    def test_function_instruction_size(self):
-        p = angr.Project(os.path.join(test_location, "x86_64", "fauxware"), auto_load_libs=False)
-        cfg = p.analyses.CFG()
-
-        func_main = cfg.kb.functions["main"]
-
-        assert func_main.instruction_size(0x40071D) == 1
-        assert func_main.instruction_size(0x40071E) == 3
-        assert func_main.instruction_size(0x400721) == 4
-        assert func_main.instruction_size(0x400725) == 3
-        assert func_main.instruction_size(0x400728) == 4
-        assert func_main.instruction_size(0x400739) == 5
-        assert func_main.instruction_size(0x400742) == 5
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/knowledge_plugins/functions/test_function_manager.py

@@ -1,139 +0,0 @@
-#!/usr/bin/env python3
-__package__ = __package__ or "tests.knowledge_plugins.functions"  # pylint:disable=redefined-builtin
-
-import os
-import unittest
-
-from archinfo import ArchAMD64
-
-import angr
-from angr.utils.constants import DEFAULT_STATEMENT
-
-from ...common import bin_location
-
-
-test_location = os.path.join(bin_location, "tests")
-
-
-class TestFunctionManager(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        cls.project = angr.Project(os.path.join(test_location, "x86_64", "fauxware"), auto_load_libs=False)
-
-    def test_amd64(self):
-        expected_functions = {
-            0x4004E0,
-            0x400510,
-            0x400520,
-            0x400530,
-            0x400540,
-            0x400550,
-            0x400560,
-            0x400570,
-            0x400580,
-            0x4005AC,
-            0x400640,
-            0x400664,
-            0x4006ED,
-            0x4006FD,
-            0x40071D,
-            0x4007E0,
-            0x400880,
-        }
-        expected_blocks = {
-            0x40071D,
-            0x40073E,
-            0x400754,
-            0x40076A,
-            0x400774,
-            0x40078A,
-            0x4007A0,
-            0x4007B3,
-            0x4007C7,
-            0x4007C9,
-            0x4007BD,
-            0x4007D3,
-        }
-        expected_callsites = {0x40071D, 0x40073E, 0x400754, 0x40076A, 0x400774, 0x40078A, 0x4007A0, 0x4007BD, 0x4007C9}
-        expected_callsite_targets = {4195600, 4195632, 4195632, 4195600, 4195632, 4195632, 4195940, 4196077, 4196093}
-        expected_callsite_returns = {
-            0x40073E,
-            0x400754,
-            0x40076A,
-            0x400774,
-            0x40078A,
-            0x4007A0,
-            0x4007B3,
-            0x4007C7,
-            None,
-        }
-
-        self.project.analyses.CFGEmulated()
-        assert {k for k in self.project.kb.functions.keys() if k < 0x500000} == expected_functions
-
-        main = self.project.kb.functions.function(name="main")
-        assert main.startpoint.addr == 0x40071D
-        assert set(main.block_addrs) == expected_blocks
-        assert [0x4007D3] == [bl.addr for bl in main.endpoints]
-        assert set(main.get_call_sites()) == expected_callsites
-        assert set(map(main.get_call_target, main.get_call_sites())) == expected_callsite_targets
-        assert set(map(main.get_call_return, main.get_call_sites())) == expected_callsite_returns
-        assert main.has_return
-
-        rejected = self.project.kb.functions.function(name="rejected")
-        assert rejected.returning is False
-
-        # transition graph
-        main_g = main.transition_graph
-        main_g_edges_ = main_g.edges(data=True)
-
-        # Convert nodes those edges from blocks to addresses
-        main_g_edges = []
-        for src_node, dst_node, data in main_g_edges_:
-            main_g_edges.append((src_node.addr, dst_node.addr, data))
-
-        edges = [
-            (0x40071D, 0x400510, {"type": "call", "stmt_idx": DEFAULT_STATEMENT, "ins_addr": 0x400739}),
-            (0x40071D, 0x400510, {"type": "call", "stmt_idx": DEFAULT_STATEMENT, "ins_addr": 0x400739}),
-            (0x40071D, 0x40073E, {"type": "fake_return", "confirmed": True, "outside": False}),
-            (0x40073E, 0x400530, {"type": "call", "stmt_idx": DEFAULT_STATEMENT, "ins_addr": 0x40074F}),
-            (0x40073E, 0x400754, {"type": "fake_return", "confirmed": True, "outside": False}),
-            # rejected() does not return
-            (0x4007C9, 0x4006FD, {"type": "call", "stmt_idx": DEFAULT_STATEMENT, "ins_addr": 0x4007CE}),
-            (0x4007C9, 0x4007D3, {"type": "fake_return", "outside": False}),
-        ]
-        for edge in edges:
-            assert edge in main_g_edges
-
-        # These tests fail for reasons of fastpath, probably
-        # assert main.bp_on_stack
-        # assert main.name == 'main'
-        # assert main.retaddr_on_stack
-        # assert 0x50 == main.sp_difference
-
-        # TODO: Check the result returned
-        # func_man.dbg_draw()
-
-    def test_call_to(self):
-        self.project.arch = ArchAMD64()
-
-        self.project.kb.functions._add_call_to(0x400000, 0x400410, 0x400420, 0x400414)
-        assert 0x400000 in self.project.kb.functions.keys()
-        assert 0x400420 in self.project.kb.functions.keys()
-
-    def test_query(self):
-        bin_path = os.path.join(test_location, "x86_64", "fauxware")
-        proj = angr.Project(bin_path, auto_load_libs=False)
-        proj.analyses.CFGFast(normalize=True, data_references=True)
-
-        assert proj.kb.functions["::read"].addr == 0x400530
-        assert proj.kb.functions["::0x400530::read"].addr == 0x400530
-        assert proj.kb.functions["::libc.so.0::read"].addr == 0x700010
-        with self.assertRaises(KeyError):
-            proj.kb.functions["::0x400531::read"]  # pylint:disable=pointless-statement
-        with self.assertRaises(KeyError):
-            proj.kb.functions["::bad::read"]  # pylint:disable=pointless-statement
-
-
-if __name__ == "__main__":
-    unittest.main()