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

tests/storage/test_memory_merge.py

@@ -1,114 +0,0 @@
-#!/usr/bin/env python3
-# pylint:disable=isinstance-second-argument-not-valid-type,missing-class-docstring,no-self-use
-import unittest
-from unittest import TestCase
-
-import claripy
-
-from angr.storage.memory_mixins.paged_memory.pages.history_tracking_mixin import MAX_HISTORY_DEPTH
-from angr.storage.memory_mixins import (
-    DataNormalizationMixin,
-    SizeNormalizationMixin,
-    AddressConcretizationMixin,
-    UltraPagesMixin,
-    ListPagesMixin,
-    PagedMemoryMixin,
-    SymbolicMergerMixin,
-    ConvenientMappingsMixin,
-)
-from angr import SimState
-from angr.storage.memory_mixins import UltraPage
-
-
-class UltraPageMemory(
-    DataNormalizationMixin,
-    SizeNormalizationMixin,
-    AddressConcretizationMixin,
-    SymbolicMergerMixin,
-    ConvenientMappingsMixin,
-    UltraPagesMixin,
-    PagedMemoryMixin,
-):
-    pass
-
-
-class ListPageMemory(
-    DataNormalizationMixin,
-    SizeNormalizationMixin,
-    AddressConcretizationMixin,
-    SymbolicMergerMixin,
-    ConvenientMappingsMixin,
-    ListPagesMixin,
-    PagedMemoryMixin,
-):
-    pass
-
-
-class TestMemoryMerge(TestCase):
-    def test_merge_memory_object_endness(self):
-        for memcls in [UltraPageMemory, ListPageMemory]:
-            state0 = SimState(arch="AMD64", mode="symbolic", plugins={"memory": memcls()})
-            state0.memory.store(0x20000, claripy.BVS("x", 64), endness="Iend_LE")
-
-            state1 = SimState(arch="AMD64", mode="symbolic", plugins={"memory": memcls()})
-            state1.memory.store(0x20000, claripy.BVS("y", 64), endness="Iend_LE")
-
-            state, _, _ = state0.merge(state1)
-            obj = state.memory.load(0x20000, size=8, endness="Iend_LE")
-            assert isinstance(obj, claripy.ast.Base)
-            # the original endness should be respected, and obj.op should not be Reverse
-            assert obj.op == "If"
-
-    def test_merge_seq(self):
-        state1 = SimState(arch="AMD64", mode="symbolic", plugins={"memory": UltraPageMemory()})
-        state2 = SimState(arch="AMD64", mode="symbolic", plugins={"memory": UltraPageMemory()})
-
-        state1.regs.rsp = 0x80000000
-        state2.regs.rsp = 0x80000000
-
-        state1.memory.store(state1.regs.rsp, 0x11, 1)
-        state1.memory.store(state1.regs.rsp + 1, 0x22, 1)
-        state2.memory.store(state2.regs.rsp, 0xAA, 1)
-        state2.memory.store(state2.regs.rsp + 1, 0xBB, 1)
-
-        state3, _, __ = state1.merge(state2)
-        vals = (v for v in state3.solver.eval_upto(state3.memory.load(state3.regs.rsp, 2), 10))
-        assert {0x1122, 0xAABB} == set(vals)
-
-    def test_history_tracking(self):
-        state = SimState(arch="AMD64", mode="symbolic", plugins={"memory": UltraPageMemory()})
-
-        states = [state]
-
-        for i in range(25):
-            state = state.copy()
-            states.append(state)  # keep references
-            state.memory.store(i, claripy.BVV(i, 8))
-
-        assert len(state.memory._pages) == 1
-        page: UltraPage = next(iter(state.memory._pages.values()))
-
-        parents = list(page.parents())
-        assert len(parents) == 24
-
-    def test_history_tracking_collapse(self):
-        state = SimState(arch="AMD64", mode="symbolic", plugins={"memory": UltraPageMemory()})
-        state.memory.store(1000, claripy.BVV(1, 8))
-
-        states = [state]
-
-        for i in range(MAX_HISTORY_DEPTH + 4):
-            state = state.copy()
-            states.append(state)  # keep references
-            state.memory.store(i, claripy.BVV(i, 8))
-            assert next(iter(state.memory._pages.values()))._history_depth == (i + 1) % (MAX_HISTORY_DEPTH + 1)
-
-        assert len(state.memory._pages) == 1
-        page: UltraPage = next(iter(state.memory._pages.values()))
-
-        parents = list(page.parents())
-        assert len(parents) == 3
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/storage/test_memview.py

@@ -1,205 +0,0 @@
-#!/usr/bin/env python3
-# pylint: disable=missing-class-docstring,no-self-use,line-too-long
-
-from collections import OrderedDict
-import ctypes
-import unittest
-
-from archinfo import Endness
-import claripy
-
-import angr
-from angr import SimState
-from angr.sim_type import register_types, parse_types, SimStruct, SimTypeNumOffset
-
-
-class TestMemView(unittest.TestCase):
-    def test_simple_concrete(self):
-        s = SimState(arch="AMD64")
-        addr = 0xBA5E0
-
-        def check_read(val):
-            assert s.solver.eval(s.memory.load(addr, 8, endness=Endness.LE), cast_to=int) == val
-
-            assert s.mem[addr].char.concrete == chr(val & 0xFF).encode()
-            assert s.mem[addr].byte.concrete == val & 0xFF
-
-            assert s.mem[addr].int16_t.concrete == ctypes.c_int16(val & 0xFFFF).value
-            assert s.mem[addr].uint16_t.concrete == val & 0xFFFF
-
-            assert s.mem[addr].qword.concrete == val
-
-        s.memory.store(addr, claripy.BVV(0x11223344AABBCC7D, 64), endness=Endness.LE)
-        check_read(0x11223344AABBCC7D)
-
-        # test storing
-        s.mem[addr].uint16_t = 0xEF6D
-        check_read(0x11223344AABBEF6D)
-
-    def test_string_concrete(self):
-        s = SimState(arch="AMD64")
-        addr = 0xBA5E0
-
-        def check_read(val):
-            assert s.solver.eval(s.memory.load(addr, len(val)), cast_to=bytes) == val
-            assert s.solver.eval(s.memory.load(addr + len(val), 1), cast_to=int) == 0
-
-            assert s.mem[addr].string.concrete == val
-
-        s.memory.store(addr, b"a string!\0")
-        check_read(b"a string!")
-
-        # not supported yet
-        # s.mem[addr].string = "shorter"
-        # check_read(b"shorter")
-
-        # s.mem[addr].string = "a longer string"
-        # check_read(b"a longer string")
-
-    def test_array_concrete(self):
-        s = SimState(arch="AMD64")
-        addr = 0xBA5E0
-
-        s.memory.store(addr, claripy.BVV(0x1, 32), endness=Endness.LE)
-        s.memory.store(addr + 4, claripy.BVV(0x2, 32), endness=Endness.LE)
-        s.memory.store(addr + 8, claripy.BVV(0x3, 32), endness=Endness.LE)
-        s.memory.store(addr + 12, claripy.BVV(0x4, 32), endness=Endness.LE)
-        s.memory.store(addr + 16, claripy.BVV(0x5, 32), endness=Endness.LE)
-
-        assert s.mem[addr].dword.array(5).concrete == [0x1, 0x2, 0x3, 0x4, 0x5]
-        assert s.mem[addr].dword.array(5)[2].concrete == 0x3
-        assert s.mem[addr].qword.array(2).concrete == [
-            0x0000000200000001,
-            0x0000000400000003,
-        ]
-        assert s.mem[addr].dword.array(2).array(2).concrete == [[0x1, 0x2], [0x3, 0x4]]
-
-        s.mem[addr].dword.array(5)[3] = 10
-        assert s.solver.eval(s.memory.load(addr + 12, 4, endness=Endness.LE), cast_to=int) == 10
-
-        s.mem[addr].dword.array(5).store([20, 2, 3, 4, 5])
-        assert s.mem[addr].dword.array(4).concrete == [20, 2, 3, 4]
-
-        s.mem[addr].dword.array(2).array(2).store([[1, 2], [4, 3]])
-        assert s.mem[addr].dword.array(4).concrete == [1, 2, 4, 3]
-
-    def test_pointer_concrete(self):
-        s = SimState(arch="AMD64")
-        addr = 0xBA5E0
-        ptraddr = 0xCD0
-
-        s.memory.store(ptraddr, claripy.BVV(addr, 64), endness=Endness.LE)
-        s.memory.store(addr, b"abcdef\0")
-
-        assert s.mem[ptraddr].deref.string.concrete == b"abcdef"
-        s.mem[ptraddr].deref.dword = 123954
-        assert s.solver.eval(s.memory.load(addr, 4, endness=Endness.LE), cast_to=int) == 123954
-        assert s.mem[ptraddr].deref.dword.concrete == 123954
-
-    def test_structs(self):
-        s = SimState(arch="AMD64")
-
-        register_types(
-            parse_types(
-                """
-    struct test_structs {
-      int a;
-      long b;
-    };
-    """
-            )
-        )
-
-        s.memory.store(0x8000, bytes(16))
-        s.mem[0x8000].struct.test_structs = {"a": 10, "b": 20}
-        assert s.mem[0x8000].struct.test_structs.a.concrete == 10
-        assert s.solver.eval(s.memory.load(0x8000, 16), cast_to=bytes) == bytes.fromhex(
-            "0a000000000000001400000000000000"
-        )
-
-    def test_struct_bitfield_simple(self):
-        """
-        Tests if a struct with bitfields like
-        struct {
-            uint32_t a:8, b:1, c:23;
-        }
-        can be used with a memview
-        :return:
-        """
-        state = SimState(arch="AMD64")
-        register_types(
-            SimStruct(
-                name="bitfield_struct",
-                pack=True,
-                fields=OrderedDict(
-                    [
-                        ("a", SimTypeNumOffset(8, signed=False)),
-                        ("b", SimTypeNumOffset(1, signed=False)),
-                        ("c", SimTypeNumOffset(23, signed=False)),
-                    ]
-                ),
-            )
-        )
-
-        data = [
-            (b"\x0e\x02\x00\x00", (14, 0, 1)),
-            (b"\x14T\x00\x00", (20, 0, 42)),
-            (b"\x04\n\x01\x00", (4, 0, 133)),
-            (b"\x04j\x01\x00", (4, 0, 181)),
-            (b"\x04\xa2\x01\x00", (4, 0, 209)),
-            (b"\x04\xf4\x01\x00", (4, 0, 250)),
-            (b"\x04\\\x02\x00", (4, 0, 302)),
-            (b"\x04\x98\x02\x00", (4, 0, 332)),
-            (b"\x04\xe0\x02\x00", (4, 0, 368)),
-            (b"\x04\x1e\x03\x00", (4, 0, 399)),
-        ]
-        state.memory.store(
-            0x8000,
-            b"\x0e\x02\x00\x00"
-            b"\x14T\x00\x00"
-            b"\x04\n\x01\x00"
-            b"\x04j\x01\x00"
-            b"\x04\xa2\x01\x00"
-            b"\x04\xf4\x01\x00"
-            b"\x04\\\x02\x00"
-            b"\x04\x98\x02\x00"
-            b"\x04\xe0\x02\x00"
-            b"\x04\x1e\x03\x00",
-        )
-        view = state.mem[0x8000].struct.bitfield_struct.array(5)
-        for idx, (b, result) in enumerate(data):
-            v = view[idx]
-            s = v.concrete
-            assert s.a == result[0], f"Field a was {s.a}, expected {result[0]}, from bytes {b}"
-            assert v.a.concrete == result[0], f"Field a was {v.a.concrete}, expected {result[0]}, from bytes {b}"
-
-            assert s.b == result[1], f"Field b was {s.b}, expected {result[1]}, from bytes {b}"
-            assert v.b.concrete == result[1], f"Field b was {s.b}, expected {result[1]}, from bytes {b}"
-
-            assert s.c == result[2], f"Field c was {s.c}, expected {result[2]}, from bytes {b}"
-            assert v.c.concrete == result[2], f"Field c was {v.c.concrete}, expected {result[2]}, from bytes {b}"
-
-    def test_struct_bitfield_complex(self):
-        bitfield_struct2 = angr.types.parse_type(
-            """struct bitfield_struct2
-        {
-            uint64_t    target    : 36,
-                        high8     :  8,
-                        reserved  :  7,
-                        next      : 12,
-                        bind      :  1;
-        }"""
-        )
-
-        angr.types.register_types(bitfield_struct2)
-        state = SimState(arch="AMD64")
-        state.memory.store(0x1000, b"\xb3\xc7\xe9|\xad\xd7\xee$")  # store some random data
-        struct = state.mem[0x1000].struct.bitfield_struct2.concrete
-        assert struct.target == 0xD7CE9C7B3
-        assert struct.high8 == 0x7A
-        assert struct.next == 0x49D
-        assert struct.bind == 0
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/storage/test_mmap.py

@@ -1,26 +0,0 @@
-#!/usr/bin/env python3
-# pylint: disable=missing-class-docstring,no-self-use,line-too-long
-
-import unittest
-
-from angr import SimState
-
-
-class TestMmap(unittest.TestCase):
-    def test_mmap_base_copy(self):
-        state = SimState(arch="AMD64", mode="symbolic")
-
-        mmap_base = 0x12345678
-
-        state.heap.mmap_base = mmap_base
-
-        # Sanity check
-        assert state.heap.mmap_base == mmap_base
-
-        state_copy = state.copy()
-
-        assert state_copy.heap.mmap_base == mmap_base
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/storage/test_multivalues.py

@@ -1,44 +0,0 @@
-#!/usr/bin/env python3
-# pylint:disable=missing-class-docstring,no-self-use
-from unittest import TestCase, main
-
-import claripy
-from angr.storage.memory_mixins.paged_memory.pages.multi_values import MultiValues
-
-
-class TestMultiValues(TestCase):
-    def test_multivalues_one_slot_has_multiple_sized_bvs(self):
-        mv = MultiValues(offset_to_values={0: {claripy.BVV(0, 32)}, 4: {claripy.BVV(1, 32)}, 8: {claripy.BVV(2, 32)}})
-        mv.add_value(4, claripy.BVV(0x1338133813371337, 64))
-
-        assert len(mv._values) == 3
-        assert len(mv._values[4]) == 2
-        assert mv._values[4] == {claripy.BVV(1, 32), claripy.BVV(0x13381338, 32)}
-        assert mv._values[8] == {claripy.BVV(2, 32), claripy.BVV(0x13371337, 32)}
-
-        mv.add_value(5, claripy.BVV(0xCC, 8))
-        assert len(mv._values) == 5  # 0, 4, 5, 6, 8
-        assert mv._values[5] == {claripy.BVV(0xCC, 8), claripy.BVV(0x38, 8), claripy.BVV(0, 8)}
-        assert mv._values[6] == {claripy.BVV(1, 16), claripy.BVV(0x1338, 16)}
-
-    def test_multivalues_empty(self):
-        mv = MultiValues()
-        assert mv._single_value is None
-        assert mv._values == {}
-        assert len(mv) == 0
-
-    def test_multivalues_single_value(self):
-        v = claripy.BVV(0x1338133813371337, 64)
-        mv = MultiValues(v)
-        assert mv._single_value is not None
-        assert v.concrete_value == mv._single_value.concrete_value
-        assert len(mv) == 64
-
-        mv2 = MultiValues(mv)
-        assert mv2._single_value is not None
-        assert v.concrete_value == mv2._single_value.concrete_value
-        assert len(mv2) == 64
-
-
-if __name__ == "__main__":
-    main()

tests/storage/test_permissions.py

@@ -1,32 +0,0 @@
-#!/usr/bin/env python3
-# pylint: disable=missing-class-docstring,no-self-use,line-too-long
-__package__ = __package__ or "tests.storage"  # pylint:disable=redefined-builtin
-
-import os
-import unittest
-
-import angr
-
-from ..common import bin_location
-
-
-test_location = os.path.join(bin_location, "tests")
-
-
-class TestPermissions(unittest.TestCase):
-    def test_nx(self):
-        nx_amd64 = angr.Project(os.path.join(test_location, "x86_64", "memmove"), auto_load_libs=False)
-        es = nx_amd64.factory.entry_state()
-
-        # .text should be PROT_READ|PROT_EXEC
-        assert es.solver.eval(es.memory.permissions(nx_amd64.entry)) == 5
-
-        # load stack to initialize page
-        es.memory.load(es.regs.sp, 4)
-
-        # stack should be PROT_READ|PROT_WRITE
-        assert es.solver.eval(es.memory.permissions(es.regs.sp)) == 3
-
-
-if __name__ == "__main__":
-    unittest.main()