hilda 0.1.2__tar.gz → 0.3.0__tar.gz

hilda-0.3.0/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012-2023 Doron Zarhi and Metan Perelman
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

{hilda-0.1.2/hilda.egg-info → hilda-0.3.0}/PKG-INFO

@@ -1,17 +1,44 @@
 Metadata-Version: 2.1
 Name: hilda
-Version: 0.1.2
+Version: 0.3.0
 Summary: LLDB wrapped and empowered by iPython's features
-Home-page: https://github.com/doronz88/hilda
-Author: DoronZ
-Project-URL: hilda, https://github.com/doronz88/hilda
-Classifier: Programming Language :: Python :: 3.7
+Author-email: doronz88 <doron88@gmail.com>, matan <matan1008@gmail.com>, netanel <matan1008@gmail.com>
+Maintainer-email: doronz88 <doron88@gmail.com>, matan <matan1008@gmail.com>
+License: Copyright (c) 2012-2023 Doron Zarhi and Metan Perelman
+        
+        Permission is hereby granted, free of charge, to any person obtaining
+        a copy of this software and associated documentation files (the
+        "Software"), to deal in the Software without restriction, including
+        without limitation the rights to use, copy, modify, merge, publish,
+        distribute, sublicense, and/or sell copies of the Software, and to
+        permit persons to whom the Software is furnished to do so, subject to
+        the following conditions:
+        
+        The above copyright notice and this permission notice shall be
+        included in all copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+        EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+        MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+        NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+        LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+        OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+        WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+Project-URL: Homepage, https://github.com/doronz88/hilda
+Project-URL: Bug Reports, https://github.com/doronz88/hilda/issues
+Keywords: python,debugger,lldb,ipython,ios,debug
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 Provides-Extra: test
+License-File: LICENSE
 
 - [Description](#description)
 - [Example](#example)
@@ -80,6 +107,16 @@ xcrun python3 -m pip install --user -U hilda
 
 ## Starting a Hilda shell
 
+### Attach mode
+
+Use the attach sub-command in order to start an LLDB shell attached to given process.
+
+```shell
+hilda attach [-p pid] [-n process-name]
+```
+
+After attaching, simply execute `hilda` command to enter the hilda shell.
+
 ### Bare mode
 
 Use "Bare mode" to get a "bare-bones" lldb shell, whereas hilda plugin is already loaded and ready to start. This mode
@@ -117,13 +154,17 @@ This mode will auto-connect to the remote device and attach to your target proce
 remote jailbroken iOS device.
 
 Please note the following:
-* script assumes the connected device already **has a running ssh server**, which doesn't require a password (you can use
-`ssh-copy-id` to achieve this).
+
+* script assumes the connected device already **has a running ssh server**, which doesn't require a password (you can
+  use
+  `ssh-copy-id` to achieve this).
 
 From this point the flow diverges into 2 flows:
 
 ### The connected device is connected to the network via `internet sharing` with your computer
+
 Run the following command:
+
 ```shell
 hilda remote PROCESS_NAME SSH_PORT
 ``` 
@@ -131,11 +172,12 @@ hilda remote PROCESS_NAME SSH_PORT
 ### The connected device is connected via Wi-Fi
 
 For this to work, you will need to make sure of the following:
-  * Find your cellphone IP address (Settings -> Wi-Fi -> network info -> IP Address).
-  * Once you found it, run the following command:
-      ```shell
-      hilda remote PROCESS_NAME SSH_PORT --hostname <DEVICE_IP_ADDRESS>
-      ```
+
+* Find your cellphone IP address (Settings -> Wi-Fi -> network info -> IP Address).
+* Once you found it, run the following command:
+    ```shell
+    hilda remote PROCESS_NAME SSH_PORT --hostname <DEVICE_IP_ADDRESS>
+    ```
 
 ## Commands
 
@@ -260,6 +302,65 @@ capabilities:
 stop?
 ```
 
+## UI Configuration
+
+Hilda contains minimal UI for examining the target state.
+The UI is divided into views:
+
+- Registers
+- Disassembly
+- Stack
+- Backtrace
+
+![img.png](gifs/ui.png)
+
+This UI can be displayed at any time be executing:
+
+```python
+ui.show()
+```
+
+By default `step_into` and `step_over` will show this UI automatically.
+You may disable this behaviour by executing:
+
+```python
+ui.active = False
+```
+
+Attentively, if you want to display UI after hitting a breakpoint, you can register `ui.show` as callback:
+
+```python
+symbol(0x7ff7b97c21b0).bp(ui.show)
+```
+
+Try playing with the UI settings by yourself:
+
+```python
+# Disable stack view
+ui.views.stack.active = False
+
+# View words from the stack
+ui.views.stack.depth = 10
+
+# View last 10 frames
+ui.views.backtrace.depth = 10
+
+# Disassemble 5 instructions
+ui.views.disassembly.instruction_count = 5
+
+# Change disassembly syntax to AT&T
+ui.views.disassembly.flavor = 'att'
+
+# View floating point registers
+ui.views.registers.rtype = 'float'
+
+# Change addresses print color
+ui.colors.address = 'red'
+
+# Change titles color
+ui.color.title = 'green'
+```
+
 ## Symbol objects
 
 In Hilda, almost everything is wrapped using the `Symbol` Object. Symbol is just a nicer way for referring to addresses

hilda-0.1.2/PKG-INFO → hilda-0.3.0/README.md

@@ -1,18 +1,3 @@
-Metadata-Version: 2.1
-Name: hilda
-Version: 0.1.2
-Summary: LLDB wrapped and empowered by iPython's features
-Home-page: https://github.com/doronz88/hilda
-Author: DoronZ
-Project-URL: hilda, https://github.com/doronz88/hilda
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Description-Content-Type: text/markdown
-Provides-Extra: test
-
 - [Description](#description)
 - [Example](#example)
 - [Installation](#installation)
@@ -80,6 +65,16 @@ xcrun python3 -m pip install --user -U hilda
 
 ## Starting a Hilda shell
 
+### Attach mode
+
+Use the attach sub-command in order to start an LLDB shell attached to given process.
+
+```shell
+hilda attach [-p pid] [-n process-name]
+```
+
+After attaching, simply execute `hilda` command to enter the hilda shell.
+
 ### Bare mode
 
 Use "Bare mode" to get a "bare-bones" lldb shell, whereas hilda plugin is already loaded and ready to start. This mode
@@ -117,13 +112,17 @@ This mode will auto-connect to the remote device and attach to your target proce
 remote jailbroken iOS device.
 
 Please note the following:
-* script assumes the connected device already **has a running ssh server**, which doesn't require a password (you can use
-`ssh-copy-id` to achieve this).
+
+* script assumes the connected device already **has a running ssh server**, which doesn't require a password (you can
+  use
+  `ssh-copy-id` to achieve this).
 
 From this point the flow diverges into 2 flows:
 
 ### The connected device is connected to the network via `internet sharing` with your computer
+
 Run the following command:
+
 ```shell
 hilda remote PROCESS_NAME SSH_PORT
 ``` 
@@ -131,11 +130,12 @@ hilda remote PROCESS_NAME SSH_PORT
 ### The connected device is connected via Wi-Fi
 
 For this to work, you will need to make sure of the following:
-  * Find your cellphone IP address (Settings -> Wi-Fi -> network info -> IP Address).
-  * Once you found it, run the following command:
-      ```shell
-      hilda remote PROCESS_NAME SSH_PORT --hostname <DEVICE_IP_ADDRESS>
-      ```
+
+* Find your cellphone IP address (Settings -> Wi-Fi -> network info -> IP Address).
+* Once you found it, run the following command:
+    ```shell
+    hilda remote PROCESS_NAME SSH_PORT --hostname <DEVICE_IP_ADDRESS>
+    ```
 
 ## Commands
 
@@ -260,6 +260,65 @@ capabilities:
 stop?
 ```
 
+## UI Configuration
+
+Hilda contains minimal UI for examining the target state.
+The UI is divided into views:
+
+- Registers
+- Disassembly
+- Stack
+- Backtrace
+
+![img.png](gifs/ui.png)
+
+This UI can be displayed at any time be executing:
+
+```python
+ui.show()
+```
+
+By default `step_into` and `step_over` will show this UI automatically.
+You may disable this behaviour by executing:
+
+```python
+ui.active = False
+```
+
+Attentively, if you want to display UI after hitting a breakpoint, you can register `ui.show` as callback:
+
+```python
+symbol(0x7ff7b97c21b0).bp(ui.show)
+```
+
+Try playing with the UI settings by yourself:
+
+```python
+# Disable stack view
+ui.views.stack.active = False
+
+# View words from the stack
+ui.views.stack.depth = 10
+
+# View last 10 frames
+ui.views.backtrace.depth = 10
+
+# Disassemble 5 instructions
+ui.views.disassembly.instruction_count = 5
+
+# Change disassembly syntax to AT&T
+ui.views.disassembly.flavor = 'att'
+
+# View floating point registers
+ui.views.registers.rtype = 'float'
+
+# Change addresses print color
+ui.colors.address = 'red'
+
+# Change titles color
+ui.color.title = 'green'
+```
+
 ## Symbol objects
 
 In Hilda, almost everything is wrapped using the `Symbol` Object. Symbol is just a nicer way for referring to addresses

{hilda-0.1.2 → hilda-0.3.0}/hilda/hilda_client.py

@@ -9,19 +9,21 @@ import os
 import pickle
 import textwrap
 import time
+import typing
 from collections import namedtuple
 from contextlib import contextmanager, suppress
 from datetime import datetime, timezone
-from functools import partial
+from functools import cached_property, partial
 from pathlib import Path
-from typing import Union
+from typing import List, Optional, Union
 
-import IPython
 import docstring_parser
 import hexdump
+import IPython
 import lldb
 from humanfriendly import prompts
 from humanfriendly.terminal.html import html_to_ansi
+from keystone import KS_ARCH_ARM64, KS_ARCH_X86, KS_MODE_64, KS_MODE_LITTLE_ENDIAN, Ks
 from pygments import highlight
 from pygments.formatters import TerminalTrueColorFormatter
 from pygments.lexers import XmlLexer
@@ -29,14 +31,17 @@ from tqdm import tqdm
 from traitlets.config import Config
 
 from hilda import objective_c_class
-from hilda.command import command, CommandsMeta
-from hilda.exceptions import *
+from hilda.command import CommandsMeta, command
+from hilda.exceptions import AccessingMemoryError, AccessingRegisterError, AddingLldbSymbolError, \
+    BrokenLocalSymbolsJarError, ConvertingFromNSObjectError, ConvertingToNsObjectError, CreatingObjectiveCSymbolError, \
+    DisableJetsamMemoryChecksError, EvaluatingExpressionError, HildaException, SymbolAbsentError
+from hilda.launch_lldb import disable_logs  # noqa: F401
 from hilda.objective_c_symbol import ObjectiveCSymbol
 from hilda.registers import Registers
 from hilda.snippets.mach import CFRunLoopServiceMachPort_hooks
 from hilda.symbol import Symbol
 from hilda.symbols_jar import SymbolsJar
-from hilda.launch_lldb import disable_logs
+from hilda.ui.ui_manager import UiManager
 
 IsaMagic = namedtuple('IsaMagic', 'mask value')
 ISA_MAGICS = [
@@ -77,7 +82,8 @@ class HildaClient(metaclass=CommandsMeta):
         self.breakpoints = {}
         self.captured_objects = {}
         self.registers = Registers(self)
-
+        self.arch = self.target.GetTriple().split('-')[0]
+        self.ui_manager = UiManager(self)
         # should unwind the stack on errors. change this to False in order to debug self-made calls
         # within hilda
         self._evaluation_unwind_on_error = True
@@ -117,16 +123,22 @@ class HildaClient(metaclass=CommandsMeta):
         return {int(k): v for k, v in result.items()}
 
     @command()
-    def bt(self):
+    def bt(self, should_print=True, depth: Optional[int] = None) -> List:
         """ Print an improved backtrace. """
+        backtrace = []
         for i, frame in enumerate(self.thread.frames):
+            if i == depth:
+                break
             row = ''
             row += html_to_ansi(f'<span style="color: cyan">0x{frame.addr.GetFileAddress():x}</span> ')
             row += str(frame)
             if i == 0:
                 # first line
                 row += ' 👈'
-            print(row)
+            backtrace.append([f'0x{frame.addr.file_addr:016x}', frame])
+            if should_print:
+                print(row)
+        return backtrace
 
     @command()
     def disable_jetsam_memory_checks(self):
@@ -238,6 +250,16 @@ class HildaClient(metaclass=CommandsMeta):
 
         return retval
 
+    @command()
+    def poke_text(self, address: int, code: str) -> int:
+        """
+        Write instructions to address.
+        :param address:
+        :param code:
+        """
+        bytecode, count = self._ks.asm(code, as_bytes=True)
+        return self.poke(address, bytecode)
+
     @command()
     def peek(self, address, size: int) -> bytes:
         """
@@ -258,28 +280,13 @@ class HildaClient(metaclass=CommandsMeta):
         return retval
 
     @command()
-    def peek_str(self, address, encoding=None):
+    def peek_str(self, address: Symbol) -> str:
         """
         Peek a buffer till null termination
         :param address:
-        :param encoding: character encoding. if None, bytes is returned
         :return:
         """
-        if hasattr(self.symbols, 'strlen'):
-            # always prefer using native strlen
-            buf = self.peek(address, self.symbols.strlen(address))
-        else:
-            buf = self.peek(address, 1)
-            while buf[-1] != 0:
-                buf += self.peek(address + len(buf), 1)
-
-            # remove null terminator
-            buf = buf[:-1]
-
-        if encoding is not None:
-            buf = str(buf, encoding)
-
-        return buf
+        return address.po('char *')[1:-1]  # strip the ""
 
     @command()
     def stop(self):
@@ -322,15 +329,16 @@ class HildaClient(metaclass=CommandsMeta):
             self.log_critical('failed to detach')
 
     @command()
-    def disass(self, address, buf, should_print=True) -> lldb.SBInstructionList:
+    def disass(self, address, buf, flavor='intel', should_print=True) -> lldb.SBInstructionList:
         """
         Print disassembly from a given address
+        :param flavor:
         :param address:
         :param buf:
         :param should_print:
         :return:
         """
-        inst = self.target.GetInstructions(lldb.SBAddress(address, self.target), buf)
+        inst = self.target.GetInstructionsWithFlavor(lldb.SBAddress(address, self.target), flavor, buf)
         if should_print:
             print(inst)
         return inst
@@ -515,12 +523,16 @@ class HildaClient(metaclass=CommandsMeta):
         """ Step into current instruction. """
         with self.sync_mode():
             self.thread.StepInto()
+        if self.ui_manager.active:
+            self.ui_manager.show()
 
     @command()
     def step_over(self):
         """ Step over current instruction. """
         with self.sync_mode():
             self.thread.StepOver()
+        if self.ui_manager.active:
+            self.ui_manager.show()
 
     @command()
     def remove_all_hilda_breakpoints(self, remove_forced=False):
@@ -608,7 +620,7 @@ class HildaClient(metaclass=CommandsMeta):
 
     def bp_callback_router(self, frame, bp_loc, *_):
         """
-        Route the breakpoint callback the the specific breakpoint callback.
+        Route the breakpoint callback the specific breakpoint callback.
         :param lldb.SBFrame frame: LLDB Frame object.
         :param lldb.SBBreakpointLocation bp_loc: LLDB Breakpoint location object.
         """
@@ -902,13 +914,13 @@ class HildaClient(metaclass=CommandsMeta):
 
         if is_running:
             self.stop()
-            time.sleep(1)
+            time.sleep(interval)
 
         try:
             yield
         finally:
             if is_running:
-                time.sleep(1)
+                time.sleep(interval)
                 self.cont()
 
     @contextmanager
@@ -1009,7 +1021,7 @@ class HildaClient(metaclass=CommandsMeta):
 
         return value
 
-    def interactive(self):
+    def interactive(self, additional_namespace: typing.Mapping = None):
         """ Start an interactive Hilda shell """
         if not self._dynamic_env_loaded:
             self.init_dynamic_environment()
@@ -1025,6 +1037,8 @@ class HildaClient(metaclass=CommandsMeta):
         ]
         namespace = globals()
         namespace.update(locals())
+        if additional_namespace is not None:
+            namespace.update(additional_namespace)
 
         IPython.start_ipython(config=c, user_ns=namespace)
 
@@ -1116,12 +1130,11 @@ class HildaClient(metaclass=CommandsMeta):
                 raise NotImplementedError('cannot serialize argument')
         return args_conv
 
-    @staticmethod
-    def _generate_call_expression(address, params):
+    def _generate_call_expression(self, address, params):
         args_type = ','.join(['intptr_t'] * len(params))
         args_conv = ','.join(params)
 
-        if self.target.modules[0].triple.split('-')[0] == 'arm64e':
+        if self.arch == 'arm64e':
             address = f'ptrauth_sign_unauthenticated((void *){address}, ptrauth_key_asia, 0)'
 
         return f'((intptr_t(*)({args_type}))({address}))({args_conv})'
@@ -1178,3 +1191,10 @@ class HildaClient(metaclass=CommandsMeta):
             return formatters[fmt](value)
         else:
             return f'{value:x} (unsupported format)'
+
+    @cached_property
+    def _ks(self) -> Ks:
+        platforms = {'arm64': Ks(KS_ARCH_ARM64, KS_MODE_LITTLE_ENDIAN),
+                     'arm64e': Ks(KS_ARCH_ARM64, KS_MODE_LITTLE_ENDIAN),
+                     'x86_64h': Ks(KS_ARCH_X86, KS_MODE_64)}
+        return platforms.get(self.arch)

{hilda-0.1.2 → hilda-0.3.0}/hilda/launch_lldb.py

@@ -67,6 +67,26 @@ def bare():
     execute(f'lldb --one-line "{commands}"')
 
 
+@cli.command('attach')
+@click.option('-n', '--name', help='process name to attach')
+@click.option('-p', '--pid', type=click.INT, help='pid to attach')
+def attach(name: str, pid: int):
+    """ Attach to given process and start an lldb shell """
+    # connect local LLDB client
+    commands = []
+    if name is not None:
+        commands.append(f'process attach -n {name}')
+    elif pid is not None:
+        commands.append(f'process attach -p {pid}')
+    else:
+        print('missing either process name or pid for attaching')
+        return
+
+    commands.append(f'command script import {os.path.join(Path(__file__).resolve().parent, "lldb_entrypoint.py")}')
+    commands = '\n'.join(commands)
+    execute(f'lldb --one-line "{commands}"')
+
+
 if __name__ == '__main__':
     disable_logs()
     cli()

{hilda-0.1.2 → hilda-0.3.0}/hilda/lldb_entrypoint.py

@@ -15,7 +15,9 @@ lldb.hilda_client = None
 def hilda(debugger, command, result, internal_dict):
     if lldb.hilda_client is None:
         lldb.hilda_client = HildaClient(debugger)
-    lldb.hilda_client.interactive()
+
+    additional_namespace = {'ui': lldb.hilda_client.ui_manager}
+    lldb.hilda_client.interactive(additional_namespace=additional_namespace)
 
 
 def __lldb_init_module(debugger, internal_dict):

{hilda-0.1.2 → hilda-0.3.0}/hilda/objective_c_class.py

@@ -7,13 +7,14 @@ from functools import partial
 from pathlib import Path
 from uuid import uuid4
 
+from objc_types_decoder.decode import decode as decode_type
+from objc_types_decoder.decode import decode_with_tail
 from pygments import highlight
 from pygments.formatters import TerminalTrueColorFormatter
 from pygments.lexers import ObjectiveCLexer
-from objc_types_decoder.decode import decode as decode_type, decode_with_tail
 
-from hilda.symbols_jar import SymbolsJar
 from hilda.exceptions import GettingObjectiveCClassError
+from hilda.symbols_jar import SymbolsJar
 
 Ivar = namedtuple('Ivar', 'name type_ offset')
 Property = namedtuple('Property', 'name attributes')

{hilda-0.1.2 → hilda-0.3.0}/hilda/objective_c_symbol.py

@@ -5,15 +5,15 @@ from dataclasses import dataclass
 from functools import partial
 from pathlib import Path
 
+from objc_types_decoder.decode import decode as decode_type
 from pygments import highlight
 from pygments.formatters import TerminalTrueColorFormatter
 from pygments.lexers import ObjectiveCLexer
-from objc_types_decoder.decode import decode as decode_type
 
 from hilda.exceptions import HildaException
-from hilda.objective_c_class import Class, convert_encoded_property_attributes, Method, Property
-from hilda.symbols_jar import SymbolsJar
+from hilda.objective_c_class import Class, Method, Property, convert_encoded_property_attributes
 from hilda.symbol import Symbol
+from hilda.symbols_jar import SymbolsJar
 
 
 class SettingIvarError(HildaException):

hilda-0.3.0/hilda/snippets/boringssl.py

@@ -0,0 +1,26 @@
+import lldb
+
+_FILENAME = '/tmp/hilda-keylog.txt'
+
+
+def _ssl_log_secret_bp(hilda, *args):
+    label = hilda.registers.x1.peek_str()
+    secret = hilda.registers.x2.peek(hilda.registers.x3).hex()
+    random = (hilda.registers.x0[6] + 48).peek(32).hex()
+    print(f'ssl_log_secret\n'
+          f'    label: {label}\n'
+          f'    secret: {secret}\n'
+          f'    random: {random}\n'
+          f'---\n')
+    with open(_FILENAME, 'a') as f:
+        f.write(f'{label} {random} {secret}\n')
+    hilda.cont()
+
+
+def start_keylog(filename: str = None) -> None:
+    global _FILENAME
+
+    if filename is not None:
+        _FILENAME = filename
+    hilda_client = lldb.hilda_client
+    hilda_client.symbols._ZN4bssl14ssl_log_secretEPK6ssl_stPKcNS_4SpanIKhEE.bp(_ssl_log_secret_bp)

{hilda-0.1.2 → hilda-0.3.0}/hilda/snippets/dyld.py

@@ -1,6 +1,5 @@
-from cached_property import cached_property
-
 import lldb
+from cached_property import cached_property
 
 from hilda.snippets.macho.all_image_infos import AllImageInfos
 from hilda.snippets.syslog import open_syslog_socket