hilda 3.0.0__tar.gz → 3.1.0__tar.gz

{hilda-3.0.0 → hilda-3.1.0}/.github/workflows/python-app.yml

@@ -39,4 +39,4 @@ jobs:
           xcrun python3 -m pip install -e ".[test]"
       - name: Run pytest
         run: |
-          sudo xcrun python3 -m pytest -k "not set_implementation"
+          sudo xcrun python3 -m pytest -k "not set_implementation" -vvv

{hilda-3.0.0 → hilda-3.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: hilda
-Version: 3.0.0
+Version: 3.1.0
 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>
@@ -55,6 +55,7 @@ Requires-Dist: inquirer3
 Requires-Dist: traitlets
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
+Dynamic: license-file
 
 # Hilda
 
@@ -152,165 +153,94 @@ You can may start a Hilda interactive shell by invoking any of the subcommand:
 
 ### Inside a Hilda shell
 
-Upon starting Hilda shell, you are greeted with:
-
-```
-Hilda has been successfully loaded! 😎
-Use the p global to access all features.
-Have a nice flight ✈️! Starting an IPython shell...
-```
-
-Here is a gist of methods you can access from `p`:
-
-- `hd`
-  - Print a hexdump of given buffer
-- `lsof`
-  - Get dictionary of all open FDs
-- `bt`
-  - Print an improved backtrace.
-- `disable_jetsam_memory_checks`
-  - Disable jetsam memory checks, prevent raising:
-      `error: Execution was interrupted, reason: EXC_RESOURCE RESOURCE_TYPE_MEMORY (limit=15 MB, unused=0x0).`
-      when evaluating expression.
-- `symbol`
-  - Get symbol object for a given address
-- `objc_symbol`
-  - Get objc symbol wrapper for given address
-- `inject`
-  - Inject a single library into currently running process
-- `rebind_symbols`
-  - Reparse all loaded images symbols
-- `poke`
-  - Write data at given address
-- `peek`
-  - Read data at given address
-- `peek_str`
-  - Peek a buffer till null termination
-- `peek_std_str`
-  - Peek a `std::string`
-- `stop`
-  - Stop process.
-- `cont`
-  - Continue process.
-- `run_for`
-  - Run the process for given interval.
-- `detach`
-  - Detach from process.
-      Useful in order to exit gracefully so process doesn't get killed
-      while you exit
-- `disass`
-  - Print disassembly from a given address
-- `file_symbol`
-  - Calculate symbol address without ASLR
-- `get_register`
-  - Get value for register by its name
-- `set_register`
-  - Set value for register by its name
-- `objc_call`
-  - Simulate a call to an objc selector
-- `call`
-  - Call function at given address with given parameters
-- `monitor` or `breakpoints.add_monitor`
-  - Monitor every time a given address is called
-
-      The following options are available:
-
-      ```
-      regs={reg1: format}
-          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)`.
-  
-              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`
-  - print current source code if possible
-- `finish`
-  - Run current frame till its end.
-- `step_into`
-  - Step into current instruction.
-- `step_over`
-  - Step over current instruction.
-- `breakpoints.clear`
-  - Remove all breakpoints
-- `breakpoints.remove`
-  - Remove a single breakpoint
-- `force_return`
-  - Prematurely return from a stack frame, short-circuiting exection of newer frames and optionally
-      yielding a specified value.
-- `proc_info`
-  - Print information about currently running mapped process.
-- `print_proc_entitlements`
-  - Get the plist embedded inside the process' __LINKEDIT section.
-- `bp` or `breakpoints.add`
-  - Add a breakpoint
-- `breakpoints.show`
-  - Show existing breakpoints
-- `po`
-  - Print given object using LLDB's po command
-      Can also run big chunks of native code:
-
-      po('NSMutableString *s = [NSMutableString string]; [s appendString:@"abc"]; [s description]')
-- `globalize_symbols`
-  - Make all symbols in python's global scope
-- `jump`
-  - jump to given symbol
-- `lldb_handle_command`
-  - Execute an LLDB command
-      For example:
-      lldb_handle_command('register read')
-- `objc_get_class`
-  - Get ObjC class object
-- `CFSTR`
-  - Create CFStringRef object from given string
-- `ns`
-  - Create NSObject from given data
-- `from_ns`
-  - Create python object from NS object.
-- `evaluate_expression`
-  - Wrapper for LLDB's EvaluateExpression.
-      Used for quick code snippets.
-
-      Feel free to use local variables inside the expression using format string.
-      For example:
-      currentDevice = objc_get_class('UIDevice').currentDevice
-      evaluate_expression(f'[[{currentDevice} systemName] hasPrefix:@"2"]')
-- `import_module`
-  - Import & reload given python module (intended mainly for external snippets)
-- `unwind`
-  - Unwind the stack (useful when get_evaluation_unwind() == False)
-- `set_selected_thread`
-  - 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)
+Upon starting Hilda, you are welcomed into an IPython shell.
+You can access following methods via the variable `p`.
+
+Basic flow control:
+
+- `stop` - Stop process
+- `cont` - Continue process
+- `finish` - Run current function until return
+- `step_into` - Step into current instruction
+- `step_over` - Step over current instruction.
+- `run_for` - Run the process for given interval
+- `force_return` - Prematurely return from a stack frame, short-circuiting exection of inner
+  frames and optionally yielding a specified value.
+- `jump` - Jump to given symbol
+- `wait_for_module` - Wait for a module to be loaded (`dlopen`) by checking if given expression is contained within its filename
+- `detach` - Detach from process (useful for exiting gracefully so the
+  process doesn't get killed when you exit)
+
+Breakpoints:
+- `bp` or `breakpoints.add` - Add a breakpoint
+- `breakpoints.show` - Show existing breakpoints
+- `breakpoints.remove` - Remove a single breakpoint
+- `breakpoints.clear` - Remove all breakpoints
+- `monitor` or `breakpoints.add_monitor` - Creates a breakpoint whose callback implements the requested features (print register vallues, execute commands, mock return value, etc.)
+
+Basic read/write:
+
+- `get_register` - Get register value
+- `set_register` - Set register value
+- `poke` - Write data at address
+- `peek[_str,_std_str]` - Read buffer/C-string/`std::string` at address
+- `po` - Print object using LLDB's `po` command
+  Can also run arbitrary native code:
+
+  ```python
+  p.po('NSMutableString *s = [NSMutableString string]; [s appendString:@"abc"]; [s description]')
+  ```
+- `disass` - Print disassembly at address
+- `show_current_source` - Print current source code (if possible)
+- `bt` - Get backtrace
+- `lsof` - Get all open FDs
+- `hd` - Hexdump a buffer
+- `proc_info` - Print information about currently running mapped process
+- `print_proc_entitlements` - Get the plist embedded inside the process' __LINKEDIT section.
+
+Execute code:
+
+- `call` - Call function at given address with given parameters
+- `objc_call` - Simulate a call to an objc selector
+- `inject` - Inject a single library into currently running process
+- `disable_jetsam_memory_checks` -
+   Disable jetsam memory checks (to prevent raising
+   `error: Execution was interrupted, reason: EXC_RESOURCE RESOURCE_TYPE_MEMORY (limit=15 MB, unused=0x0).`
+   when evaluating expressions).
+
+Hilda symbols:
+
+- `symbol` - Get symbol object for a given address
+- `objc_symbol` - Get objc symbol wrapper for given address
+- `rebind_symbols` - Reparse all loaded images symbols
+- `file_symbol` - Calculate symbol address without ASLR
+- `save` - Save loaded symbols map (for loading later using the load() command)
+- `load` - Load an existing symbols map (previously saved by the save() command)
+- `globalize_symbols` - Make all symbols in python's global scope
+
+Advanced:
+
+- `lldb_handle_command` - Execute an LLDB command (e.g., `p.lldb_handle_command('register read')`)
+- `evaluate_expression` - Use for quick code snippets (wrapper for LLDB's `EvaluateExpression`)
+
+  Take advantage of local variables inside the expression using format string, e.g.,
+
+  ```python
+  currentDevice = p.objc_get_class('UIDevice').currentDevice
+  p.evaluate_expression(f'[[{currentDevice} systemName] hasPrefix:@"2"]')
+  ```
+- `import_module` - Import & reload given python module (intended mainly for external snippets)
+- `unwind` - Unwind the stack (useful when get_evaluation_unwind() == False)
+- `set_selected_thread` - 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.
+
+Objective-C related:
+
+- `objc_get_class` - Get ObjC class object
+- `CFSTR` - Create CFStringRef object from given string
+- `ns` - Create NSObject from given data
+- `from_ns` - Create python object from NS object.
 
 #### Magic functions
 
@@ -672,7 +602,7 @@ commands so you are able to use complicated types when parsing values and passin
 import datetime
 
 # using the `ns` command we can just pass a python-native dictionary
-function_requiring_a_specfic_dictionary(ns({
+function_requiring_a_specfic_dictionary(p.cf({
     'key1': 'string',  # will convert to NSString
     'key2': True,  # will convert to NSNumber
     'key3': b'1234',  # will convert to NSData

{hilda-3.0.0 → hilda-3.1.0}/README.md

@@ -94,165 +94,94 @@ You can may start a Hilda interactive shell by invoking any of the subcommand:
 
 ### Inside a Hilda shell
 
-Upon starting Hilda shell, you are greeted with:
-
-```
-Hilda has been successfully loaded! 😎
-Use the p global to access all features.
-Have a nice flight ✈️! Starting an IPython shell...
-```
-
-Here is a gist of methods you can access from `p`:
-
-- `hd`
-  - Print a hexdump of given buffer
-- `lsof`
-  - Get dictionary of all open FDs
-- `bt`
-  - Print an improved backtrace.
-- `disable_jetsam_memory_checks`
-  - Disable jetsam memory checks, prevent raising:
-      `error: Execution was interrupted, reason: EXC_RESOURCE RESOURCE_TYPE_MEMORY (limit=15 MB, unused=0x0).`
-      when evaluating expression.
-- `symbol`
-  - Get symbol object for a given address
-- `objc_symbol`
-  - Get objc symbol wrapper for given address
-- `inject`
-  - Inject a single library into currently running process
-- `rebind_symbols`
-  - Reparse all loaded images symbols
-- `poke`
-  - Write data at given address
-- `peek`
-  - Read data at given address
-- `peek_str`
-  - Peek a buffer till null termination
-- `peek_std_str`
-  - Peek a `std::string`
-- `stop`
-  - Stop process.
-- `cont`
-  - Continue process.
-- `run_for`
-  - Run the process for given interval.
-- `detach`
-  - Detach from process.
-      Useful in order to exit gracefully so process doesn't get killed
-      while you exit
-- `disass`
-  - Print disassembly from a given address
-- `file_symbol`
-  - Calculate symbol address without ASLR
-- `get_register`
-  - Get value for register by its name
-- `set_register`
-  - Set value for register by its name
-- `objc_call`
-  - Simulate a call to an objc selector
-- `call`
-  - Call function at given address with given parameters
-- `monitor` or `breakpoints.add_monitor`
-  - Monitor every time a given address is called
-
-      The following options are available:
-
-      ```
-      regs={reg1: format}
-          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)`.
-  
-              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`
-  - print current source code if possible
-- `finish`
-  - Run current frame till its end.
-- `step_into`
-  - Step into current instruction.
-- `step_over`
-  - Step over current instruction.
-- `breakpoints.clear`
-  - Remove all breakpoints
-- `breakpoints.remove`
-  - Remove a single breakpoint
-- `force_return`
-  - Prematurely return from a stack frame, short-circuiting exection of newer frames and optionally
-      yielding a specified value.
-- `proc_info`
-  - Print information about currently running mapped process.
-- `print_proc_entitlements`
-  - Get the plist embedded inside the process' __LINKEDIT section.
-- `bp` or `breakpoints.add`
-  - Add a breakpoint
-- `breakpoints.show`
-  - Show existing breakpoints
-- `po`
-  - Print given object using LLDB's po command
-      Can also run big chunks of native code:
-
-      po('NSMutableString *s = [NSMutableString string]; [s appendString:@"abc"]; [s description]')
-- `globalize_symbols`
-  - Make all symbols in python's global scope
-- `jump`
-  - jump to given symbol
-- `lldb_handle_command`
-  - Execute an LLDB command
-      For example:
-      lldb_handle_command('register read')
-- `objc_get_class`
-  - Get ObjC class object
-- `CFSTR`
-  - Create CFStringRef object from given string
-- `ns`
-  - Create NSObject from given data
-- `from_ns`
-  - Create python object from NS object.
-- `evaluate_expression`
-  - Wrapper for LLDB's EvaluateExpression.
-      Used for quick code snippets.
-
-      Feel free to use local variables inside the expression using format string.
-      For example:
-      currentDevice = objc_get_class('UIDevice').currentDevice
-      evaluate_expression(f'[[{currentDevice} systemName] hasPrefix:@"2"]')
-- `import_module`
-  - Import & reload given python module (intended mainly for external snippets)
-- `unwind`
-  - Unwind the stack (useful when get_evaluation_unwind() == False)
-- `set_selected_thread`
-  - 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)
+Upon starting Hilda, you are welcomed into an IPython shell.
+You can access following methods via the variable `p`.
+
+Basic flow control:
+
+- `stop` - Stop process
+- `cont` - Continue process
+- `finish` - Run current function until return
+- `step_into` - Step into current instruction
+- `step_over` - Step over current instruction.
+- `run_for` - Run the process for given interval
+- `force_return` - Prematurely return from a stack frame, short-circuiting exection of inner
+  frames and optionally yielding a specified value.
+- `jump` - Jump to given symbol
+- `wait_for_module` - Wait for a module to be loaded (`dlopen`) by checking if given expression is contained within its filename
+- `detach` - Detach from process (useful for exiting gracefully so the
+  process doesn't get killed when you exit)
+
+Breakpoints:
+- `bp` or `breakpoints.add` - Add a breakpoint
+- `breakpoints.show` - Show existing breakpoints
+- `breakpoints.remove` - Remove a single breakpoint
+- `breakpoints.clear` - Remove all breakpoints
+- `monitor` or `breakpoints.add_monitor` - Creates a breakpoint whose callback implements the requested features (print register vallues, execute commands, mock return value, etc.)
+
+Basic read/write:
+
+- `get_register` - Get register value
+- `set_register` - Set register value
+- `poke` - Write data at address
+- `peek[_str,_std_str]` - Read buffer/C-string/`std::string` at address
+- `po` - Print object using LLDB's `po` command
+  Can also run arbitrary native code:
+
+  ```python
+  p.po('NSMutableString *s = [NSMutableString string]; [s appendString:@"abc"]; [s description]')
+  ```
+- `disass` - Print disassembly at address
+- `show_current_source` - Print current source code (if possible)
+- `bt` - Get backtrace
+- `lsof` - Get all open FDs
+- `hd` - Hexdump a buffer
+- `proc_info` - Print information about currently running mapped process
+- `print_proc_entitlements` - Get the plist embedded inside the process' __LINKEDIT section.
+
+Execute code:
+
+- `call` - Call function at given address with given parameters
+- `objc_call` - Simulate a call to an objc selector
+- `inject` - Inject a single library into currently running process
+- `disable_jetsam_memory_checks` -
+   Disable jetsam memory checks (to prevent raising
+   `error: Execution was interrupted, reason: EXC_RESOURCE RESOURCE_TYPE_MEMORY (limit=15 MB, unused=0x0).`
+   when evaluating expressions).
+
+Hilda symbols:
+
+- `symbol` - Get symbol object for a given address
+- `objc_symbol` - Get objc symbol wrapper for given address
+- `rebind_symbols` - Reparse all loaded images symbols
+- `file_symbol` - Calculate symbol address without ASLR
+- `save` - Save loaded symbols map (for loading later using the load() command)
+- `load` - Load an existing symbols map (previously saved by the save() command)
+- `globalize_symbols` - Make all symbols in python's global scope
+
+Advanced:
+
+- `lldb_handle_command` - Execute an LLDB command (e.g., `p.lldb_handle_command('register read')`)
+- `evaluate_expression` - Use for quick code snippets (wrapper for LLDB's `EvaluateExpression`)
+
+  Take advantage of local variables inside the expression using format string, e.g.,
+
+  ```python
+  currentDevice = p.objc_get_class('UIDevice').currentDevice
+  p.evaluate_expression(f'[[{currentDevice} systemName] hasPrefix:@"2"]')
+  ```
+- `import_module` - Import & reload given python module (intended mainly for external snippets)
+- `unwind` - Unwind the stack (useful when get_evaluation_unwind() == False)
+- `set_selected_thread` - 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.
+
+Objective-C related:
+
+- `objc_get_class` - Get ObjC class object
+- `CFSTR` - Create CFStringRef object from given string
+- `ns` - Create NSObject from given data
+- `from_ns` - Create python object from NS object.
 
 #### Magic functions
 
@@ -614,7 +543,7 @@ commands so you are able to use complicated types when parsing values and passin
 import datetime
 
 # using the `ns` command we can just pass a python-native dictionary
-function_requiring_a_specfic_dictionary(ns({
+function_requiring_a_specfic_dictionary(p.cf({
     'key1': 'string',  # will convert to NSString
     'key2': True,  # will convert to NSNumber
     'key3': b'1234',  # will convert to NSData

{hilda-3.0.0 → hilda-3.1.0}/hilda/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '3.0.0'
-__version_tuple__ = version_tuple = (3, 0, 0)
+__version__ = version = '3.1.0'
+__version_tuple__ = version_tuple = (3, 1, 0)

{hilda-3.0.0 → hilda-3.1.0}/hilda/breakpoints.py

@@ -124,12 +124,30 @@ class HildaBreakpoint:
         for name in names_to_add:
             self.lldb_breakpoint.AddName(name)
 
+    @property
+    def enabled(self) -> bool:
+        """
+        Configures whether this breakpoint is enabled or not.
+        """
+        return self.lldb_breakpoint.IsEnabled()
+
+    @enabled.setter
+    def enabled(self, value: bool) -> None:
+        self.lldb_breakpoint.SetEnabled(value)
+
     def __repr__(self) -> str:
-        return (f'<{self.__class__.__name__} LLDB:{self.lldb_breakpoint} GUARDED:{self.guarded} '
+        enabled_repr = 'ENABLED' if self.enabled else 'DISABLED'
+        guarded_repr = 'GUARDED' if self.guarded else 'NOT-GUARDED'
+        return (f'<{self.__class__.__name__} LLDB:{self.lldb_breakpoint} {enabled_repr} {guarded_repr} '
                 f'CALLBACK:{self.callback}>')
 
     def __str__(self) -> str:
-        result = f'🚨 Breakpoint #{self.id} (guarded: {self.guarded}):\n'
+        emoji = '🚨' if self.enabled else '🔕'
+        enabled_str = 'enabled' if self.enabled else 'disabled'
+        guarded_str = 'guarded' if self.guarded else 'not-guarded'
+
+        result = f'{emoji} Breakpoint #{self.id} ({enabled_str}, {guarded_str})\n'
+
         if self.description is not None:
             result += f'\tDescription: {self.description}\n'
 
@@ -137,10 +155,13 @@ class HildaBreakpoint:
             result += f'\tWhere: {self.where}\n'
 
         # A single breakpoint may be related to several locations (addresses)
+        locations = self.locations
+        if len(locations) == 0:
+            result += f'\tNo locations\n'
         for location in self.locations:
             result += f'\tLocation {location}\n'
 
-        return result
+        return result.strip('\n')
 
     def remove(self, remove_guarded: bool = False) -> None:
         """
@@ -441,8 +462,10 @@ class BreakpointList:
 
     def show(self) -> None:
         """ Show existing breakpoints. """
+        if len(self) == 0:
+            self._hilda.log_info('No breakpoints')
         for bp in self:
-            print(bp)
+            self._hilda.log_info(bp)
 
     def items(self):
         """