Merge pull request #975 from xwings/dev

baremetal, interpreter and gpos now formed

Author: xwings

qiling/core.py

@@ -19,7 +19,7 @@
     from .hw.hw import QlHwManager
     from .loader.loader import QlLoader
 
-from .const import QL_ARCH_ENDIAN, QL_ENDIAN, QL_OS, QL_VERBOSE, QL_ARCH_INTERPRETER, QL_ARCH_BAREMETAL
+from .const import QL_ARCH_ENDIAN, QL_ENDIAN, QL_OS, QL_VERBOSE, QL_ARCH_INTERPRETER, QL_ARCH_BAREMETAL, QL_OS_ALL
 from .exception import QlErrorFileNotFound, QlErrorArch, QlErrorOsType, QlErrorOutput
 from .utils import *
 from .core_struct import QlCoreStructs
@@ -68,9 +68,10 @@ def __init__(
         self._code = code
         self._ostype = ostype
         self._archtype = archtype
-        self._interpreter = False,
-        self._baremetal = False,
-        self._archendian = None
+        self._interpreter = False
+        self._baremetal = False
+        self._gpos = False
+        self._archendian = QL_ENDIAN.EL
         self._archbit = None
         self._pointersize = None
         self._profile = profile
@@ -107,14 +108,12 @@ def __init__(
         self.count = None
         self._initial_sp = None
 
-
         """
         Qiling Framework Core Engine
         """
         ###############
         # code_exec() #
         ###############
-
         if self._code or (self._archtype and type(self._archtype) == str):
             if (self._archtype and type(self._archtype) == str):
                 self._archtype= arch_convert(self._archtype.lower())
@@ -125,35 +124,32 @@ def __init__(
                 self._ostype = ostype_convert(self._ostype.lower())
 
             if self._code == None:
-                self._code = "qiling"
+                self._code = "qilingcode"
             if self._argv is None:
                 self._argv = ["qilingcode"]
             if self._rootfs is None:
                 self._rootfs = "."
 
         self._interpreter = True if self._archtype in (QL_ARCH_INTERPRETER) else False
         self._baremetal = True if self._archtype in (QL_ARCH_BAREMETAL) else False
+        self._path = (str(self._argv[0]))
+        self._targetname = ntpath.basename(self._argv[0])
 
-        # file check
-        if self._code is None:
+        ##############
+        # File check #
+        ##############
+        if (not self._interpreter and not self._baremetal) and self._code == None:
             if not os.path.exists(str(self._argv[0])):
                 raise QlErrorFileNotFound("Target binary not found: %s" %(self._argv[0]))
             if not os.path.exists(self._rootfs):
                 raise QlErrorFileNotFound("Target rootfs not found")
-
-        self._path = (str(self._argv[0]))
-        self._targetname = ntpath.basename(self._argv[0])
-
-        ##########
-        # Loader #
-        ##########
-        if self._code is None:
+        
             guessed_archtype, guessed_ostype, guessed_archendian = ql_guess_emu_env(self._path)
+            
             if self._ostype is None:
                 self._ostype = guessed_ostype
             if self._archtype is None:
                 self._archtype = guessed_archtype
-            if self.archendian is None:
                 self._archendian = guessed_archendian
 
             if not ql_is_valid_ostype(self._ostype):
@@ -162,6 +158,13 @@ def __init__(
             if not ql_is_valid_arch(self._archtype):
                 raise QlErrorArch("Invalid Arch %s" % self._archtype)
 
+
+         
+            
+        #######################################
+        # Loader and General Purpose OS check #
+        #######################################
+        self._gpos = True if self._ostype in (QL_OS_ALL) else False 
         self._loader = loader_setup(self._ostype, self)
 
         #####################
@@ -170,7 +173,6 @@ def __init__(
         self._profile, debugmsg = profile_setup(self)
 
         # Log's configuration
-
         self._log_file_fd, self._log_filter = ql_setup_logger(self,
                                                               self._log_file,
                                                               self._console,
@@ -189,25 +191,23 @@ def __init__(
         self._archbit = ql_get_arch_bits(self._archtype)
         self._pointersize = (self.archbit // 8)  
 
-        # Endian for shellcode needs to set manually
-        if self._code:
-            self._archendian = QL_ENDIAN.EL
-            if bigendian == True and self._archtype in (QL_ARCH_ENDIAN):
-                self._archendian = QL_ENDIAN.EB
+ 
+        if bigendian == True and self._archtype in (QL_ARCH_ENDIAN):
+            self._archendian = QL_ENDIAN.EB
+
 
         # Once we finish setting up archendian and arcbit, we can init QlCoreStructs.
         QlCoreStructs.__init__(self, self._archendian, self._archbit)
 
         ##############
         # Components #
         ##############
-
-        if not self._interpreter:
+        if self._gpos or self._baremetal:
             self._mem = component_setup("os", "memory", self)
             self._reg = component_setup("arch", "register", self)
-        
-        if self._baremetal:   
-            self._hw  = component_setup("hw", "hw", self)
+
+            if self._baremetal:   
+                self._hw  = component_setup("hw", "hw", self)
 
         self._arch = arch_setup(self.archtype, self)
 
@@ -216,29 +216,27 @@ def __init__(
         QlCoreHooks.__init__(self, self.uc)
 
         # Setup Outpt
-        if not self._interpreter:
+        if self._gpos or self._baremetal:
             self.arch.utils.setup_output()
 
-        if not self._interpreter:
-            if not self._baremetal:
-                self._os = os_setup(self.archtype, self.ostype, self)
+        if self._gpos:
+            self._os = os_setup(self.archtype, self.ostype, self)
 
-                if stdin is not None:
-                    self._os.stdin = stdin
+            if stdin is not None:
+                self._os.stdin = stdin
 
-                if stdout is not None:
-                    self._os.stdout = stdout
+            if stdout is not None:
+                self._os.stdout = stdout
 
-                if stderr is not None:
-                    self._os.stderr = stderr
+            if stderr is not None:
+                self._os.stderr = stderr
 
         # Run the loader
         self.loader.run()
 
-        if not self._interpreter:
-            if not self._baremetal:
-                # Add extra guard options when configured to do so
-                self._init_stop_guard()    
+        if self._gpos:
+            # Add extra guard options when configured to do so
+            self._init_stop_guard()    
 
     #####################
     # Qiling Components #
@@ -655,6 +653,18 @@ def baremetal(self, b):
         self._baremetal = b
 
 
+    @property
+    def gpos(self) -> bool:
+        """ Raw uc instance.
+
+            Type: Ucgit
+        """
+        return self._gpos
+
+    @gpos.setter
+    def gpos(self, o):
+        self._gpos = o
+
     @property
     def stop_options(self) -> "QlStopOptions":
         """ The stop options configured:
@@ -736,33 +746,25 @@ def run(self, begin=None, end=None, timeout=0, count=0, code = None):
         if self._debugger != False and self._debugger != None:
             self._debugger = debugger_setup(self._debugger, self)
 
-        if not self.interpreter:
-            if not self.baremetal:
-                self.write_exit_trap()
-                # patch binary
-                self.__enable_bin_patch()
-
-                # emulate the binary
-                self.os.run()
-
         if self.interpreter:
-            if code == None:
-                return self.arch.run(self._code)
-            else:
-                return self.arch.run(code) 
-        
-        if self.baremetal:
+            return self.arch.run(code)
+        elif self.baremetal:
             self.__enable_bin_patch()
             if self.count <= 0:
                 self.count = -1
-            self.arch.run(count=self.count, end=self.exit_point)
-        
+            self.arch.run(count=self.count, end=self.exit_point)        
+        else:
+            self.write_exit_trap()
+            # patch binary
+            self.__enable_bin_patch()
+            # emulate the binary
+            self.os.run()
+
         # run debugger
         if self._debugger != False and self._debugger != None:
             self._debugger.run()
 
 
-
     # patch code to memory address
     def patch(self, addr, code, file_name=b''):
         if file_name == b'':

qiling/debugger/gdb/gdb.py

@@ -51,11 +51,10 @@ def __init__(self, ql: Qiling, ip: str = '127.0.01', port: int = 9999):
         self.ip = ip
         self.port = port
 
-
         if self.ql.baremetal:
             load_address = self.ql.loader.load_address
             exit_point = load_address + os.path.getsize(ql.path)
-        elif self.ql.code:
+        elif self.ql.code and ql.gpos:
             load_address = self.ql.os.entry_point
             exit_point = load_address + len(ql.code)
         else:

tests/test_elf.py

@@ -480,13 +480,13 @@ def test_elf_linux_arm64_static(self):
         del ql
 
 
-    def test_elf_linux_mips32_static(self):
+    def test_elf_linux_mips32eb_static(self):
        ql = Qiling(["../examples/rootfs/mips32_linux/bin/mips32_hello_static"], "../examples/rootfs/mips32_linux")
        ql.run()
        del ql
 
 
-    def test_elf_linux_mips32(self):
+    def test_elf_linux_mips32eb(self):
         def random_generator(size=6, chars=string.ascii_uppercase + string.digits):
             return ''.join(random.choice(chars) for x in range(size))