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

tests/analyses/cfg/test_noop_blocks.py

@@ -1,54 +0,0 @@
-#!/usr/bin/env python3
-# pylint: disable=missing-class-docstring,no-self-use,line-too-long
-
-import unittest
-
-import archinfo
-
-import angr
-from angr.analyses.cfg import CFGBase
-
-
-class TestNoopBlocks(unittest.TestCase):
-    def test_x86_noop_blocks(self):
-        # nop
-        arch = archinfo.arch_from_id("x86")
-        b = b"\x90\x90\x90\x90\x90\x90\x90\x90"
-        p = angr.load_shellcode(b, arch, load_address=0x400000)
-        block = p.factory.block(0x400000, opt_level=1, cross_insn_opt=False)
-        assert CFGBase._is_noop_block(arch, block) is True
-        block = p.factory.block(0x400000, opt_level=1, cross_insn_opt=True)
-        assert CFGBase._is_noop_block(arch, block) is True
-
-    def test_amd64_noop_blocks(self):
-        # nop
-        arch = archinfo.arch_from_id("amd64")
-        b = b"\x90\x90\x90\x90\x90\x90\x90\x90"
-        p = angr.load_shellcode(b, arch, load_address=0x400000)
-        block = p.factory.block(0x400000, opt_level=1, cross_insn_opt=False)
-        assert CFGBase._is_noop_block(arch, block) is True
-        block = p.factory.block(0x400000, opt_level=1, cross_insn_opt=True)
-        assert CFGBase._is_noop_block(arch, block) is True
-
-    def test_arm_noop_blocks(self):
-        arch = archinfo.arch_from_id("ARMEL")
-
-        # andeq r0, r0, r0
-        b = b"\x00\x00\x00\x00\x00\x00\x00\x00"
-        p = angr.load_shellcode(b, arch, load_address=0x400000)
-        block = p.factory.block(0x400000, opt_level=1, cross_insn_opt=False)
-        assert CFGBase._is_noop_block(arch, block) is True
-        block = p.factory.block(0x400000, opt_level=1, cross_insn_opt=True)
-        assert CFGBase._is_noop_block(arch, block) is True
-
-        # mov r0, r0
-        b = b"\x00\x00\xa0\xe1"
-        p = angr.load_shellcode(b, arch, load_address=0x400000)
-        block = p.factory.block(0x400000, opt_level=1, cross_insn_opt=False)
-        assert CFGBase._is_noop_block(arch, block) is True
-        block = p.factory.block(0x400000, opt_level=1, cross_insn_opt=True)
-        assert CFGBase._is_noop_block(arch, block) is True
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/analyses/cfg_slice_to_sink/test_cfg_slice_to_sink.py

@@ -1,93 +0,0 @@
-#!/usr/bin/env python3
-import os
-import unittest
-
-from angr.analyses.cfg_slice_to_sink import CFGSliceToSink
-from angr.project import Project
-
-
-class TestCFGSliceToSink(unittest.TestCase):
-    def test_get_transitions_from_slice(self):
-        transitions = {1: [2, 3]}
-        my_slice = CFGSliceToSink(None, transitions)
-
-        self.assertDictEqual(my_slice.transitions, transitions)
-
-    def test_get_entrypoints_from_slice(self):
-        transitions = {0: [2], 1: [2, 3], 2: [4, 5]}
-        my_slice = CFGSliceToSink(None, transitions)
-
-        self.assertListEqual(my_slice.entrypoints, [0, 1])
-
-    def test_add_transitions_updates_the_slice(self):
-        my_slice = CFGSliceToSink(None, {1: [2, 3]})
-        transitions_to_add = {1: [4], 2: [4]}
-
-        result = my_slice.add_transitions(transitions_to_add)
-
-        expected_result = {
-            1: [2, 3, 4],
-            2: [4],
-        }
-
-        self.assertDictEqual(result, expected_result)
-
-    def test_nodes(self):
-        my_slice = CFGSliceToSink(
-            None,
-            {
-                1: [2, 3],
-                2: [3],
-            },
-        )
-
-        expected_result = [1, 2, 3]
-        result = my_slice.nodes
-
-        self.assertListEqual(result, expected_result)
-
-    def test_transitions_as_tuples(self):
-        my_slice = CFGSliceToSink(None, {1: [2, 3], 2: [3]})
-
-        expected_result = [(1, 2), (1, 3), (2, 3)]
-        result = my_slice.transitions_as_tuples
-
-        self.assertListEqual(result, expected_result)
-
-    def disable_emptyness(self):
-        # disabled since binaries-private is not checked out for angr CI
-        binaries_path = os.path.join(
-            os.path.dirname(__file__), "..", "..", "..", "..", "binaries-private", "operation-mango"
-        )
-        binary_path = os.path.join(binaries_path, "air-live-bu-2015", "cgi_test.cgi")
-        project = Project(binary_path, auto_load_libs=False)
-        cfg = project.analyses.CFGFast()
-        printf = cfg.kb.functions.function(name="printf", plt=False)
-        printf_node = cfg.model.get_all_nodes(printf.addr)[0]
-
-        printf_predecessor = printf_node.predecessors[0]
-
-        empty_slice = CFGSliceToSink(printf, {})
-        non_empty_slice = CFGSliceToSink(printf, {printf_predecessor.addr: [printf.addr]})
-
-        self.assertEqual(empty_slice.is_empty(), True)
-        self.assertEqual(non_empty_slice.is_empty(), False)
-
-    def test_path_between_returns_True_only_if_there_exists_at_least_a_path_between_two_nodes_in_the_slice(self):
-        my_slice = CFGSliceToSink(None, {1: [2, 3], 2: [4]})
-
-        self.assertTrue(my_slice.path_between(1, 2))
-        self.assertTrue(my_slice.path_between(1, 3))
-        self.assertTrue(my_slice.path_between(2, 4))
-        self.assertTrue(my_slice.path_between(1, 4))
-
-        self.assertFalse(my_slice.path_between(3, 4))
-
-    def test_path_between_deals_with_loops(self):
-        my_slice = CFGSliceToSink(None, {1: [2, 3], 2: [1]})
-
-        self.assertFalse(my_slice.path_between(1, 4))
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/analyses/cfg_slice_to_sink/test_graph.py

@@ -1,114 +0,0 @@
-#!/usr/bin/env python3
-import networkx
-import unittest
-
-from angr.analyses.cfg_slice_to_sink import CFGSliceToSink, slice_callgraph, slice_cfg_graph, slice_function_graph
-
-
-class _MockCFGNode:
-    def __init__(self, addr):
-        self.addr = addr
-
-    def __repr__(self):
-        return "%s" % self.addr
-
-
-def _a_graph_and_its_nodes():
-    # Build the following graph (addresses displayed):
-    # 0 -> 1, 1 -> 2, 0 -> 3
-    graph = networkx.DiGraph()
-    nodes = list(map(_MockCFGNode, range(4)))
-    graph.add_edge(nodes[0], nodes[1])
-    graph.add_edge(nodes[1], nodes[2])
-    graph.add_edge(nodes[0], nodes[3])
-    return (graph, nodes)
-
-
-class TestGraph(unittest.TestCase):
-    def test_slice_callgraph_remove_content_not_in_a_cfg_slice_to_sink(self):
-        my_callgraph, nodes = _a_graph_and_its_nodes()
-
-        # Let's imagine a node (0x42), not a function entry point, not in my_callgraph, such as:
-        # 1 -> 0x42, 0x42 -> 2
-        transitions = {nodes[0]: [nodes[1]], nodes[1]: [0x42], 0x42: [nodes[2]]}
-        cfg_slice_to_sink = CFGSliceToSink(None, transitions)
-
-        sliced_callgraph = slice_callgraph(my_callgraph, cfg_slice_to_sink)
-
-        result_nodes = list(sliced_callgraph.nodes)
-        result_edges = list(sliced_callgraph.edges)
-
-        self.assertListEqual(result_nodes, [nodes[0], nodes[1], nodes[2]])
-        self.assertListEqual(result_edges, [(nodes[0], nodes[1]), (nodes[1], nodes[2])])
-
-    def test_slice_callgraph_mutates_the_original_graph(self):
-        my_callgraph, nodes = _a_graph_and_its_nodes()
-
-        # Let's imagine a node (0x42), not a function entry point, not in my_callgraph, such as:
-        # 1 -> 0x42, 0x42 -> 2
-        transitions = {nodes[0]: [nodes[1]], nodes[1]: [0x42], 0x42: [nodes[2]]}
-        cfg_slice_to_sink = CFGSliceToSink(None, transitions)
-
-        sliced_callgraph = slice_callgraph(my_callgraph, cfg_slice_to_sink)
-
-        self.assertEqual(len(my_callgraph.nodes), 3)
-        self.assertEqual(len(my_callgraph.edges), 2)
-        self.assertEqual(my_callgraph, sliced_callgraph)
-
-    def test_slice_cfg_graph_remove_content_not_in_a_cfg_slice_to_sink(self):
-        my_graph, nodes = _a_graph_and_its_nodes()
-
-        transitions = {nodes[0].addr: [nodes[1].addr], nodes[1].addr: [nodes[2].addr]}
-        my_slice = CFGSliceToSink(None, transitions)
-
-        sliced_graph = slice_cfg_graph(my_graph, my_slice)
-        result_nodes = list(sliced_graph.nodes)
-        result_edges = list(sliced_graph.edges)
-
-        self.assertListEqual(result_nodes, [nodes[0], nodes[1], nodes[2]])
-        self.assertListEqual(result_edges, [(nodes[0], nodes[1]), (nodes[1], nodes[2])])
-
-    def test_slice_cfg_graph_mutates_the_original_graph(self):
-        my_graph, nodes = _a_graph_and_its_nodes()
-
-        transitions = {nodes[0].addr: [nodes[1].addr]}
-        my_slice = CFGSliceToSink(None, transitions)
-
-        sliced_graph = slice_cfg_graph(my_graph, my_slice)
-
-        self.assertEqual(len(my_graph.nodes), 2)
-        self.assertEqual(len(my_graph.edges), 1)
-        self.assertEqual(my_graph, sliced_graph)
-
-    def test_slice_function_graph_remove_nodes_not_in_a_cfg_slice_to_sink(self):
-        # Imagine a CFG being:    0 -> 0x42, 0x42 -> 1, 1 -> 2, 0 -> 3
-        # And the function graph: 0 -> 1, 1 -> 2, 0 -> 3
-        my_function_graph, nodes = _a_graph_and_its_nodes()
-
-        transitions = {nodes[0].addr: [0x42], 0x42: [nodes[1].addr]}
-        my_slice = CFGSliceToSink(None, transitions)
-
-        sliced_function_graph = slice_function_graph(my_function_graph, my_slice)
-        result_nodes = list(sliced_function_graph.nodes)
-        result_edges = list(sliced_function_graph.edges)
-
-        self.assertListEqual(result_nodes, [nodes[0], nodes[1]])
-        self.assertListEqual(result_edges, [(nodes[0], nodes[1])])
-
-    def test_slice_function_graph_mutates_the_original_function_graph(self):
-        # Imagine a CFG being:    0 -> 0x42, 0x42 -> 1, 1 -> 2, 0 -> 3
-        # And the function graph: 0 -> 1, 1 -> 2, 0 -> 3
-        my_function_graph, nodes = _a_graph_and_its_nodes()
-
-        transitions = {nodes[0].addr: [0x42], 0x42: [nodes[1].addr]}
-        my_slice = CFGSliceToSink(None, transitions)
-
-        sliced_function_graph = slice_function_graph(my_function_graph, my_slice)
-
-        self.assertEqual(len(my_function_graph.nodes), 2)
-        self.assertEqual(len(my_function_graph.edges), 1)
-        self.assertEqual(my_function_graph, sliced_function_graph)
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/analyses/cfg_slice_to_sink/test_transitions.py

@@ -1,28 +0,0 @@
-#!/usr/bin/env python3
-import unittest
-
-from angr.analyses.cfg_slice_to_sink.transitions import merge_transitions
-
-
-class TestTrasitions(unittest.TestCase):
-    def test_merge_transitions(self):
-        t1 = {1: [2, 3]}
-        t2 = {2: [4]}
-
-        result = merge_transitions(t1, t2)
-        expected_result = {1: [2, 3], 2: [4]}
-
-        self.assertEqual(result, expected_result)
-
-    def test_merging_transitions_with_a_from_node_present_in_both_operands(self):
-        t1 = {1: [2, 3]}
-        t2 = {1: [4]}
-
-        result = merge_transitions(t1, t2)
-        expected_result = {1: [2, 3, 4]}
-
-        self.assertEqual(result, expected_result)
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/analyses/decompiler/test_baseptr_save_simplifier.py

@@ -1,80 +0,0 @@
-#!/usr/bin/env python3
-__package__ = __package__ or "tests.analyses.decompiler"  # pylint:disable=redefined-builtin
-
-import os.path
-import unittest
-
-import angr
-import ailment
-from angr.analyses.decompiler.optimization_passes.base_ptr_save_simplifier import (
-    BasePointerSaveSimplifier,
-)
-
-from ...common import bin_location
-
-
-test_location = os.path.join(bin_location, "tests")
-
-
-def _get_block(clinic, addr):
-    for block in clinic.graph.nodes():
-        if block.addr == addr:
-            return block
-    return None
-
-
-def check_bp_save_fauxware(arch):
-    p = angr.Project(os.path.join(test_location, arch, "fauxware"), auto_load_libs=False)
-    cfg = p.analyses.CFGFast(normalize=True)
-    main = p.kb.functions["main"]
-    optimization_passes = [BasePointerSaveSimplifier]
-    dra = p.analyses.Decompiler(main, cfg=cfg, optimization_passes=optimization_passes)
-    first_block_stmts = dra.codegen._sequence.nodes[0].nodes[0].statements
-    for stmt in first_block_stmts:
-        if isinstance(stmt, ailment.Stmt.Store):
-            assert not (isinstance(stmt.data, ailment.Expr.Register) and stmt.data.reg_offset == p.arch.bp_offset) or (
-                isinstance(stmt.data, ailment.Expr.StackBaseOffset) and stmt.data.offset == 0
-            )
-
-
-# pylint: disable=missing-class-docstring
-# pylint: disable=no-self-use
-class TestBaseptrSaveSimplifier(unittest.TestCase):
-    def test_baseptr_save_simplifier_amd64(self):
-        # decompile all:main and make sure the first and the last blocks do not save or restore to rbp
-        bin_path = os.path.join(test_location, "x86_64", "all")
-        proj = angr.Project(bin_path, auto_load_libs=False, load_debug_info=True)
-
-        cfg = proj.analyses.CFG(data_references=True, normalize=True)
-
-        optimization_passes = [BasePointerSaveSimplifier]
-        main_func = cfg.functions["main"]
-        dec = proj.analyses.Decompiler(main_func, cfg=cfg, optimization_passes=optimization_passes)
-
-        entry_block = _get_block(dec.clinic, main_func.addr)
-        endpoint_block = _get_block(dec.clinic, next(iter(main_func.endpoints)).addr)
-
-        assert entry_block is not None
-        assert endpoint_block is not None
-
-        for stmt in entry_block.statements:
-            if isinstance(stmt, ailment.Stmt.Store) and isinstance(stmt.data, ailment.Expr.StackBaseOffset):
-                assert False, "Found a base-pointer saving statement in the first block."
-
-        for stmt in endpoint_block.statements:
-            if (
-                isinstance(stmt, ailment.Stmt.Assignment)
-                and isinstance(stmt.dst, ailment.Expr.Register)
-                and stmt.dst.reg_offset == proj.arch.bp_offset
-            ):
-                assert False, "Found a base-pointer restoring statement in the last block."
-
-    def test_bp_save_amd64_fauxware(self):
-        check_bp_save_fauxware("x86_64")
-
-    def test_bp_save_armel_fauxware(self):
-        check_bp_save_fauxware("armel")
-
-
-if __name__ == "__main__":
-    unittest.main()