hilda 2.0.6__tar.gz → 2.0.10__tar.gz

{hilda-2.0.6 → hilda-2.0.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hilda
-Version: 2.0.6
+Version: 2.0.10
 Summary: LLDB wrapped and empowered by iPython's features
 Author-email: doronz88 <doron88@gmail.com>, matan <matan1008@gmail.com>, netanel cohen <netanelc305@protonmail.com>
 Maintainer-email: doronz88 <doron88@gmail.com>, matan <matan1008@gmail.com>, netanel cohen <netanelc305@protonmail.com>
@@ -207,38 +207,39 @@ Here is a gist of methods you can access from `p`:
   - Call function at given address with given parameters
 - `monitor`
   - Monitor every time a given address is called
+
       The following options are available:
 
       ```
       regs={reg1: format}
-      will print register values
+          will print register values
   
-               Available formats:
-                   x: hex
-                   s: string
-                   cf: use CFCopyDescription() to get more informative description of the object
-                   po: use LLDB po command
-                   User defined function, will be called like `format_function(hilda_client, value)`.
+          Available formats:
+              x: hex
+              s: string
+              cf: use CFCopyDescription() to get more informative description of the object
+              po: use LLDB po command
+              User defined function, will be called like `format_function(hilda_client, value)`.
   
-               For example:
-                   regs={'x0': 'x'} -> x0 will be printed in HEX format
-           expr={lldb_expression: format}
-               lldb_expression can be for example '$x0' or '$arg1'
-               format behaves just like 'regs' option
-           retval=format
-               Print function's return value. The format is the same as regs format.
-           stop=True
-               force a stop at every hit
-           bt=True
-               print backtrace
-           cmd=[cmd1, cmd2]
-               run several LLDB commands, one by another
-           force_return=value
-               force a return from function with the specified value
-           name=some_value
-               use `some_name` instead of the symbol name automatically extracted from the calling frame
-           override=True
-               override previous break point at same location
+              For example:
+                  regs={'x0': 'x'} -> x0 will be printed in HEX format
+      expr={lldb_expression: format}
+          lldb_expression can be for example '$x0' or '$arg1'
+          format behaves just like 'regs' option
+      retval=format
+          Print function's return value. The format is the same as regs format.
+      stop=True
+          force a stop at every hit
+      bt=True
+          print backtrace
+      cmd=[cmd1, cmd2]
+          run several LLDB commands, one by another
+      force_return=value
+          force a return from function with the specified value
+      name=some_value
+          use `some_name` instead of the symbol name automatically extracted from the calling frame
+      override=True
+          override previous break point at same location
       ```
 
 - `show_current_source`
@@ -305,6 +306,8 @@ Here is a gist of methods you can access from `p`:
   - sets the currently selected thread, which is used in other parts of the program, such as displaying disassembly or
       checking registers.
       This ensures the application focuses on the specified thread for these operations.
+- `wait_for_module`
+  - Wait for a module to be loaded (`dlopen`) by checking if given expression is contained within its filename
 
 All these methods are available from the global `p` within the newly created IPython shell. In addition, you may invoke any of the exported APIs described in the [Python API](#python-api)
 

{hilda-2.0.6 → hilda-2.0.10}/README.md

@@ -150,38 +150,39 @@ Here is a gist of methods you can access from `p`:
   - Call function at given address with given parameters
 - `monitor`
   - Monitor every time a given address is called
+
       The following options are available:
 
       ```
       regs={reg1: format}
-      will print register values
+          will print register values
   
-               Available formats:
-                   x: hex
-                   s: string
-                   cf: use CFCopyDescription() to get more informative description of the object
-                   po: use LLDB po command
-                   User defined function, will be called like `format_function(hilda_client, value)`.
+          Available formats:
+              x: hex
+              s: string
+              cf: use CFCopyDescription() to get more informative description of the object
+              po: use LLDB po command
+              User defined function, will be called like `format_function(hilda_client, value)`.
   
-               For example:
-                   regs={'x0': 'x'} -> x0 will be printed in HEX format
-           expr={lldb_expression: format}
-               lldb_expression can be for example '$x0' or '$arg1'
-               format behaves just like 'regs' option
-           retval=format
-               Print function's return value. The format is the same as regs format.
-           stop=True
-               force a stop at every hit
-           bt=True
-               print backtrace
-           cmd=[cmd1, cmd2]
-               run several LLDB commands, one by another
-           force_return=value
-               force a return from function with the specified value
-           name=some_value
-               use `some_name` instead of the symbol name automatically extracted from the calling frame
-           override=True
-               override previous break point at same location
+              For example:
+                  regs={'x0': 'x'} -> x0 will be printed in HEX format
+      expr={lldb_expression: format}
+          lldb_expression can be for example '$x0' or '$arg1'
+          format behaves just like 'regs' option
+      retval=format
+          Print function's return value. The format is the same as regs format.
+      stop=True
+          force a stop at every hit
+      bt=True
+          print backtrace
+      cmd=[cmd1, cmd2]
+          run several LLDB commands, one by another
+      force_return=value
+          force a return from function with the specified value
+      name=some_value
+          use `some_name` instead of the symbol name automatically extracted from the calling frame
+      override=True
+          override previous break point at same location
       ```
 
 - `show_current_source`
@@ -248,6 +249,8 @@ Here is a gist of methods you can access from `p`:
   - sets the currently selected thread, which is used in other parts of the program, such as displaying disassembly or
       checking registers.
       This ensures the application focuses on the specified thread for these operations.
+- `wait_for_module`
+  - Wait for a module to be loaded (`dlopen`) by checking if given expression is contained within its filename
 
 All these methods are available from the global `p` within the newly created IPython shell. In addition, you may invoke any of the exported APIs described in the [Python API](#python-api)
 

{hilda-2.0.6 → hilda-2.0.10}/hilda/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '2.0.6'
-__version_tuple__ = version_tuple = (2, 0, 6)
+__version__ = version = '2.0.10'
+__version_tuple__ = version_tuple = (2, 0, 10)

{hilda-2.0.6 → hilda-2.0.10}/hilda/cli.py

@@ -53,7 +53,7 @@ def attach(name: Optional[str], pid: Optional[int], startup_files: List[str]) ->
     if name is not None:
         hilda_client = create_hilda_client_using_attach_by_name(name)
     elif pid is not None:
-        hilda_client = create_hilda_client_using_attach_by_pid(name)
+        hilda_client = create_hilda_client_using_attach_by_pid(pid)
     else:
         raise click.UsageError('You must specify a process name or pid')
     hilda_client.interact(startup_files=startup_files)

{hilda-2.0.6 → hilda-2.0.10}/hilda/hilda_client.py

@@ -58,7 +58,8 @@ GREETING = f"""
 <b>Hilda has been successfully loaded! 😎
 Usage:
  <span style="color: magenta">p</span>   Global to access all features.
- <span style="color: magenta">F1</span>  UI Show.
+ <span style="color: magenta">F1</span>  Show UI.
+ <span style="color: magenta">F2</span>  Toggle enabling of stdout & stderr.
  <span style="color: magenta">F7</span>  Step Into.
  <span style="color: magenta">F8</span>  Step Over.
  <span style="color: magenta">F9</span>  Continue.
@@ -92,6 +93,8 @@ class Configs:
         'doc': 'Whether to exclude NSObject during evaluation - reduce ipython autocomplete results.'})
     objc_verbose_monitor: bool = field(default=False, metadata={
         'doc': 'When set to True, using monitor() will automatically print objc methods arguments.'})
+    enable_stdout_stderr: bool = field(default=True, metadata={
+        'doc': 'When set to True, will enable process stdout and stderr.'})
 
     def __repr__(self):
         return self.__str__()
@@ -511,7 +514,8 @@ class HildaClient:
             :param dict options: User defined options.
             """
             bp = bp_loc.GetBreakpoint()
-            symbol = hilda.breakpoints[bp.id].address  # type: Symbol
+
+            symbol = hilda.symbol(hilda.frame.addr.GetLoadAddress(hilda.target))  # type: Symbol
 
             # by default, attempt to resolve the symbol name through lldb
             name = str(symbol.lldb_symbol)
@@ -1043,6 +1047,24 @@ class HildaClient:
 
         return value
 
+    def wait_for_module(self, expression: str) -> None:
+        """ Wait for a module to be loaded using `dlopen` by matching given expression """
+        self.log_info(f'Waiting for module name containing "{expression}" to be loaded')
+
+        def bp(client: HildaClient, frame, bp_loc, options) -> None:
+            loading_module_name = client.evaluate_expression('$arg1').peek_str()
+            client.log_info(f'Loading module: {loading_module_name}')
+            if expression not in loading_module_name:
+                client.cont()
+                return
+            client.finish()
+            client.log_info(f'Desired module has been loaded: {expression}. Process remains stopped')
+            bp = bp_loc.GetBreakpoint()
+            client.remove_hilda_breakpoint(bp.id)
+
+        self.bp('dlopen', bp)
+        self.cont()
+
     def interact(self, additional_namespace: Optional[typing.Mapping] = None,
                  startup_files: Optional[List[str]] = None) -> None:
         """ Start an interactive Hilda shell """
@@ -1070,6 +1092,10 @@ class HildaClient:
         sys.argv = ['a']
         IPython.start_ipython(config=ipython_config, user_ns=namespace)
 
+    def toggle_enable_stdout_stderr(self, *args) -> None:
+        self.configs.enable_stdout_stderr = not self.configs.enable_stdout_stderr
+        self.logger.info(f'Changed stdout and stderr status to: {self.configs.enable_stdout_stderr}')
+
     def __enter__(self) -> 'HildaClient':
         return self
 
@@ -1166,6 +1192,11 @@ class HildaClient:
         else:
             return f'{value:x} (unsupported format)'
 
+    @cached_property
+    def _object_identifier(self) -> Symbol:
+        return self.symbols.objc_getClass('VMUObjectIdentifier').objc_call('alloc').objc_call(
+            'initWithTask:', self.symbols.mach_task_self())
+
     @cached_property
     def _ks(self) -> Optional['Ks']:
         if not lldb.KEYSTONE_SUPPORT:

{hilda-2.0.6 → hilda-2.0.10}/hilda/ipython_extensions/keybindings.py

@@ -7,6 +7,7 @@ def load_ipython_extension(ipython):
     def register_keybindings():
         hilda = ipython.user_ns['p']
         keys_mapping = {Keys.F1: hilda.ui_manager.show,
+                        Keys.F2: hilda.toggle_enable_stdout_stderr,
                         Keys.F7: hilda.step_into,
                         Keys.F8: hilda.step_over,
                         Keys.F9: lambda _: (hilda.log_info('Sending continue'), hilda.cont()),

{hilda-2.0.6 → hilda-2.0.10}/hilda/launch_lldb.py

@@ -1,5 +1,6 @@
 import logging
 import os
+import sys
 from abc import ABC, abstractmethod
 from threading import Thread
 from typing import List, Optional
@@ -46,6 +47,20 @@ class LLDBListenerThread(Thread, ABC):
             return
         raise LLDBError(self.error.description)
 
+    def _process_stdout(self) -> None:
+        stdout = self.process.GetSTDOUT(1024)
+        while stdout:
+            if lldb.hilda_client is not None and lldb.hilda_client.configs.enable_stdout_stderr:
+                sys.stdout.write(stdout)
+            stdout = self.process.GetSTDOUT(1024)
+
+    def _process_stderr(self) -> None:
+        stderr = self.process.GetSTDERR(1024)
+        while stderr:
+            if lldb.hilda_client is not None and lldb.hilda_client.configs.enable_stdout_stderr:
+                sys.stderr.write(stderr)
+            stderr = self.process.GetSTDERR(1024)
+
     def run(self):
         event = lldb.SBEvent()
         last_state = lldb.eStateStopped
@@ -54,6 +69,13 @@ class LLDBListenerThread(Thread, ABC):
                 continue
             if not lldb.SBProcess.EventIsProcessEvent(event):
                 continue
+
+            event_type = event.GetType()
+            if event_type & lldb.SBProcess.eBroadcastBitSTDOUT:
+                self._process_stdout()
+            if event_type & lldb.SBProcess.eBroadcastBitSTDERR:
+                self._process_stderr()
+
             state = self.process.GetStateFromEvent(event)
             if state == lldb.eStateDetached:
                 logger.debug('Process Detached')

{hilda-2.0.6 → hilda-2.0.10}/hilda/symbol.py

@@ -104,6 +104,13 @@ class Symbol(int):
         """
         return self._client.symbols.CFCopyDescription(self).po()
 
+    @property
+    def name(self) -> str:
+        symbol_info = int(self._client.po(f'[{self._client._object_identifier} symbolForAddress:{self}]', '__int128'))
+        arg1 = symbol_info & 0xffffffffffffffff
+        arg2 = symbol_info >> 64
+        return self._client.symbols.CSSymbolGetName(arg1, arg2).peek_str()
+
     @contextmanager
     def change_item_size(self, new_item_size: int) -> None:
         """

{hilda-2.0.6 → hilda-2.0.10}/hilda/symbols_jar.py

@@ -139,15 +139,15 @@ class SymbolsJar(dict):
         :param args: given arguments for monitor command
         """
         for name, address in self.items():
-            args_c = args.copy()
+            options = args.copy()
             if name == '_client':
                 continue
             if self.__dict__['_client'].configs.objc_verbose_monitor:
                 arg_count = name.count(':')
                 if arg_count > 0:
-                    args_c['regs'] = {f'x{i + 2}': 'po' for i in range(arg_count)}
-            name = args_c.get('name', name)
-            address.monitor(name=name, **args_c)
+                    options['expr'] = {f'$arg{i + 3}': 'po' for i in range(arg_count)}
+            name = options.get('name', name)
+            address.monitor(name=name, **options)
 
     def startswith(self, exp, case_sensitive=True):
         """

{hilda-2.0.6 → hilda-2.0.10}/hilda.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hilda
-Version: 2.0.6
+Version: 2.0.10
 Summary: LLDB wrapped and empowered by iPython's features
 Author-email: doronz88 <doron88@gmail.com>, matan <matan1008@gmail.com>, netanel cohen <netanelc305@protonmail.com>
 Maintainer-email: doronz88 <doron88@gmail.com>, matan <matan1008@gmail.com>, netanel cohen <netanelc305@protonmail.com>
@@ -207,38 +207,39 @@ Here is a gist of methods you can access from `p`:
   - Call function at given address with given parameters
 - `monitor`
   - Monitor every time a given address is called
+
       The following options are available:
 
       ```
       regs={reg1: format}
-      will print register values
+          will print register values
   
-               Available formats:
-                   x: hex
-                   s: string
-                   cf: use CFCopyDescription() to get more informative description of the object
-                   po: use LLDB po command
-                   User defined function, will be called like `format_function(hilda_client, value)`.
+          Available formats:
+              x: hex
+              s: string
+              cf: use CFCopyDescription() to get more informative description of the object
+              po: use LLDB po command
+              User defined function, will be called like `format_function(hilda_client, value)`.
   
-               For example:
-                   regs={'x0': 'x'} -> x0 will be printed in HEX format
-           expr={lldb_expression: format}
-               lldb_expression can be for example '$x0' or '$arg1'
-               format behaves just like 'regs' option
-           retval=format
-               Print function's return value. The format is the same as regs format.
-           stop=True
-               force a stop at every hit
-           bt=True
-               print backtrace
-           cmd=[cmd1, cmd2]
-               run several LLDB commands, one by another
-           force_return=value
-               force a return from function with the specified value
-           name=some_value
-               use `some_name` instead of the symbol name automatically extracted from the calling frame
-           override=True
-               override previous break point at same location
+              For example:
+                  regs={'x0': 'x'} -> x0 will be printed in HEX format
+      expr={lldb_expression: format}
+          lldb_expression can be for example '$x0' or '$arg1'
+          format behaves just like 'regs' option
+      retval=format
+          Print function's return value. The format is the same as regs format.
+      stop=True
+          force a stop at every hit
+      bt=True
+          print backtrace
+      cmd=[cmd1, cmd2]
+          run several LLDB commands, one by another
+      force_return=value
+          force a return from function with the specified value
+      name=some_value
+          use `some_name` instead of the symbol name automatically extracted from the calling frame
+      override=True
+          override previous break point at same location
       ```
 
 - `show_current_source`
@@ -305,6 +306,8 @@ Here is a gist of methods you can access from `p`:
   - sets the currently selected thread, which is used in other parts of the program, such as displaying disassembly or
       checking registers.
       This ensures the application focuses on the specified thread for these operations.
+- `wait_for_module`
+  - Wait for a module to be loaded (`dlopen`) by checking if given expression is contained within its filename
 
 All these methods are available from the global `p` within the newly created IPython shell. In addition, you may invoke any of the exported APIs described in the [Python API](#python-api)