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

tests/analyses/test_disassembly.py

@@ -1,121 +0,0 @@
-#!/usr/bin/env python3
-# pylint:disable=missing-class-docstring,no-self-use
-from unittest import TestCase, main
-
-import angr
-from angr.analyses import Disassembly
-from angr.analyses.disassembly import MemoryOperand, Instruction
-
-
-class TestDisassembly(TestCase):
-    def test_arm64_dissect_instructions(self):
-        proj = angr.load_shellcode(
-            b"\x00\xe4\x00\x6f"
-            b"\x43\x3c\x0b\x0e"
-            b"\x54\x9a\xb7\x72"
-            b"\xfc\x6f\xba\xa9"
-            b"\x88\x03\x98\x1a"
-            b"\x00\x60\x01\x4e",
-            "AARCH64",
-            0,
-        )
-        # movi   v0.2d, #0000000000000000'                              ; SIMD register
-        # umov   w3, v2.b[5]                                            ; SIMD register index
-        # movk   w20, #0xbcd2, lsl #16                                  ; ARM64 shifter
-        # stp    x28, x27, [sp, #-0x60]!                                ; ARM64 pre-indexed operand
-        # csel   w8, w28, w24, eq                                       ; Condition code at the end
-        # tbl    v0.16b, {v0.16b, v1.16b, v2.16b, v3.16b}, v1.16b       ; Multiple SIMD regs in table
-        block = proj.factory.block(0)
-        disasm = proj.analyses[Disassembly].prep()(ranges=[(block.addr, block.addr + block.size)])
-
-        insns = [r for r in disasm.raw_result if isinstance(r, Instruction)]
-        rendered_insns = [i.render()[0].lower() for i in insns]
-        assert "v0.2d" in rendered_insns[0]
-        assert "v2.b[5]" in rendered_insns[1]
-        assert "lsl#16" in rendered_insns[2].replace(" ", "")
-        assert rendered_insns[3].endswith("]!")
-        assert rendered_insns[4].endswith("eq")
-        insn = rendered_insns[5]
-        regs_table = insn[insn.index("{") + 1 : insn.index("}")].replace(" ", "").split(",")
-        assert ["v0.16b", "v1.16b", "v2.16b", "v3.16b"] == regs_table
-
-    def test_arm32_dissect_instructions(self):
-        proj = angr.load_shellcode(
-            b"\x00\xc0\x2d\xe9\x10\xf9\xf9\xe9",
-            "ARM",
-            0,
-        )
-        # push    {lr, pc}
-        # ldmib   sb!, {r4, r8, fp, ip, sp, lr, pc}^
-
-        block = proj.factory.block(0)
-        disasm = proj.analyses[Disassembly].prep()(ranges=[(block.addr, block.addr + block.size)])
-        insns = [r for r in disasm.raw_result if isinstance(r, Instruction)]
-        rendered_insns = [i.render()[0].lower() for i in insns]
-        assert all(i in rendered_insns[0] for i in ("{", "}", "lr", "pc"))
-        assert "sb!" in rendered_insns[1]
-        assert rendered_insns[1].endswith("^")
-
-    def test_arm32_thumb_dissect_instructions(self):
-        proj = angr.load_shellcode(b"\x00\xf9\x01\x1a", "ARM", 0, thumb=True)
-        # vst1.8  {d1, d2}, [r0], r1
-
-        block = proj.factory.block(0, thumb=True)
-        disasm = proj.analyses[Disassembly].prep()(ranges=[(block.addr, block.addr + block.size)], thumb=True)
-        insns = [r for r in disasm.raw_result if isinstance(r, Instruction)]
-
-        disassembly_operands = insns[0].operands
-        capstone_operands = insns[0].insn.operands
-        assert len(disassembly_operands) == len(capstone_operands)
-
-    def test_mips32_missing_offset_in_instructions(self):
-        proj = angr.load_shellcode(
-            b"\x8f\xbc\x00\x10"
-            b"\x02\x20\x30\x21"
-            b"\x8F\x85\x80\x28"
-            b"\x8F\x99\x81\x20"
-            b"\x02\x40\x38\x21"
-            b"\x24\xA5\x5E\x38"
-            b"\x03\x20\xF8\x09"
-            b"\x24\x04\x00\x02",
-            "MIPS32",
-            0,
-        )
-        # 0x0:    lw      $gp, 0x10($sp)
-        # 0x4:    move    $a2, $s1
-        # 0x8:    lw      $a1, -0x7fd8($gp)
-        # 0xc:    lw      $t9, -0x7ee0($gp)
-        # 0x10:   move    $a3, $s2
-        # 0x14:   addiu   $a1, $a1, 0x5e38
-        # 0x18:   jalr    $t9
-        # 0x1c:   addiu   $a0, $zero, 2
-
-        block = proj.factory.block(0)
-        disass = proj.analyses[Disassembly].prep()(ranges=[(block.addr, block.addr + block.size)])
-        result = disass.raw_result
-        assert len(result) == 10, f"Incorrect number of instructions ({len(result)})"
-
-        ins = result[4]
-        operand_1 = ins.operands[1]
-        assert isinstance(operand_1, MemoryOperand)
-        assert len(operand_1.children) == 4
-        assert len(operand_1.values) == 1
-        assert len(operand_1.offset) == 1
-        assert operand_1.offset_location == "prefix"
-        rendered = disass.render(color=False)
-        assert (
-            rendered
-            == """   _start:
-0  lw      $gp, 0x10($sp)
-4  move    $a2, $s1
-8  lw      $a1, -0x7fd8($gp)
-c  lw      $t9, -0x7ee0($gp)
-10  move    $a3, $s2
-14  addiu   $a1, $a1, 0x5e38
-18  jalr    $t9
-1c  addiu   $a0, $zero, 0x2"""
-        )
-
-
-if __name__ == "__main__":
-    main()

tests/analyses/test_find_objects_static.py

@@ -1,35 +0,0 @@
-#!/usr/bin/env python3
-# pylint: disable=missing-class-docstring,disable=no-self-use
-__package__ = __package__ or "tests.analyses"  # pylint:disable=redefined-builtin
-
-import os
-import unittest
-
-import angr
-
-from ..common import bin_location
-
-
-test_location = os.path.join(bin_location, "tests")
-
-
-class TestFindObjectsStatic(unittest.TestCase):
-    def test_object_identification_x86_64(self):
-        p = angr.Project(os.path.join(test_location, "x86_64", "cpp_classes"), auto_load_libs=False)
-        object_identifier_analysis = p.analyses.StaticObjectFinder()
-        possible_objects_dict = object_identifier_analysis.possible_objects
-        possible_constructors = object_identifier_analysis.possible_constructors
-        class_labels = []
-
-        for possible_object in possible_objects_dict.values():
-            class_labels.append(possible_object.class_name)
-
-        assert "C" in class_labels
-        assert len(possible_objects_dict) == 2
-        assert len(possible_constructors) == 1
-        assert 0x401512 in possible_constructors
-        assert len(possible_constructors[0x401512]) == 2
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/analyses/test_flirt.py

@@ -1,49 +0,0 @@
-#!/usr/bin/env python3
-# pylint: disable=missing-class-docstring,disable=no-self-use
-__package__ = __package__ or "tests.analyses"  # pylint:disable=redefined-builtin
-
-import os.path
-import unittest
-
-import angr
-
-from ..common import bin_location, slow_test
-
-
-class TestFlirt(unittest.TestCase):
-    @slow_test
-    def test_amd64_elf_static_libc_ubuntu_2004(self):
-        binary_path = os.path.join(bin_location, "tests", "x86_64", "elf_with_static_libc_ubuntu_2004_stripped")
-        proj = angr.Project(binary_path, auto_load_libs=False, load_debug_info=False)
-        cfg = proj.analyses.CFGFast(show_progressbar=False)  # , detect_tail_calls=True)
-        flirt_path = os.path.join(bin_location, "tests", "x86_64", "libc_ubuntu_2004.sig")
-        proj.analyses.Flirt(flirt_path)
-
-        assert cfg.functions[0x415CC0].name == "_IO_file_open"
-        assert cfg.functions[0x415CC0].is_default_name is False
-        assert cfg.functions[0x415CC0].from_signature == "flirt"
-        assert cfg.functions[0x436980].name == "__mempcpy_chk_avx512_no_vzeroupper"
-        assert cfg.functions[0x436980].is_default_name is False
-        assert cfg.functions[0x436980].from_signature == "flirt"
-
-    @slow_test
-    def test_armhf_elf_static_using_armel_libc(self):
-        binary_path = os.path.join(bin_location, "tests", "armhf", "amp_challenge_07.gcc")
-        proj = angr.Project(binary_path, auto_load_libs=False, load_debug_info=False)
-        proj.analyses.CFGFast(show_progressbar=False)
-        flirt_path = os.path.join(bin_location, "tests", "armhf", "debian_10.3_libc.sig")
-        flirt = proj.analyses.Flirt(flirt_path)
-
-        assert len(flirt.matched_suggestions) == 1
-
-        assert proj.kb.functions[0x1004C9].name == "strstr"
-        assert proj.kb.functions[0x1004C9].prototype is not None
-        assert proj.kb.functions[0x1004C9].calling_convention is not None
-
-        assert proj.kb.functions[0xF38D9].name == "__printf"
-        assert proj.kb.functions[0xF38D9].prototype is not None
-        assert proj.kb.functions[0xF38D9].calling_convention is not None
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/analyses/test_identifier.py

@@ -1,33 +0,0 @@
-#!/usr/bin/env python3
-# pylint: disable=missing-class-docstring,disable=no-self-use
-__package__ = __package__ or "tests.analyses"  # pylint:disable=redefined-builtin
-
-import logging
-import os
-import sys
-import unittest
-
-import angr
-
-from ..common import bin_location
-
-
-@unittest.skipIf(sys.platform == "win32", "broken on windows")
-class TestIdentifier(unittest.TestCase):
-    def test_comparison_identification(self):
-        true_symbols = {0x804A3D0: "strncmp", 0x804A0F0: "strcmp", 0x8048E60: "memcmp", 0x8049F40: "strcasecmp"}
-
-        p = angr.Project(os.path.join(bin_location, "tests", "i386", "identifiable"))
-        idfer = p.analyses.Identifier(require_predecessors=False)
-
-        seen = {}
-        for addr, symbol in idfer.run():
-            seen[addr] = symbol
-
-        for addr, symbol in true_symbols.items():
-            assert symbol == seen[addr]
-
-
-if __name__ == "__main__":
-    logging.getLogger("identifier").setLevel("DEBUG")
-    unittest.main()

tests/analyses/test_init_finder.py

@@ -1,38 +0,0 @@
-#!/usr/bin/env python3
-# pylint: disable=missing-class-docstring,disable=no-self-use
-__package__ = __package__ or "tests.analyses"  # pylint:disable=redefined-builtin
-
-import os
-import unittest
-
-import angr
-
-from ..common import bin_location
-
-
-test_location = os.path.join(bin_location, "tests")
-
-
-class TestInitFinder(unittest.TestCase):
-    def test_p2im_drone(self):
-        bin_path = os.path.join(test_location, "armel", "p2im_drone.elf")
-        proj = angr.Project(bin_path, auto_load_libs=False)
-        cfg = proj.analyses.CFG(data_references=True)
-
-        func = cfg.functions["Peripherals_Init"]
-        state = proj.factory.blank_state()
-        prop = proj.analyses.Propagator(func=func, base_state=state)
-
-        init_finder = proj.analyses.InitializationFinder(func=func, replacements=prop.replacements)
-        overlay = init_finder.overlay
-
-        # h12c1.Instance
-        assert state.solver.eval_one(overlay.load(0x20001500, 4, endness="Iend_LE")) == 0x40005400
-        # hi2c1.Init.AddressingMode
-        assert state.solver.eval_one(overlay.load(0x20001500 + 4 + 0xC, 4, endness="Iend_LE")) == 0x4000
-        # h12c1.Init.NoStretchMode
-        assert state.solver.eval_one(overlay.load(0x20001500 + 4 + 0x1C, 4, endness="Iend_LE")) == 0
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/analyses/test_proximitygraph.py

@@ -1,31 +0,0 @@
-#!/usr/bin/env python3
-# pylint: disable=missing-class-docstring,no-self-use,line-too-long
-__package__ = __package__ or "tests.analyses"  # pylint:disable=redefined-builtin
-
-import os
-import unittest
-
-import angr
-
-from ..common import bin_location
-
-test_location = os.path.join(bin_location, "tests")
-
-
-class TestProximityGraph(unittest.TestCase):
-    def test_fauxware(self):
-        bin_path = os.path.join(test_location, "x86_64", "fauxware")
-        proj = angr.Project(bin_path, auto_load_libs=False)
-
-        cfg = proj.analyses.CFG(data_references=True, cross_references=True, normalize=True)
-        func = cfg.kb.functions["main"]
-
-        proj.analyses.Proximity(func, cfg.model, cfg.kb.xrefs)
-
-        # once we have decompiled code, things are different...
-        dec = proj.analyses.Decompiler(func, cfg=cfg.model)
-        proj.analyses.Proximity(func, cfg.model, cfg.kb.xrefs, decompilation=dec)
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/analyses/test_reassembler.py

@@ -1,295 +0,0 @@
-#!/usr/bin/env python3
-# pylint: disable=missing-class-docstring,no-self-use,line-too-long
-__package__ = __package__ or "tests.analyses"  # pylint:disable=redefined-builtin
-
-import sys
-import platform
-import os
-import tempfile
-import subprocess
-import shutil
-import unittest
-
-import angr
-
-from ..common import bin_location, has_32_bit_compiler_support
-
-
-test_location = os.path.join(bin_location, "tests")
-
-# Note: Reassembler is intensively tested by Patcherex test cases on CGC binaries.
-
-
-def is_linux_x64():
-    return sys.platform.startswith("linux") and platform.machine().endswith("64")
-
-
-def is_linux():
-    return sys.platform.startswith("linux")
-
-
-class TestReassembler(unittest.TestCase):
-    def test_data_reference_collection_in_add(self):
-        # Issue reported and test binary provided by Antonio F. Montoya
-        # Fixed in https://github.com/angr/pyvex/pull/192
-
-        p = angr.Project(os.path.join(test_location, "x86_64", "df_gcc_-O1"), auto_load_libs=False)
-        vexblock_opt0 = p.factory.block(0x402431, opt_level=0).vex
-        vexblock_opt1 = p.factory.block(0x402431, opt_level=1).vex
-        vexblock_opt1_nostmt = p.factory.block(0x402431, opt_level=1, collect_data_refs=True).vex_nostmt
-
-        cfg = p.analyses.CFG()
-
-        cfg._model.memory_data = {}
-        cfg._collect_data_references(vexblock_opt0, 0x402431)
-        memory_data_opt0 = cfg._model.memory_data
-
-        cfg._model.memory_data = {}
-        # bypass the IRSB unoptimization step
-        cfg._collect_data_references_by_scanning_stmts(vexblock_opt1, 0x402431)
-        memory_data_opt1 = cfg._model.memory_data
-
-        cfg._model.memory_data = {}
-        cfg._collect_data_references(vexblock_opt1_nostmt, 0x402431)
-        memory_data_opt1_nostmt = cfg._model.memory_data
-
-        assert memory_data_opt0.keys() == memory_data_opt1.keys()
-        assert memory_data_opt0.keys() == memory_data_opt1_nostmt.keys()
-
-    def test_ln_gcc_O2(self):
-        # Issue reported and test binary provided by Antonio F. Montoya
-
-        p = angr.Project(os.path.join(test_location, "x86_64", "ln_gcc_-O2"), auto_load_libs=False)
-        r = p.analyses.Reassembler(syntax="at&t")
-        r.symbolize()
-        r.remove_unnecessary_stuff()
-        assembly = r.assembly(comments=True, symbolized=True)
-
-        # There should be two symbols with the same name: file_name. Reassembler renames the second one to file_name_0.
-        # Test their existence.
-        assert "\nfile_name:" in assembly and "\nfile_name_0:" in assembly
-
-        if is_linux_x64():
-            # we should be able to compile it and run it ... if we are running on x64 Linux
-            tempdir = tempfile.mkdtemp(prefix="angr_test_reassembler_")
-            asm_filename = "ln_gcc-O2.s"
-            bin_filename = "ln_gcc-O2"
-            asm_filepath = os.path.join(tempdir, asm_filename)
-            bin_filepath = os.path.join(tempdir, bin_filename)
-            with open(asm_filepath, "w", encoding="ascii") as f:
-                f.write(assembly)
-            # Call out to GCC, and it should return 0. Otherwise check_call() will raise an exception.
-            subprocess.check_call(
-                ["gcc", "-no-pie", asm_filepath, "-o", bin_filepath],
-                stdout=subprocess.DEVNULL,
-                stderr=subprocess.DEVNULL,
-            )
-            # Run the generated binary file, and it should not crash (which is a pretty basic requirement, I know)
-            subprocess.check_call([bin_filepath, "--help"], stdout=subprocess.DEVNULL)
-            # Pick up after ourselves
-            shutil.rmtree(tempdir)
-
-    def test_chmod_gcc_O1(self):
-        # Issue reported and test binary provided by Antonio F. Montoya
-
-        p = angr.Project(os.path.join(test_location, "x86_64", "chmod_gcc_-O1"), auto_load_libs=False)
-        r = p.analyses.Reassembler(syntax="at&t")
-        r.symbolize()
-        r.remove_unnecessary_stuff()
-        assembly = r.assembly(comments=True, symbolized=True)
-
-        if is_linux_x64():
-            # we should be able to compile it and run it ... if we are running on x64 Linux
-            tempdir = tempfile.mkdtemp(prefix="angr_test_reassembler_")
-            asm_filename = "chmod_gcc-O1.s"
-            bin_filename = "chmod_gcc-O1"
-            asm_filepath = os.path.join(tempdir, asm_filename)
-            bin_filepath = os.path.join(tempdir, bin_filename)
-            with open(asm_filepath, "w", encoding="ascii") as f:
-                f.write(assembly)
-            # Call out to GCC, and it should return 0. Otherwise check_call() will raise an exception.
-            subprocess.check_call(
-                ["gcc", "-no-pie", asm_filepath, "-o", bin_filepath],
-                stdout=subprocess.DEVNULL,
-                stderr=subprocess.DEVNULL,
-            )
-            # Run the generated binary file, and it should not crash (which is a pretty basic requirement, I know)
-            subprocess.check_call([bin_filepath, "--help"], stdout=subprocess.DEVNULL)
-            # Pick up after ourselves
-            shutil.rmtree(tempdir)
-
-    def test_ex_gpp(self):
-        # Issue reported and test binary provided by Antonio F. Montoya
-
-        p = angr.Project(os.path.join(test_location, "x86_64", "ex_g++"), auto_load_libs=False)
-        r = p.analyses.Reassembler(syntax="at&t")
-        r.symbolize()
-        r.remove_unnecessary_stuff()
-        assembly = r.assembly(comments=True, symbolized=True)
-
-        if is_linux_x64():
-            # we should be able to compile it and run it ... if we are running on x64 Linux
-            tempdir = tempfile.mkdtemp(prefix="angr_test_reassembler_")
-            asm_filename = "ex_g++.s"
-            bin_filename = "ex_g++"
-            asm_filepath = os.path.join(tempdir, asm_filename)
-            bin_filepath = os.path.join(tempdir, bin_filename)
-            with open(asm_filepath, "w", encoding="ascii") as f:
-                f.write(assembly)
-            # Call out to GCC, and it should return 0. Otherwise check_call() will raise an exception.
-            subprocess.check_call(
-                ["g++", "-no-pie", asm_filepath, "-o", bin_filepath],
-                stdout=subprocess.DEVNULL,
-                stderr=subprocess.DEVNULL,
-            )
-            # Run the generated binary file and check the output
-            output = subprocess.check_output([bin_filepath])
-            assert output == b"A1\nA2\n"
-            # Pick up after ourselves
-            shutil.rmtree(tempdir)
-
-    def test_df_gcc_O1(self):
-        # Issue reported and test binary provided by Antonio F. Montoya
-
-        p = angr.Project(os.path.join(test_location, "x86_64", "df_gcc_-O1"), auto_load_libs=False)
-        r = p.analyses.Reassembler(syntax="at&t")
-        r.symbolize()
-        r.remove_unnecessary_stuff()
-        assembly = r.assembly(comments=True, symbolized=True)
-
-        if is_linux_x64():
-            # we should be able to compile it and run it ... if we are running on x64 Linux
-            tempdir = tempfile.mkdtemp(prefix="angr_test_reassembler_")
-            asm_filename = "df_gcc-O1.s"
-            bin_filename = "df_gcc-O1"
-            asm_filepath = os.path.join(tempdir, asm_filename)
-            bin_filepath = os.path.join(tempdir, bin_filename)
-            with open(asm_filepath, "w", encoding="ascii") as f:
-                f.write(assembly)
-            # Call out to GCC, and it should return 0. Otherwise check_call() will raise an exception.
-            subprocess.check_call(
-                ["gcc", "-no-pie", asm_filepath, "-o", bin_filepath],
-                stdout=subprocess.DEVNULL,
-                stderr=subprocess.DEVNULL,
-            )
-            # Run the generated binary file, and it should not crash (which is a pretty basic requirement, I know)
-            subprocess.check_call([bin_filepath, "--help"], stdout=subprocess.DEVNULL)
-            # Pick up after ourselves
-            shutil.rmtree(tempdir)
-
-    def test_dir_gcc_O0(self):
-        # Issue reported and test binary provided by Antonio F. Montoya
-
-        p = angr.Project(os.path.join(test_location, "x86_64", "dir_gcc_-O0"), auto_load_libs=False)
-        r = p.analyses.Reassembler(syntax="at&t")
-        r.symbolize()
-        r.remove_unnecessary_stuff()
-        assembly = r.assembly(comments=True, symbolized=True)
-
-        if is_linux_x64():
-            # we should be able to compile it and run it ... if we are running on x64 Linux
-            tempdir = tempfile.mkdtemp(prefix="angr_test_reassembler_")
-            asm_filename = "dir_gcc-O0.s"
-            bin_filename = "dir_gcc-O0"
-            asm_filepath = os.path.join(tempdir, asm_filename)
-            bin_filepath = os.path.join(tempdir, bin_filename)
-            with open(asm_filepath, "w", encoding="ascii") as f:
-                f.write(assembly)
-            # Call out to GCC, and it should return 0. Otherwise check_call() will raise an exception.
-            subprocess.check_call(
-                ["gcc", "-no-pie", asm_filepath, "-o", bin_filepath],
-                stdout=subprocess.DEVNULL,
-                stderr=subprocess.DEVNULL,
-            )
-            # Run the generated binary file, and it should not crash (which is a pretty basic requirement, I know)
-            subprocess.check_call([bin_filepath, "--help"], stdout=subprocess.DEVNULL)
-            subprocess.check_call([bin_filepath, "-la", "/"], stdout=subprocess.DEVNULL)
-            # Pick up after ourselves
-            shutil.rmtree(tempdir)
-
-    def test_helloworld(self):
-        # Reassembler complains about TYPE_OTHER symbols, which is because it's trying to classify bytes inside the ELF
-        # header as pointers. We identify the ELF header in CFGFast to workaround this problem.
-        # https://github.com/angr/angr/issues/1630
-
-        p = angr.Project(os.path.join(test_location, "x86_64", "hello_world"), auto_load_libs=False)
-        r = p.analyses.Reassembler(syntax="at&t")
-        r.symbolize()
-        r.remove_unnecessary_stuff()
-        _ = r.assembly(comments=True, symbolized=True)
-
-        # No exception should have been raised
-
-    def test_helloworld_gcc9(self):
-        # New versions of GCC changed the names of init and fini sections.
-        # https://github.com/angr/patcherex/issues/39
-
-        p = angr.Project(os.path.join(test_location, "x86_64", "hello_gcc9_reassembler"), auto_load_libs=False)
-        r = p.analyses.Reassembler(syntax="at&t")
-        r.symbolize()
-        r.remove_unnecessary_stuff()
-        assembly = r.assembly(comments=True, symbolized=True)
-
-        if is_linux_x64():
-            # we should be able to compile it and run it ... if we are running on x64 Linux
-            tempdir = tempfile.mkdtemp(prefix="angr_test_reassembler_")
-            asm_filename = "hello.s"
-            bin_filename = "hello"
-            asm_filepath = os.path.join(tempdir, asm_filename)
-            bin_filepath = os.path.join(tempdir, bin_filename)
-            with open(asm_filepath, "w", encoding="ascii") as f:
-                f.write(assembly)
-            # Call out to GCC, and it should return 0. Otherwise check_call() will raise an exception.
-            subprocess.check_call(
-                ["gcc", "-no-pie", asm_filepath, "-o", bin_filepath],
-                stdout=subprocess.DEVNULL,
-                stderr=subprocess.DEVNULL,
-            )
-            # Run the generated binary file, and it should not crash
-            subprocess.check_call([bin_filepath], stdout=subprocess.DEVNULL)
-            # Pick up after ourselves
-            shutil.rmtree(tempdir)
-
-    def test_partial_pie_ls_x86(self):
-        # https://github.com/angr/patcherex/issues/39
-        # a GCC-generated X86 binary with a few functions somehow being PIE
-
-        p = angr.Project(os.path.join(test_location, "i386", "ls_gcc_7.5_reassembler"), auto_load_libs=False)
-        r = p.analyses.Reassembler(syntax="at&t")
-        r.symbolize()
-        r.remove_unnecessary_stuff()
-        assembly = r.assembly(comments=True, symbolized=True)
-
-        if is_linux() and has_32_bit_compiler_support():
-            # we should be able to compile it and run it ... if we are running on x64 Linux
-            tempdir = tempfile.mkdtemp(prefix="angr_test_reassembler_")
-            asm_filename = "ls.s"
-            bin_filename = "ls"
-            asm_filepath = os.path.join(tempdir, asm_filename)
-            bin_filepath = os.path.join(tempdir, bin_filename)
-            with open(asm_filepath, "w", encoding="ascii") as f:
-                f.write(assembly)
-            # Call out to GCC, and it should return 0. Otherwise check_call() will raise an exception.
-            subprocess.check_call(
-                ["gcc", "-m32", "-no-pie", asm_filepath, "-o", bin_filepath],
-                stdout=subprocess.DEVNULL,
-                stderr=subprocess.DEVNULL,
-            )
-            # Run the generated binary file, and it should not crash
-            subprocess.check_call([bin_filepath], stdout=subprocess.DEVNULL)
-            # We can also run it with "-h"
-            o = subprocess.check_output([bin_filepath, "--version"])
-            assert (
-                o == b"ls (GNU coreutils) 8.30\n"
-                b"Copyright (C) 2018 Free Software Foundation, Inc.\n"
-                b"License GPLv3+: GNU GPL version 3 or later <https://gnu.org/licenses/gpl.html>.\n"
-                b"This is free software: you are free to change and redistribute it.\n"
-                b"There is NO WARRANTY, to the extent permitted by law.\n\n"
-                b"Written by Richard M. Stallman and David MacKenzie.\n"
-            )
-            # Pick up after ourselves
-            shutil.rmtree(tempdir)
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/analyses/test_regionidentifier.py

@@ -1,27 +0,0 @@
-#!/usr/bin/env python3
-# pylint: disable=missing-class-docstring,no-self-use,line-too-long
-__package__ = __package__ or "tests.analyses"  # pylint:disable=redefined-builtin
-
-import os
-import unittest
-
-import angr
-
-from ..common import bin_location
-
-
-test_location = os.path.join(bin_location, "tests")
-
-
-class TestRegionIdentifier(unittest.TestCase):
-    def test_smoketest(self):
-        p = angr.Project(os.path.join(test_location, "x86_64", "all"), auto_load_libs=False)
-        cfg = p.analyses.CFG(normalize=True)
-
-        main_func = cfg.kb.functions["main"]
-
-        _ = p.analyses.RegionIdentifier(main_func)
-
-
-if __name__ == "__main__":
-    unittest.main()