PyNerva 0.0.7__py3-none-any.whl

nervapy/formats/macho/section.py

@@ -0,0 +1,322 @@
+# This file is part of PeachPy package and is licensed under the Simplified BSD license.
+#    See license.rst for the full text of the license.
+
+from enum import IntEnum
+
+
+class MemoryProtection(IntEnum):
+    read = 0x01
+    write = 0x02
+    execute = 0x04
+    default = 0x07
+
+
+class Segment:
+    def __init__(self, name):
+        self.name = name
+        self.sections = list()
+        self.flags = 0
+
+    def add_section(self, section):
+        assert isinstance(section, Section)
+        assert section.segment_name == self.name
+
+        self.sections.append(section)
+
+    def get_command_size(self, abi):
+        from nervapy.abi import ABI
+
+        assert isinstance(abi, ABI)
+        assert abi.pointer_size in [4, 8]
+
+        return {4: 56, 8: 72}[abi.pointer_size] + sum(
+            section.get_command_size(abi) for section in self.sections
+        )
+
+    def encode_command(
+        self, encoder, section_offset_map, section_address_map, section_relocations_map
+    ):
+        import nervapy.encoder
+
+        assert isinstance(encoder, nervapy.encoder.Encoder)
+
+        offset = section_offset_map[self.sections[0]]
+        memory_size = (
+            section_address_map[self.sections[-1]] + self.sections[-1].content_size
+        )
+        file_size = sum(section.content_size for section in self.sections)
+
+        address = 0
+        if self.sections:
+            address = section_address_map[self.sections[0]]
+        # TODO: combine the two cases
+        if encoder.bitness == 32:
+            command_id = 0x1
+            command_size = 56 + len(self.sections) * 68
+            command = (
+                encoder.uint32(command_id)
+                + encoder.uint32(command_size)
+                + encoder.fixed_string(self.name, 16)
+                + encoder.uint32(address)
+                + encoder.uint32(memory_size)
+                + encoder.uint32(offset)
+                + encoder.uint32(file_size)
+                + encoder.uint32(MemoryProtection.default)
+                + encoder.uint32(MemoryProtection.default)
+                + encoder.uint32(len(self.sections))
+                + encoder.uint32(self.flags)
+            )
+        else:
+            command_id = 0x19
+            command_size = 72 + len(self.sections) * 80
+            command = (
+                encoder.uint32(command_id)
+                + encoder.uint32(command_size)
+                + encoder.fixed_string(self.name, 16)
+                + encoder.uint64(address)
+                + encoder.uint64(memory_size)
+                + encoder.uint64(offset)
+                + encoder.uint64(file_size)
+                + encoder.uint32(MemoryProtection.default)
+                + encoder.uint32(MemoryProtection.default)
+                + encoder.uint32(len(self.sections))
+                + encoder.uint32(self.flags)
+            )
+        for section in self.sections:
+            command += section.encode_command(
+                encoder,
+                section_offset_map[section],
+                section_address_map[section],
+                section_relocations_map.get(section),
+            )
+        from nervapy.x86_64.abi import system_v_x86_64_abi
+
+        return command
+
+
+class SectionIndex(IntEnum):
+    no_section = 0
+
+
+class SectionType(IntEnum):
+    regular = 0x00
+    zero_fill = 0x01
+    gb_zero_fill = 0x0C
+    cstring_literals = 0x02
+    four_byte_literals = 0x03
+    eight_byte_literals = 0x04
+    sixteen_byte_literals = 0x0E
+    literal_pointers = 0x05
+    non_lazy_symbol_pointers = 0x06
+    lazy_symbol_pointers = 0x07
+    symbol_stubs = 0x08
+    module_init_function_pointers = 0x09
+    module_terminate_function_pointers = 0x0A
+    coalesced_symbols = 0x0B
+    interposing = 0x0D
+    dtrace_object_format = 0x0F
+    lazy_dylib_symbol_pointers = 0x10
+    thread_local_regular = 0x11
+    thread_local_zero_fill = 0x12
+    thread_local_variable_descriptors = 0x13
+    thread_local_variable_pointers = 0x14
+    thread_local_function_pointers = 0x15
+
+
+class SectionAttributes(IntEnum):
+    only_instructions = 0x80000000
+    coalesced_symbols = 0x40000000
+    strip_static_symbols = 0x20000000
+    no_dead_stripping = 0x10000000
+    live_support = 0x08000000
+    self_modifying_code = 0x04000000
+    debug = 0x02000000
+    some_instructions = 0x00000400
+    external_relocations = 0x00000200
+    local_relocations = 0x00000100
+
+
+class Section(object):
+    def __init__(self, type, segment_name, section_name):
+        self.type = type
+        self.segment_name = segment_name
+        self.section_name = section_name
+        self.attributes = 0
+        self._alignment = 1
+        self.relocations = []
+        self.content = bytearray()
+
+    @property
+    def alignment(self):
+        return self._alignment
+
+    @alignment.setter
+    def alignment(self, alignment):
+        from nervapy.util import is_uint32
+
+        if not is_uint32(alignment):
+            raise TypeError(
+                "Section alignment %s is not representable as a 32-bit unsigned integer"
+                % str(alignment)
+            )
+        if alignment & (alignment - 1) != 0:
+            raise ValueError("Section alignment %d is not a power of 2" % alignment)
+        if alignment == 0:
+            alignment = 1
+        self._alignment = alignment
+
+    @property
+    def log2_alignment(self):
+        from nervapy.util import ilog2
+
+        return ilog2(self._alignment)
+
+    @property
+    def relocations_count(self):
+        return len(self.relocations)
+
+    @property
+    def content_size(self):
+        return len(self.content)
+
+    @staticmethod
+    def get_command_size(abi):
+        from nervapy.abi import ABI
+
+        assert isinstance(abi, ABI)
+        assert abi.pointer_size in [4, 8]
+
+        return {4: 68, 8: 80}[abi.pointer_size]
+
+    def encode_command(self, encoder, offset, address, relocations_offset):
+        import nervapy.encoder
+
+        assert isinstance(encoder, nervapy.encoder.Encoder)
+
+        if len(self.relocations) == 0:
+            relocations_offset = 0
+        if encoder.bitness == 32:
+            return (
+                encoder.fixed_string(self.section_name, 16)
+                + encoder.fixed_string(self.segment_name, 16)
+                + encoder.uint32(address)
+                + encoder.uint32(self.content_size)
+                + encoder.uint32(offset)
+                + encoder.uint32(self.log2_alignment)
+                + encoder.uint32(relocations_offset)
+                + encoder.uint32(self.relocations_count)
+                + encoder.uint32(self.type | self.attributes)
+                + bytearray(8)
+            )
+        else:
+            return (
+                encoder.fixed_string(self.section_name, 16)
+                + encoder.fixed_string(self.segment_name, 16)
+                + encoder.uint64(address)
+                + encoder.uint64(self.content_size)
+                + encoder.uint32(offset)
+                + encoder.uint32(self.log2_alignment)
+                + encoder.uint32(relocations_offset)
+                + encoder.uint32(self.relocations_count)
+                + encoder.uint32(self.type | self.attributes)
+                + bytearray(12)
+            )
+
+
+class RegularSection(Section):
+    def __init__(self, segment_name, section_name):
+        super(RegularSection, self).__init__(
+            SectionType.regular, segment_name, section_name
+        )
+
+    def align(self, alignment):
+        import nervapy.util
+
+        ilog2_alignment = nervapy.util.ilog2(alignment)
+        self.alignment = max(self.alignment, ilog2_alignment)
+        if len(self.content) % alignment != 0:
+            padding_length = alignment - len(self.content) % alignment
+            self.content += bytearray(padding_length)
+
+
+class TextSection(RegularSection):
+    def __init__(self):
+        super(TextSection, self).__init__("__TEXT", "__text")
+        self.attributes = (
+            SectionAttributes.only_instructions | SectionAttributes.some_instructions
+        )
+
+
+class ConstSection(RegularSection):
+    def __init__(self):
+        super(ConstSection, self).__init__("__TEXT", "__const")
+
+
+class SymbolTable:
+    command_size = 24
+
+    def __init__(self, string_table):
+        assert isinstance(string_table, StringTable)
+
+        self.symbols = list()
+        self.string_table = string_table
+
+    def add_symbol(self, symbol):
+        from nervapy.formats.macho.symbol import Symbol
+
+        assert isinstance(symbol, Symbol)
+
+        self.symbols.append(symbol)
+        self.string_table.add(symbol.name)
+
+    def encode_command(self, encoder, symbol_offset_map, string_offset):
+        import nervapy.encoder
+
+        assert isinstance(encoder, nervapy.encoder.Encoder)
+
+        command_id = 0x2
+        symbols_offset = 0
+        if self.symbols:
+            symbols_offset = symbol_offset_map[self.symbols[0]]
+        return (
+            encoder.uint32(command_id)
+            + encoder.uint32(SymbolTable.command_size)
+            + encoder.uint32(symbols_offset)
+            + encoder.uint32(len(self.symbols))
+            + encoder.uint32(string_offset)
+            + encoder.uint32(self.string_table.size)
+        )
+
+
+class StringTable:
+    def __init__(self):
+        self.string_index_map = dict()
+        self.size = 0
+
+    def add(self, string):
+        import codecs
+
+        if string is None or len(string) == 0:
+            return 0
+        if string in self.string_index_map:
+            return self.string_index_map[string]
+        else:
+            content_size = self.size
+            if content_size == 0:
+                content_size = 1
+            string_index = content_size
+            self.string_index_map[string] = string_index
+            bytestring = codecs.encode(string, "utf-8")
+            content_size += len(bytestring) + 1
+            self.size = content_size
+
+    def encode(self):
+        import codecs
+
+        if self.size != 0:
+            bytestring = b"\x00"
+            for string in sorted(self.string_index_map, key=self.string_index_map.get):
+                bytestring += codecs.encode(string, "utf8") + b"\x00"
+            return bytestring
+        else:
+            return bytearray()

nervapy/formats/macho/symbol.py

@@ -0,0 +1,158 @@
+# This file is part of PeachPy package and is licensed under the Simplified BSD license.
+#    See license.rst for the full text of the license.
+
+from enum import IntEnum
+
+
+class SymbolVisibility(IntEnum):
+    external = 0x01
+    private_external = 0x10
+
+
+class SymbolType(IntEnum):
+    undefined = 0x00
+    prebound_undefined = 0x0C
+    absolute = 0x02
+    section_relative = 0x0E
+    indirect = 0x0A
+
+
+class SymbolDescription(IntEnum):
+    undefined_lazy = 0x00
+    undefined_non_lazy = 0x01
+    defined = 0x02
+    private_defined = 0x03
+    private_undefined_lazy = 0x05
+    private_undefined_non_lazy = 0x04
+
+
+class SymbolFlags(IntEnum):
+    referenced_dynamically = 0x10
+    no_dead_strip = 0x20
+    weak_reference = 0x40
+    weak_definition = 0x80
+
+
+class Symbol:
+    def __init__(self, name, type, section, value=None):
+        self.name = name
+        self.visibility = 0
+        self.type = type
+        self.section = section
+        self.description = 0
+        self.flags = 0
+        self.value = value
+
+    @staticmethod
+    def get_entry_size(abi):
+        from nervapy.abi import ABI
+
+        assert isinstance(abi, ABI)
+        assert abi.pointer_size in [4, 8]
+
+        return {4: 12, 8: 16}[abi.pointer_size]
+
+    def encode(self, encoder, name_index_map, section_index_map, section_address_map):
+        import nervapy.encoder
+
+        assert isinstance(encoder, nervapy.encoder.Encoder)
+        assert self.name in name_index_map
+        assert self.section is None or self.section in section_index_map
+
+        name_index = name_index_map[self.name]
+        section_index = 0
+        if self.section is not None:
+            section_index = section_index_map[self.section]
+        if encoder.bitness == 32:
+            return (
+                encoder.uint32(name_index)
+                + encoder.uint8(self.type | self.visibility)
+                + encoder.uint8(section_index)
+                + encoder.uint16(self.description | self.flags)
+                + encoder.uint32(self.value)
+            )
+        else:
+            return (
+                encoder.uint32(name_index)
+                + encoder.uint8(self.type | self.visibility)
+                + encoder.uint8(section_index)
+                + encoder.uint16(self.description | self.flags)
+                + encoder.uint64(self.value + section_address_map[self.section])
+            )
+
+
+class RelocationType(IntEnum):
+    x86_64_unsigned = 0
+    x86_64_signed = 1
+    # CALL or JMP instruction with 32-bit displacement.
+    x86_64_branch = 2
+    # Load (MOVQ) of a 64-bit Global Offset Table entry
+    x86_64_got_load = 3
+    x86_64_got = 4
+    x86_64_subtractor = 5
+    # Signed 32-bit displacement with a -1 addend
+    x86_64_signed_minus_1 = 6
+    # Signed 32-bit displacement with a -2 addend
+    x86_64_signed_minus_2 = 7
+    # Signed 32-bit displacement with a -4 addend
+    x86_64_signed_minus_4 = 8
+
+    arm_vanilla = 0
+    arm_pair = 1
+    arm_sectdiff = 2
+    arm_local_sectdiff = 3
+    arm_pb_la_ptr = 4
+    arm_br_24 = 5
+    arm_half = 6
+    arm_half_sectdiff = 7
+
+    arm64_unsigned = 0
+    arm64_subtractor = 1
+    arm64_branch26 = 2
+    arm64_page21 = 3
+    arm64_pageoff12 = 4
+    arm64_got_load_page21 = 5
+    arm64_got_load_pageoff12 = 6
+    arm64_pointer_to_got = 7
+    arm64_tlvp_load_page21 = 8
+    arm64_tlvp_load_pageoff12 = 9
+    arm64_reloc_addend = 10
+
+
+class Relocation:
+    size = 8
+
+    def __init__(self, type, offset, size, symbol, is_pc_relative=False):
+        from nervapy.util import is_sint32
+
+        assert is_sint32(offset)
+        assert offset >= 0
+        assert size in [1, 2, 4, 8]
+        from nervapy.formats.macho.section import Section
+
+        assert symbol is None or isinstance(symbol, (Section, Symbol))
+
+        self.type = type
+        self.offset = offset
+        self.size = size
+        self.symbol = symbol
+        self.is_pc_relative = is_pc_relative
+
+    def encode(self, encoder, section_index_map, symbol_index_map):
+        from nervapy.formats.macho.section import Section
+        from nervapy.util import ilog2
+
+        symbol = 0
+        if isinstance(self.symbol, Symbol):
+            # Set "external" bit (bit 27) if referencing an external symbol
+            symbol = symbol_index_map[self.symbol] | 0x8000000
+        elif isinstance(self.symbol, Section):
+            symbol = section_index_map[self.symbol]
+        if self.is_pc_relative:
+            # Set "pc_relative" bit (bit 24) if the relocation is relative to the program counter
+            symbol |= 0x1000000
+        log2_size = ilog2(self.size)
+        symbol |= log2_size << 25
+        symbol |= self.type << 28
+
+        return encoder.uint32(self.offset) + encoder.uint32(symbol)

nervapy/formats/mscoff/__init__.py

@@ -0,0 +1,8 @@
+# This file is part of PeachPy package and is licensed under the Simplified BSD license.
+#    See license.rst for the full text of the license.
+
+from nervapy.formats.mscoff.image import Image, MachineType
+from nervapy.formats.mscoff.section import (ReadOnlyDataSection, Section,
+                                            TextSection)
+from nervapy.formats.mscoff.symbol import (Relocation, RelocationType,
+                                           StorageClass, Symbol, SymbolType)

nervapy/formats/mscoff/image.py

@@ -0,0 +1,132 @@
+# This file is part of PeachPy package and is licensed under the Simplified BSD license.
+#    See license.rst for the full text of the license.
+
+from enum import IntEnum
+
+
+class MachineType(IntEnum):
+    # Machine-independent
+    unknown = 0
+    # IA32 (x86)
+    x86 = 0x14C
+    # x86-64 (AMD64, Intel64, x64)
+    x86_64 = 0x8664
+    # IA64 (Itanium)
+    ia64 = 0x200
+    # ARM
+    arm = 0x1C0
+    # ARMv7 (Thumb mode only)
+    armnt = 0x1C4
+    # ARMv8 AArch64
+    arm64 = 0xAA64
+    # EFI bytecode
+    efi_bytecode = 0xEBC
+
+
+class Image:
+    file_header_size = 20
+
+    def __init__(self, abi, source=None):
+        from nervapy.formats.mscoff.section import StringTable
+
+        self.abi = abi
+        self.sections = list()
+        self.symbols = list()
+        self.string_table = StringTable()
+
+    def add_section(self, section):
+        from nervapy.formats.mscoff.section import Section
+
+        assert isinstance(section, Section)
+
+        self.sections.append(section)
+
+    def add_symbol(self, symbol):
+        from nervapy.formats.mscoff.symbol import Symbol
+
+        assert isinstance(symbol, Symbol)
+
+        self.symbols.append(symbol)
+
+    def encode(self):
+        from nervapy.encoder import Encoder
+
+        encoder = Encoder(self.abi.endianness)
+
+        # Collect names that need to be encoded in the string table
+        import codecs
+
+        for section in self.sections:
+            if len(codecs.encode(section.name, "utf8")) > 8:
+                self.string_table.add(section.name)
+        for symbol in self.symbols:
+            if len(codecs.encode(symbol.name, "utf8")) > 8:
+                self.string_table.add(symbol.name)
+
+        # Layout sections offsets
+        from nervapy.formats.mscoff.section import Section
+
+        section_offset_map = dict()
+        symbol_table_offset = (
+            Image.file_header_size + len(self.sections) * Section.header_size
+        )
+        data_offset = symbol_table_offset + self.string_table.size
+        for symbol in self.symbols:
+            data_offset += symbol.entry_size
+        for section in self.sections:
+            section_offset_map[section] = data_offset
+            data_offset += section.content_size
+
+        # Layout section relocations
+        from nervapy.formats.mscoff.symbol import Relocation
+
+        section_relocations_map = dict()
+        for section in self.sections:
+            if section.relocations:
+                section_relocations_map[section] = data_offset
+                data_offset += Relocation.entry_size * len(section.relocations)
+
+        section_index_map = {
+            section: index + 1 for index, section in enumerate(self.sections)
+        }
+        symbol_index_map = {symbol: index for index, symbol in enumerate(self.symbols)}
+
+        # Write file header
+        timestamp = 0
+        file_flags = 0
+        data = (
+            encoder.uint16(self.abi.mscoff_machine_type)
+            + encoder.uint16(len(self.sections))
+            + encoder.uint32(timestamp)
+            + encoder.uint32(symbol_table_offset)
+            + encoder.uint32(len(self.symbols))
+            + encoder.uint16(0)
+            + encoder.uint16(file_flags)
+        )
+
+        # Write section headers
+        for section in self.sections:
+            data += section.encode_header(
+                encoder,
+                self.string_table._strings,
+                section_offset_map[section],
+                section_relocations_map.get(section),
+            )
+
+        # Write symbol table and string table (immediately follows symbols table)
+        for symbol in self.symbols:
+            data += symbol.encode_entry(
+                encoder, self.string_table._strings, section_index_map
+            )
+        data += self.string_table.encode()
+
+        # Write section content
+        for section in self.sections:
+            data += section.content
+
+        # Write section relocations
+        for section in self.sections:
+            for relocation in section.relocations:
+                data += relocation.encode_entry(encoder, symbol_index_map)
+
+        return data