Merge pull request #962 from elicn/misc-improv

elicn · web-flow · commit f0f558f529a7 · 2021-10-25T07:40:35.000+03:00
Clean and tidy-up various modules
diff --git a/qiling/const.py b/qiling/const.py
@@ -3,8 +3,8 @@
 # Cross Platform and Multi Architecture Advanced Binary Emulation Framework
 #
 
-from enum import EnumMeta, IntEnum
-from typing import Mapping, TypeVar
+from enum import Enum, IntEnum
+from typing import Any, Mapping, Type
 
 class QL_ENDIAN(IntEnum):
     EL = 1
@@ -69,9 +69,7 @@ class QL_INTERCEPT(IntEnum):
 QL_HOOK_BLOCK = 0b0001
 QL_CALL_BLOCK = 0b0010
 
-__QL_CE = TypeVar('__QL_CE', QL_DEBUGGER, QL_ARCH, QL_OS, QL_VERBOSE)
-
-def __reverse_enum(e: EnumMeta) -> Mapping[str, __QL_CE]:
+def __reverse_enum(e: Type[Enum]) -> Mapping[str, Any]:
     '''Create a reverse mapping for an enum.
     '''
 
diff --git a/qiling/debugger/gdb/gdb.py b/qiling/debugger/gdb/gdb.py
@@ -493,7 +493,7 @@ def handle_q(subcmd):
                 elif subcmd.startswith('Xfer:features:read'):
                     xfercmd_file    = subcmd.split(':')[3]
                     xfercmd_abspath = os.path.dirname(os.path.abspath(__file__))
-                    xml_folder      = arch_convert_str(self.ql.archtype)
+                    xml_folder      = arch_convert_str(self.ql.archtype).lower()
                     xfercmd_file    = os.path.join(xfercmd_abspath,"xml",xml_folder, xfercmd_file)                        
 
                     if os.path.exists(xfercmd_file) and self.ql.ostype is not QL_OS.WINDOWS:
diff --git a/qiling/extensions/trace.py b/qiling/extensions/trace.py
@@ -8,9 +8,7 @@
 
 from capstone import Cs, CsInsn, CS_OP_IMM, CS_OP_MEM, CS_OP_REG
 from capstone.x86 import X86Op
-from capstone.x86_const import X86_INS_LEA
-
-from unicorn.x86_const import UC_X86_REG_INVALID, UC_X86_REG_RIP
+from capstone.x86_const import X86_INS_LEA, X86_REG_INVALID, X86_REG_RIP
 
 from qiling import Qiling
 
@@ -54,14 +52,14 @@ def __to_trace_line(record: TraceRecord, symsmap: Mapping[int, str] = {}) -> str
 	# current instruction instead of the next one.
 	#
 	# here we patch rip value recorded in state to point to the next instruction boundary
-	state = tuple((reg, val + insn.size if reg == UC_X86_REG_RIP else val) for reg, val in state)
+	state = tuple((reg, val + insn.size if reg == X86_REG_RIP else val) for reg, val in state)
 
 	def __read_reg(reg: int) -> int:
 		"""[internal] Read a register value from the recorded state. Only registers that were
 		referenced by the current instruction can be read.
 		"""
 
-		return 0 if reg == UC_X86_REG_INVALID else next(v for r, v in state if r == reg)
+		return 0 if reg == X86_REG_INVALID else next(v for r, v in state if r == reg)
 
 	def __resolve(address: int) -> str:
 		"""[internal] Find the symbol that matches to the specified address (if any).
@@ -114,11 +112,10 @@ def __parse_op(op: X86Op) -> str:
 		# unexpected op type
 		raise RuntimeError
 
-	opcode = ''.join(f'{b:02x}' for b in insn.bytes)
 	operands = ', '.join(__parse_op(o) for o in insn.operands)
 	reads = ', '.join(f'{insn.reg_name(reg)} = {val:#x}' for reg, val in state)
 
-	return f'{insn.address:08x} | {opcode:24s} {insn.mnemonic:10} {operands:56s} | {reads}'
+	return f'{insn.address:08x} | {insn.bytes.hex():24s} {insn.mnemonic:10} {operands:56s} | {reads}'
 
 def enable_full_trace(ql: Qiling):
 	"""Enable instruction-level tracing.
diff --git a/qiling/os/path.py b/qiling/os/path.py
@@ -3,16 +3,12 @@
 # Cross Platform and Multi Architecture Advanced Binary Emulation Framework
 #
 
-from typing import Any, Mapping
-import ctypes, os, uuid
-
-from pathlib import Path, PurePosixPath, PureWindowsPath, PosixPath, WindowsPath
-from unicorn import UcError
+import os
+from typing import Union
+from pathlib import Path, PurePath, PurePosixPath, PureWindowsPath
 
 from qiling import Qiling
-from qiling.os.windows.wdk_const import *
-from qiling.os.windows.structs import *
-from qiling.utils import verify_ret
+from qiling.const import QL_OS, QL_OS_POSIX
 
 # OH-MY-WIN32 !!!
 # Some codes from cygwin.
@@ -25,27 +21,24 @@ class QlPathManager:
     def __init__(self, ql: Qiling, cwd: str):
         self.ql = ql
         self._cwd = cwd
-    
+
     @property
-    def cwd(self):
+    def cwd(self) -> str:
         return self._cwd
-    
+
     @cwd.setter
-    def cwd(self, c):
-        if c[0] != "/":
-            self.ql.log.warning(f"Sanity check: cur_path doesn't start with a /!")
+    def cwd(self, c: str) -> None:
+        if not c.startswith('/'):
+            self.ql.log.warning(f'Sanity check: path does not start with a forward slash "/"')
+
         self._cwd = c
 
     @staticmethod
-    def normalize(path):
-        if type(path) is PurePosixPath:
-            normalized_path = PurePosixPath()
-        elif type(path) is PureWindowsPath:
-            normalized_path = PureWindowsPath()
-        elif type(path) is PosixPath:
-            normalized_path = PosixPath()
-        elif type(path) is WindowsPath:
-            normalized_path = WindowsPath()
+    def normalize(path: Union[Path, PurePath]) -> Union[Path, PurePath]:
+        # expected types: PosixPath, PurePosixPath, WindowsPath, PureWindowsPath
+        assert isinstance(path, (Path, PurePath)), f'did not expect {type(path).__name__!r} here'
+
+        normalized_path = type(path)()
 
         # remove anchor (necessary for Windows UNC paths) and convert to relative path
         if path.is_absolute():
@@ -64,101 +57,103 @@ def normalize(path):
         return normalized_path
 
     @staticmethod
-    def convert_win32_to_posix(rootfs, cwd, path):
-        # rootfs is a concrete path.
-        rootfs = Path(rootfs)
-        # cwd and path are pure paths
-        cwd = PurePosixPath(cwd[1:])
+    def convert_win32_to_posix(rootfs: Union[str, Path], cwd: str, path: str) -> Path:
+        _rootfs = Path(rootfs)
+        _cwd = PurePosixPath(cwd[1:])
 
-        result = None
         # Things are complicated here.
         # See https://docs.microsoft.com/zh-cn/windows/win32/fileio/naming-a-file?redirectedfrom=MSDN
         if PureWindowsPath(path).is_absolute():
-            if (len(path) >= 2 and path[0] == '\\' and path[1] == '\\') or \
-                (len(path) >= 3 and path[0].isalpha() and path[2] == '\\'): # \\.\PhysicalDrive0 or \\Server\Share\Directory or X:\
+            if (len(path) >= 2 and path.startswith(r'\\')) or \
+                (len(path) >= 3 and path[0].isalpha() and path[1:3] == ':\\'): # \\.\PhysicalDrive0 or \\Server\Share\Directory or X:\
                 # UNC path should be handled in fs mapping. If not, append it to rootfs directly.
                 pw = PureWindowsPath(path)
-                result = rootfs / QlPathManager.normalize(pw)
+                result = _rootfs / QlPathManager.normalize(pw)
             else:
                 # code should never reach here.
-                result = rootfs / QlPathManager.normalize(path)
+                result = _rootfs / QlPathManager.normalize(path)
         else:
             if len(path) >= 3 and path[:3] == r'\\?' or path[:3] == r'\??': # \??\ or \\?\ or \Device\..
                 # Similair to \\.\, it should be handled in fs mapping.
                 pw = PureWindowsPath(path)
-                result = rootfs / QlPathManager.normalize(cwd / pw.relative_to(pw.anchor).as_posix())
+                result = _rootfs / QlPathManager.normalize(_cwd / pw.relative_to(pw.anchor).as_posix())
             else:
                 # a normal relative path
-                result = rootfs / QlPathManager.normalize(cwd / PureWindowsPath(path).as_posix())
+                result = _rootfs / QlPathManager.normalize(_cwd / PureWindowsPath(path).as_posix())
+
         return result
 
     @staticmethod
-    def convert_posix_to_win32(rootfs, cwd, path):
-        # rootfs is a concrete path.
-        rootfs = Path(rootfs)
-        # cwd and path are pure paths
-        cwd = PurePosixPath(cwd[1:])
-        path = PurePosixPath(path)
-        if path.is_absolute():
-            return rootfs / QlPathManager.normalize(path)
+    def convert_posix_to_win32(rootfs: Union[str, Path], cwd: str, path: str) -> Path:
+        _rootfs = Path(rootfs)
+        _cwd = PurePosixPath(cwd[1:])
+        _path = PurePosixPath(path)
+
+        if _path.is_absolute():
+            return _rootfs / QlPathManager.normalize(_path)
         else:
-            return rootfs / QlPathManager.normalize(cwd / path)
+            return _rootfs / QlPathManager.normalize(_cwd / _path)
 
     @staticmethod
-    def convert_for_native_os(rootfs, cwd, path):
-        rootfs = Path(rootfs)
-        cwd = PurePosixPath(cwd[1:])
-        path = Path(path)
-        if path.is_absolute():
-            return rootfs / QlPathManager.normalize(path)
+    def convert_for_native_os(rootfs: Union[str, Path], cwd: str, path: str) -> Path:
+        _rootfs = Path(rootfs)
+        _cwd = PurePosixPath(cwd[1:])
+        _path = Path(path)
+
+        if _path.is_absolute():
+            return _rootfs / QlPathManager.normalize(_path)
         else:
-            return rootfs / QlPathManager.normalize(cwd / path.as_posix())
+            return _rootfs / QlPathManager.normalize(_cwd / _path.as_posix())
 
-    def convert_path(self, rootfs, cwd, path):
-        if  (self.ql.ostype == self.ql.platform ) \
-            or (self.ql.ostype in [QL_OS.LINUX, QL_OS.MACOS] and self.ql.platform in [QL_OS.LINUX, QL_OS.MACOS]):
+    def convert_path(self, rootfs: Union[str, Path], cwd: str, path: str) -> Path:
+        emulated_os = self.ql.ostype
+        hosting_os = self.ql.platform
+
+        # emulated os and hosting platform are of the same type
+        if  (emulated_os == hosting_os) or (emulated_os in QL_OS_POSIX and hosting_os in QL_OS_POSIX):
             return QlPathManager.convert_for_native_os(rootfs, cwd, path)
-        elif self.ql.ostype in [QL_OS.LINUX, QL_OS.MACOS] and self.ql.platform == QL_OS.WINDOWS:
+
+        elif emulated_os in QL_OS_POSIX and hosting_os == QL_OS.WINDOWS:
             return QlPathManager.convert_posix_to_win32(rootfs, cwd, path)
-        elif self.ql.ostype == QL_OS.WINDOWS and self.ql.platform in [QL_OS.LINUX, QL_OS.MACOS]:
+
+        elif emulated_os == QL_OS.WINDOWS and hosting_os in QL_OS_POSIX:
             return QlPathManager.convert_win32_to_posix(rootfs, cwd, path)
+
         else:
-            # Fallback
             return QlPathManager.convert_for_native_os(rootfs, cwd, path)
-    
-    def transform_to_link_path(self, path):
-        rootfs = self.ql.rootfs
-        real_path  = self.convert_path(rootfs, self.cwd, path)
+
+    def transform_to_link_path(self, path: str) -> str:
+        real_path = self.convert_path(self.ql.rootfs, self.cwd, path)
 
         return str(real_path.absolute())
 
-    def transform_to_real_path(self, path):
-        from types import FunctionType
+    def transform_to_real_path(self, path: str) -> str:
+        real_path = self.convert_path(self.ql.rootfs, self.cwd, path)
 
-        rootfs = self.ql.rootfs
-        real_path = self.convert_path(rootfs, self.cwd, path)
-        
         if os.path.islink(real_path):
             link_path = Path(os.readlink(real_path))
+
             if not link_path.is_absolute():
                 real_path = Path(os.path.join(os.path.dirname(real_path), link_path))
 
             # resolve multilevel symbolic link
             if not os.path.exists(real_path):
                 path_dirs = link_path.parts
+
                 if link_path.is_absolute():
                     path_dirs = path_dirs[1:]
 
-                for i in range(0, len(path_dirs)-1):
+                for i in range(len(path_dirs) - 1):
                     path_prefix = os.path.sep.join(path_dirs[:i+1])
                     real_path_prefix = self.transform_to_real_path(path_prefix)
                     path_remain = os.path.sep.join(path_dirs[i+1:])
                     real_path = Path(os.path.join(real_path_prefix, path_remain))
+
                     if os.path.exists(real_path):
                         break
-            
+
         return str(real_path.absolute())
 
     # The `relative path` here refers to the path which is relative to the rootfs.
-    def transform_to_relative_path(self, path):
+    def transform_to_relative_path(self, path: str) -> str:
         return str(Path(self.cwd) / path)
diff --git a/qiling/utils.py b/qiling/utils.py
