ghidraxdbg 12.0__py3-none-any.whl

ghidraxdbg/__init__.py

@@ -0,0 +1,17 @@
+## ###
+# IP: GHIDRA
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+##
+
+from . import util, commands, methods, hooks

ghidraxdbg/arch.py

@@ -0,0 +1,236 @@
+## ###
+# IP: GHIDRA
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+##
+from typing import Dict, List, Optional, Tuple
+
+from ghidratrace.client import Address, RegVal
+
+from . import util
+
+
+language_map: Dict[str, List[str]] = {
+    'x86_32': ['x86:LE:32:default'],
+    'x86_64': ['x86:LE:64:default']
+}
+
+data64_compiler_map: Dict[Optional[str], str] = {
+    None: 'pointer64',
+}
+
+x86_compiler_map: Dict[Optional[str], str] = {
+    'windows': 'windows',
+    'Cygwin': 'windows',
+    'default': 'windows',
+}
+
+default_compiler_map: Dict[Optional[str], str] = {
+    'windows': 'default',
+}
+
+windows_compiler_map: Dict[Optional[str], str] = {
+    'windows': 'windows',
+}
+
+compiler_map : Dict[str, Dict[Optional[str], str]]= {
+    'DATA:BE:64:default': data64_compiler_map,
+    'DATA:LE:64:default': data64_compiler_map,
+    'x86:LE:32:default': x86_compiler_map,
+    'x86:LE:64:default': x86_compiler_map
+}
+
+
+def get_arch() -> str:
+    try:
+        type = str(util.dbg.get_actual_processor_type())
+    except Exception as e:
+        print(f"Error getting actual processor type: {e}")
+        return "Unknown"
+    if type == "32":
+        return "x86_32"
+    if type == "64":
+        return "x86_64"
+    if type == None:
+        return "x86_64"
+    return "Unknown"
+
+
+def get_endian() -> str:
+    parm = util.get_convenience_variable('endian')
+    if parm != 'auto':
+        return parm
+    return 'little'
+
+
+def get_osabi() -> str:
+    parm = util.get_convenience_variable('osabi')
+    if not parm in ['auto', 'default']:
+        return parm
+    try:
+        os = "Windows" #util.dbg.cmd("vertarget")
+        if "Windows" not in os:
+            return "default"
+    except Exception:
+        print("Error getting target OS/ABI")
+        pass
+    return "windows"
+
+
+def compute_ghidra_language() -> str:
+    # First, check if the parameter is set
+    lang = util.get_convenience_variable('ghidra-language')
+    if lang != 'auto':
+        return lang
+
+    # Get the list of possible languages for the arch. We'll need to sift
+    # through them by endian and probably prefer default/simpler variants. The
+    # heuristic for "simpler" will be 'default' then shortest variant id.
+    arch = get_arch()
+    endian = get_endian()
+    lebe = ':BE:' if endian == 'big' else ':LE:'
+    if not arch in language_map:
+        return 'DATA' + lebe + '64:default'
+    langs = language_map[arch]
+    matched_endian = sorted(
+        (l for l in langs if lebe in l),
+        key=lambda l: 0 if l.endswith(':default') else len(l)
+    )
+    if len(matched_endian) > 0:
+        return matched_endian[0]
+    # NOTE: I'm disinclined to fall back to a language match with wrong endian.
+    return 'DATA' + lebe + '64:default'
+
+
+def compute_ghidra_compiler(lang: str) -> str:
+    # First, check if the parameter is set
+    comp = util.get_convenience_variable('ghidra-compiler')
+    if comp != 'auto':
+        return comp
+
+    # Check if the selected lang has specific compiler recommendations
+    if not lang in compiler_map:
+        print(f"{lang} not found in compiler map")
+        return 'default'
+    comp_map = compiler_map[lang]
+    if comp_map == data64_compiler_map:
+        print(f"Using the DATA64 compiler map")
+    osabi = get_osabi()
+    if osabi in comp_map:
+        return comp_map[osabi]
+    if None in comp_map:
+        return comp_map[None]
+    print(f"{osabi} not found in compiler map")
+    return 'default'
+
+
+def compute_ghidra_lcsp() -> Tuple[str, str]:
+    lang = compute_ghidra_language()
+    comp = compute_ghidra_compiler(lang)
+    return lang, comp
+
+
+class DefaultMemoryMapper(object):
+
+    def __init__(self, defaultSpace: str) -> None:
+        self.defaultSpace = defaultSpace
+
+    def map(self, proc: int, offset: int) -> Tuple[str, Address]:
+        space = self.defaultSpace
+        return self.defaultSpace, Address(space, offset)
+
+    def map_back(self, proc: int, address: Address) -> int:
+        if address.space == self.defaultSpace:
+            return address.offset
+        raise ValueError(f"Address {address} is not in process {proc}")
+
+
+DEFAULT_MEMORY_MAPPER = DefaultMemoryMapper('ram')
+
+memory_mappers: Dict[str, DefaultMemoryMapper] = {}
+
+
+def compute_memory_mapper(lang: str) -> DefaultMemoryMapper:
+    if not lang in memory_mappers:
+        return DEFAULT_MEMORY_MAPPER
+    return memory_mappers[lang]
+
+
+class DefaultRegisterMapper(object):
+
+    def __init__(self, byte_order: str) -> None:
+        if not byte_order in ['big', 'little']:
+            raise ValueError("Invalid byte_order: {}".format(byte_order))
+        self.byte_order = byte_order
+
+    def map_name(self, proc: int, name: str):
+        return name
+
+    def map_value(self, proc: int, name: str, value: int):
+        try:
+            # TODO: this seems half-baked
+            av = value.to_bytes(8, "big")
+        except Exception:
+            raise ValueError("Cannot convert {}'s value: '{}', type: '{}'"
+                             .format(name, value, type(value)))
+        return RegVal(self.map_name(proc, name), av)
+
+    def map_name_back(self, proc: int, name: str) -> str:
+        return name
+
+    def map_value_back(self, proc: int, name: str, value: bytes):
+        return RegVal(self.map_name_back(proc, name), value)
+
+
+class Intel_x86_64_RegisterMapper(DefaultRegisterMapper):
+
+    def __init__(self):
+        super().__init__('little')
+
+    def map_name(self, proc, name):
+        if name is None:
+            return 'UNKNOWN'
+        if name == 'efl':
+            return 'rflags'
+        if name.startswith('zmm'):
+            # Ghidra only goes up to ymm, right now
+            return 'ymm' + name[3:]
+        return super().map_name(proc, name)
+
+    def map_value(self, proc, name, value):
+        rv = super().map_value(proc, name, value)
+        if rv.name.startswith('ymm') and len(rv.value) > 32:
+            return RegVal(rv.name, rv.value[-32:])
+        return rv
+
+    def map_name_back(self, proc, name):
+        if name == 'rflags':
+            return 'eflags'
+
+
+DEFAULT_BE_REGISTER_MAPPER = DefaultRegisterMapper('big')
+DEFAULT_LE_REGISTER_MAPPER = DefaultRegisterMapper('little')
+
+register_mappers = {
+    'x86:LE:632:default': DEFAULT_LE_REGISTER_MAPPER,
+    'x86:LE:64:default': Intel_x86_64_RegisterMapper()
+}
+
+
+def compute_register_mapper(lang: str)-> DefaultRegisterMapper:
+    if not lang in register_mappers:
+        if ':BE:' in lang:
+            return DEFAULT_BE_REGISTER_MAPPER
+        if ':LE:' in lang:
+            return DEFAULT_LE_REGISTER_MAPPER
+    return register_mappers[lang]