smallworld-re 1.0.3__py3-none-any.whl → 2.0.0__py3-none-any.whl

smallworld/state/memory/elf/register_state.py

@@ -0,0 +1,36 @@
+class RegisterState:
+    def __init__(self, registers: dict, pc: int, sp: int, status: int, arch: str):
+        self.arch = arch
+        self.pc = pc
+        self.sp = sp
+        self.status = status
+
+        # The rest of the registers
+        self._registers = registers
+
+    def __getattr__(self, name: str):
+        if name in self._registers:
+            return self._registers[name]
+
+        raise AttributeError(f"No register named '{name}' in this core dump.")
+
+    def __setattr__(self, name: str, value):
+        if name.startswith("_") or name in ("arch", "pc", "sp", "status"):
+            super().__setattr__(name, value)
+        else:
+            if hasattr(self, "_registers") and (name in self._registers):
+                self._registers[name] = value
+            else:
+                super().__setattr__(name, value)
+
+    def apply_to_cpu(self, cpu):
+        """
+        Set the CPU registers from this RegisterState object.
+        """
+        cpu.pc.set(self.pc)
+        cpu.sp.set(self.sp)
+
+        for reg_name, reg_val in self._registers.items():
+            reg_name_lower = reg_name.lower()
+            if hasattr(cpu, reg_name_lower):
+                getattr(cpu, reg_name_lower).set(reg_val)

smallworld/state/memory/elf/rela/__init__.py

@@ -8,6 +8,7 @@ from .arm import (
     Armv7RElfRelocator,
 )
 from .i386 import I386ElfRelocator
+from .loongarch import LoongArch64ElfRelocator
 from .mips import MIPSELElfRelocator, MIPSElfRelocator
 from .ppc import PowerPCElfRelocator
 from .rela import ElfRelocator
@@ -23,6 +24,7 @@ __all__ = [
     "Armv7MElfRelocator",
     "Armv7RElfRelocator",
     "I386ElfRelocator",
+    "LoongArch64ElfRelocator",
     "MIPSElfRelocator",
     "MIPSELElfRelocator",
     "PowerPCElfRelocator",

smallworld/state/memory/elf/rela/aarch64.py

@@ -3,6 +3,7 @@ from .....exceptions import ConfigurationError
 from ..structs import ElfRela
 from .rela import ElfRelocator
 
+R_AARCH64_ABS64 = 257  # Direct 64-bit
 R_AARCH64_GLOB_DAT = 1025  # Create GOT entry
 R_AARCH64_JUMP_SLOT = 1026  # Create PLT entry
 R_AARCH64_RELATIVE = 1027  # Adjust by program base
@@ -17,11 +18,12 @@ class AArch64ElfRelocator(ElfRelocator):
             rela.type == R_AARCH64_GLOB_DAT
             or rela.type == R_AARCH64_JUMP_SLOT
             or rela.type == R_AARCH64_RELATIVE
+            or rela.type == R_AARCH64_ABS64
         ):
             # Different semantics, all behave the same
             val = rela.symbol.value + rela.symbol.baseaddr + rela.addend
             return val.to_bytes(8, "little")
         else:
             raise ConfigurationError(
-                "Unknown relocation type for {rela.symbol.name}: {rela.type}"
+                f"Unknown relocation type for {rela.symbol.name}: {rela.type}"
             )

smallworld/state/memory/elf/rela/amd64.py

@@ -3,6 +3,7 @@ from .....exceptions import ConfigurationError
 from ..structs import ElfRela
 from .rela import ElfRelocator
 
+R_X86_64_64 = 1  # Direct 64-bit
 R_X86_64_GLOB_DAT = 6  # Create GOT entry
 R_X86_64_JUMP_SLOT = 7  # Create PLT entry
 R_X86_64_RELATIVE = 8  # Adjust by program base
@@ -18,15 +19,16 @@ class AMD64ElfRelocator(ElfRelocator):
             rela.type == R_X86_64_GLOB_DAT
             or rela.type == R_X86_64_JUMP_SLOT
             or rela.type == R_X86_64_RELATIVE
+            or rela.type == R_X86_64_64
         ):
             # Different semantics, all behave the same
             val = rela.symbol.value + rela.symbol.baseaddr + rela.addend
             return val.to_bytes(8, "little")
         elif rela.type >= 0 and rela.type < R_X86_64_NUM:
             raise ConfigurationError(
-                "Valid, but unsupported relocation for {rela.symbol.name}: {rela.type}"
+                f"Valid, but unsupported relocation for {rela.symbol.name}: {rela.type}"
             )
         else:
             raise ConfigurationError(
-                "Invalid relocation type for {rela.symbol.name}: {rela.type}"
+                f"Invalid relocation type for {rela.symbol.name}: {rela.type}"
             )

smallworld/state/memory/elf/rela/arm.py

@@ -3,6 +3,7 @@ from .....exceptions import ConfigurationError
 from ..structs import ElfRela
 from .rela import ElfRelocator
 
+R_ARM_ABS32 = 2  # Direct 32-bit
 R_ARM_GLOB_DAT = 21  # Create GOT entry
 R_ARM_JUMP_SLOT = 22  # Create PLT entry
 R_ARM_RELATIVE = 23  # Adjust by program base
@@ -17,17 +18,18 @@ class ArmElfRelocator(ElfRelocator):
             rela.type == R_ARM_GLOB_DAT
             or rela.type == R_ARM_JUMP_SLOT
             or rela.type == R_ARM_RELATIVE
+            or rela.type == R_ARM_ABS32
         ):
             # Different semantics, all behave the same
             val = rela.symbol.value + rela.symbol.baseaddr + rela.addend
             return val.to_bytes(4, "little")
         elif rela.type >= 0 and rela.type < R_ARM_NUM:
             raise ConfigurationError(
-                "Valid, but unsupported relocation for {rela.symbol.name}: {rela.type}"
+                f"Valid, but unsupported relocation for {rela.symbol.name}: {rela.type}"
             )
         else:
             raise ConfigurationError(
-                "Invalid relocation type for {rela.symbol.name}: {rela.type}"
+                f"Invalid relocation type for {rela.symbol.name}: {rela.type}"
             )
 
 

smallworld/state/memory/elf/rela/i386.py

@@ -3,6 +3,7 @@ from .....exceptions import ConfigurationError
 from ..structs import ElfRela
 from .rela import ElfRelocator
 
+R_386_32 = 1  # Direct 32-bit
 R_386_GLOB_DAT = 6  # Create GOT entry
 R_386_JUMP_SLOT = 7  # Create PLT entry
 R_386_RELATIVE = 8  # Adjust by program base
@@ -18,15 +19,16 @@ class I386ElfRelocator(ElfRelocator):
             rela.type == R_386_GLOB_DAT
             or rela.type == R_386_JUMP_SLOT
             or rela.type == R_386_RELATIVE
+            or rela.type == R_386_32
         ):
             # Different semantics, all behave the same
             val = rela.symbol.value + rela.symbol.baseaddr + rela.addend
             return val.to_bytes(4, "little")
         elif rela.type >= 0 and rela.type < R_386_NUM:
             raise ConfigurationError(
-                "Valid, but unsupported relocation for {rela.symbol.name}: {rela.type}"
+                f"Valid, but unsupported relocation for {rela.symbol.name}: {rela.type}"
             )
         else:
             raise ConfigurationError(
-                "Invalid relocation type for {rela.symbol.name}: {rela.type}"
+                f"Invalid relocation type for {rela.symbol.name}: {rela.type}"
             )

smallworld/state/memory/elf/rela/loongarch.py

@@ -0,0 +1,32 @@
+from ..... import platforms
+from .....exceptions import ConfigurationError
+from ..structs import ElfRela
+from .rela import ElfRelocator
+
+R_LARCH_64 = 2  # Direct 64-bit
+R_LARCH_RELATIVE = 4  # Adjust by program base
+R_LARCH_JUMP_SLOT = 5  # Create PLT entry
+R_LARCH_NUM = 127  # This and higher aren't valid
+
+
+class LoongArch64ElfRelocator(ElfRelocator):
+    arch = platforms.Architecture.LOONGARCH64
+    byteorder = platforms.Byteorder.LITTLE
+
+    def _compute_value(self, rela: ElfRela):
+        if (
+            rela.type == R_LARCH_JUMP_SLOT
+            or rela.type == R_LARCH_RELATIVE
+            or rela.type == R_LARCH_64
+        ):
+            # Different semantics, all behave the same
+            val = rela.symbol.value + rela.symbol.baseaddr + rela.addend
+            return val.to_bytes(8, "little")
+        elif rela.type >= 0 and rela.type < R_LARCH_NUM:
+            raise ConfigurationError(
+                f"Valid, but unsupported relocation for {rela.symbol.name}: {rela.type}"
+            )
+        else:
+            raise ConfigurationError(
+                f"Invalid relocation type for {rela.symbol.name}: {rela.type}"
+            )

smallworld/state/memory/elf/rela/mips.py

@@ -3,7 +3,9 @@ from .....exceptions import ConfigurationError
 from ..structs import ElfRela
 from .rela import ElfRelocator
 
+R_MIPS_NONE = 0
 R_MIPS_32 = 2  # 32-bit direct
+R_MIPS_REL32 = 3
 R_MIPS_64 = 18  # 64-bit direct
 
 
@@ -12,24 +14,43 @@ class MIPSElfRelocator(ElfRelocator):
     byteorder = platforms.Byteorder.BIG
 
     def _compute_value(self, rela: ElfRela):
-        # Because mypy doesn't believe I know what I'm doing...
-
-        if rela.type == R_MIPS_32:
-            # 32-bit direct
-            val = rela.symbol.value + rela.symbol.baseaddr + rela.addend
-            return val.to_bytes(
-                4, "big" if self.byteorder == platforms.Byteorder.BIG else "little"
-            )
-        elif rela.type == R_MIPS_64:
-            # 64-bit direct
-            val = rela.symbol.value + rela.symbol.baseaddr + rela.addend
-            return val.to_bytes(
-                8, "big" if self.byteorder == platforms.Byteorder.BIG else "little"
-            )
-        else:
-            raise ConfigurationError(
-                "Invalid relocation type for {rela.symbol.name}: {rela.type}"
-            )
+        # Unpack a MIPS64 relocation.
+        #
+        # It's not possible to build a 64-bit address in one instruction in MIPS64.
+        # Rather than tell the linker to live with it,
+        # MIPS64 relocation entries can define up to three nested relocations,
+        # with relocations 2 and 3 acting as if the symbol value were the result
+        # of the previous relocation.
+        #
+        # There's a fourth argument, which is a parameter to relocation 2, I think.
+        # Don't want to waste those bytes...
+        rela_types = []
+        # rela_special = (rela.type >> 24) & 0xFF
+        for i in range(0, 3):
+            rela_types.append((rela.type >> (i * 8)) & 0xFF)
+
+        val = rela.symbol.value + rela.symbol.baseaddr
+        is_64 = False
+        for i in range(0, 3):
+            rela_type = rela_types[i]
+            if rela_type == R_MIPS_NONE:
+                break
+            elif rela_type == R_MIPS_32 or rela_type == R_MIPS_REL32:
+                # 32-bit direct
+                val = val + rela.addend
+            elif rela_type == R_MIPS_64:
+                # 64-bit direct
+                val = val + rela.addend
+                is_64 = True
+            else:
+                raise ConfigurationError(
+                    f"Invalid relocation type {i} for {rela.symbol.name}: {rela_type}"
+                )
+
+        return val.to_bytes(
+            8 if is_64 else 4,
+            "big" if self.byteorder == platforms.Byteorder.BIG else "little",
+        )
 
 
 class MIPSELElfRelocator(MIPSElfRelocator):

smallworld/state/memory/elf/rela/ppc.py

@@ -3,6 +3,7 @@ from .....exceptions import ConfigurationError
 from ..structs import ElfRela
 from .rela import ElfRelocator
 
+R_PPC_ABS32 = 1  # Direct 32-bit
 R_PPC_GLOB_DAT = 20  # Create GOT entry
 R_PPC_JUMP_SLOT = 21  # Create PLT entry
 R_PPC_RELATIVE = 22  # Adjust by program base
@@ -14,7 +15,10 @@ class PowerPCElfRelocator(ElfRelocator):
     addrsz = 4
 
     def _compute_value(self, rela: ElfRela):
-        if (
+        if rela.type == R_PPC_ABS32:
+            val = rela.symbol.value + rela.symbol.baseaddr + rela.addend
+            return val.to_bytes(4, "big")
+        elif (
             rela.type == R_PPC_GLOB_DAT
             or rela.type == R_PPC_JUMP_SLOT
             or rela.type == R_PPC_RELATIVE
@@ -24,22 +28,35 @@ class PowerPCElfRelocator(ElfRelocator):
             return val.to_bytes(self.addrsz, "big")
         else:
             raise ConfigurationError(
-                "Invalid relocation type for {rela.symbol.name}: {rela.type}"
+                f"Invalid relocation type for {rela.symbol.name}: {rela.type}"
             )
 
 
+R_PPC64_ADDR64 = 38  # Adjust by program base, I think...
+
+
 class PowerPC64ElfRelocator(PowerPCElfRelocator):
     arch = platforms.Architecture.POWERPC64
+    byteorder = platforms.Byteorder.BIG
     addrsz = 8
-    # TODO: This is only the beginning
-    #
-    # The PowerPC64 JUMP_SLOT relocation is much more complicated,
-    # possibly the most complicated I've ever seen.
-    # It actually fills in three 64-bit values:
-    #
-    # 1. The actual function address
-    # 2. The TOC base address; serves a similar purpose to the Global Pointer in MIPS.
-    # 3. An "environment" pointer, not used by C.
-    #
-    # We're currently correctly filling in 1.
-    # Entry 2. is the address of the GOT section of the containing binary + 0x8000.
+
+    def _compute_value(self, rela: ElfRela):
+        if rela.type == R_PPC64_ADDR64:
+            val = rela.symbol.value + rela.symbol.baseaddr + rela.addend
+            return val.to_bytes(self.addrsz, "big")
+        elif rela.type == R_PPC_JUMP_SLOT:
+            # The PowerPC64 JUMP_SLOT relocation is much more complicated.
+            # It actually fills in three 64-bit values:
+            #
+            # 1. The actual function address
+            # 2. The TOC base address; serves a similar purpose to the Global Pointer in MIPS.
+            # 3. An "environment" pointer, not used by C.
+            #
+            # We're currently correctly filling in 1.
+            # Entry 2. is the address of the GOT section of the containing binary + 0x8000.
+            #
+            # This requires a reference to the containing binary,
+            # which I have no idea how to pass.
+            raise NotImplementedError("R_PPC64_JUMP_SLOT not implemented")
+        else:
+            return super()._compute_value(rela)

smallworld/state/memory/elf/structs.py

@@ -24,11 +24,14 @@ class ElfSymbol:
     without a separate dict.
     """
 
+    idx: int  # Symbol table index
+    dynamic: bool  # Is this in the static or dynamic symbol table?
     name: str  # Symbol name
     type: int  # Symbol type
     bind: int  # Symbol binding
     visibility: int  # Symbol visibility
     shndx: int  # Symbol section index, or reserved flags
+    defined: bool  # Is this symbol defined?
     value: int  # Symbol value
     size: int  # Symbol size
     baseaddr: int  # Base address for relative symbol values

smallworld/state/memory/heap.py

@@ -42,7 +42,7 @@ class Heap(memory.Memory):
         return self.allocate(value)
 
     def allocate_bytes(
-        self, content: typing.Union[bytes, bytearray], label: str
+        self, content: typing.Union[bytes, bytearray], label: typing.Optional[str]
     ) -> int:
         """Allocate space for and write bytes to the heap.
 
@@ -79,7 +79,7 @@ class BumpAllocator(Heap):
         return self.address + offset
 
     def free(self, address: int) -> None:
-        raise NotImplementedError("freeing with a BumpAllocator is not yet implemented")
+        pass
 
 
 __all__ = ["Heap", "BumpAllocator"]

smallworld/state/memory/memory.py

@@ -114,6 +114,24 @@ class Memory(state.Stateful, dict):
         self.clear()
         self[0] = value
 
+    def write_bytes(self, address: int, data: bytes) -> None:
+        """Overwrite part of this memory region with specific bytes
+
+        This will fail if the data you want to overwrite is in a symbolic sub-region.
+        """
+
+        for segment_offset, segment in self.items():
+            segment_address = self.address + segment_offset
+            if address >= segment_address and address < segment_address + segment._size:
+                contents = segment.get_content()
+                if not isinstance(contents, bytes):
+                    raise exceptions.SymbolicValueError(
+                        f"Tried to write {len(data)} bytes at {hex(address)}; data in {segment_address:x} - {segment_address + segment._size:x} is symbolic."
+                    )
+                offset = address - segment_address
+                contents = contents[0:offset] + data + contents[offset + len(data) :]
+                segment.set_content(contents)
+
     def __hash__(self):
         return super(dict, self).__hash__()
 

smallworld/state/memory/pe/__init__.py

@@ -0,0 +1,3 @@
+from .pe import PEExecutable
+
+__all__ = ["PEExecutable"]