hilda 0.1.2__py3-none-any.whl → 0.3.0__py3-none-any.whl

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/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/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/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/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/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/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

hilda/snippets/mach/CFRunLoopServiceMachPort_hooks.py

@@ -1,11 +1,53 @@
 import lldb
-from keystone import Ks, KS_ARCH_ARM64, KS_MODE_LITTLE_ENDIAN
 
+from hilda.exceptions import SymbolAbsentError
 
-def disable_mach_msg_errors():
+
+def _CFRunLoopServiceMachPort_hook(hilda, *args):
+    """
+    :param hilda.hilda_client.HildaClient hilda:
+     """
+    hilda.jump(hilda.CFRunLoopServiceMachPort_while_ea)
+    hilda.cont()
+
+
+def _disable_internal_error_handling() -> None:
+    hilda = lldb.hilda_client
+    with hilda.stopped():
+        instructions = hilda.symbols.__CFRunLoopServiceMachPort.disass(2000, should_print=False)
+        while_ea = None
+        for instruction in instructions:
+            if (while_ea is None) and instruction.DoesBranch():
+                # Beginning of the `while(true) { ... }`
+                while_ea = instruction.GetOperands(hilda.target)
+                hilda.CFRunLoopServiceMachPort_while_ea = int(hilda.file_symbol(eval(while_ea)))
+            elif instruction.GetMnemonic(hilda.target) in ('brk', 'ud2'):
+                symbol = hilda.symbol(instruction.addr.GetLoadAddress(hilda.target))
+                symbol.bp(
+                    _CFRunLoopServiceMachPort_hook,
+                    forced=True,
+                    name=f'__CFRunLoopServiceMachPort-brk-{int(symbol - hilda.symbols.__CFRunLoopServiceMachPort)}'
+                )
+
+    if hilda.arch == 'x86_64h':
+        return
+
+    # on iOS 16.x, will need to also patch this one
+    try:
+        handle_error = hilda.symbols['__CFRunLoopServiceMachPort.cold.1']
+    except SymbolAbsentError:
+        return
+
+    for instruction in handle_error.disass(2000, should_print=False):
+        if instruction.GetMnemonic(hilda.target) in ('brk', 'ud2'):
+            # mov x0, x0
+            hilda.symbol(instruction.addr.GetLoadAddress(hilda.target)).poke(b'\xe0\x03\x00\xaa')
+
+
+def _disable_mach_msg_timeout() -> None:
     """
-    Disable mach_msg syscall timeout CFRunLoopServiceMachPort. `__CFRunLoopServiceMachPort` receives
-    `mach_msg_timeout_t` parameter, the parameter passes on `x3` register. We set timeout = MACH_MSG_TIMEOUT_NONE.
+    Remove the timeout validation from __CFRunLoopServiceMachPort. This is done by patching the mach_msg_timeout_t
+    parameter (4rd one) to MACH_MSG_TIMEOUT_NONE. On arm the parameter passes on `x3` register.
 
         __int64 __fastcall __CFRunLoopServiceMachPort(
             mach_port_name_t a1,
@@ -29,15 +71,22 @@ def disable_mach_msg_errors():
         CoreFoundation:__text:0000000186E50154                 MOV             X23, X3       <-------- Timeout parameter
     """
     hilda = lldb.hilda_client
-    ks = Ks(KS_ARCH_ARM64, KS_MODE_LITTLE_ENDIAN)
+    if hilda.arch == 'x86_64h':
+        return
+
     with hilda.stopped():
         for inst in hilda.symbols.__CFRunLoopServiceMachPort.disass(200, should_print=False):
             mnemonic = inst.GetMnemonic(hilda.target)
-            operands = inst.GetOperands(hilda.target).replace(' ', '')
-            if mnemonic != 'mov' or ',x3' not in operands:
+            operands = inst.GetOperands(hilda.target)
+            if mnemonic != 'mov' or not operands.endswith('x3'):
                 continue
             addr = inst.GetAddress()
             file_addr = addr.GetFileAddress()
-            encoding, _ = ks.asm(f'{mnemonic} {operands.replace("x3", "0")}')
-            hilda.file_symbol(file_addr).poke(bytearray(encoding))
+            new_inst = f'{mnemonic} {operands.replace("x3", "0")}'
+            hilda.file_symbol(file_addr).poke_text(new_inst)
             break
+
+
+def disable_mach_msg_errors() -> None:
+    _disable_mach_msg_timeout()
+    _disable_internal_error_handling()

hilda/snippets/macho/all_image_infos.py

@@ -1,10 +1,10 @@
 import logging
 
 import lldb
-from construct import Struct, Tell, Int32ul, Pointer, this, Array, Int32ub, CString, If, Int64ul, Hex
+from construct import Array, CString, Hex, If, Int32ub, Int32ul, Int64ul, Pointer, Struct, Tell, this
 from humanfriendly import prompts
 
-from hilda.snippets.macho.image_info import dyld_image_info_t, ImageInfo
+from hilda.snippets.macho.image_info import ImageInfo, dyld_image_info_t
 from hilda.snippets.macho.macho import mach_header_t
 from hilda.snippets.uuid import uuid_t
 from hilda.symbol import SymbolFormatField

hilda/snippets/macho/apple_version.py

@@ -1,4 +1,4 @@
-from construct import BitStruct, Octet, BitsInteger
+from construct import BitsInteger, BitStruct, Octet
 
 version_t = BitStruct(
     'major' / BitsInteger(16),

hilda/snippets/macho/image_info.py

@@ -1,5 +1,5 @@
 import lldb
-from construct import Pointer, this, CString, Int64ul, Struct, If
+from construct import CString, If, Int64ul, Pointer, Struct, this
 
 from hilda.snippets.macho.macho import mach_header_t
 from hilda.snippets.macho.macho_load_commands import LoadCommands

hilda/snippets/macho/macho.py

@@ -1,4 +1,5 @@
-from construct import Int32ul, Struct, Hex, this, Tell, LazyArray, Computed
+from construct import Computed, Hex, Int32ul, LazyArray, Struct, Tell, this
+
 from hilda.snippets.macho.macho_load_commands import LOAD_COMMAND_TYPE, load_command_t
 
 

hilda/snippets/macho/macho_load_commands.py

@@ -1,7 +1,6 @@
 import lldb
-
-from construct import Hex, Int32ul, Pointer, PaddedString, Int64ul, this, Enum, Struct, Tell, Switch, Bytes, Seek, \
-    Array, Int8ul
+from construct import Array, Bytes, Enum, Hex, Int8ul, Int32ul, Int64ul, PaddedString, Pointer, Seek, Struct, Switch, \
+    Tell, this
 
 from hilda.snippets.macho.apple_version import version_t
 from hilda.symbol import SymbolFormatField

hilda/snippets/remotepairingd.py

@@ -35,9 +35,7 @@ TLV_MAP = {
 }
 
 
-def TLV8CopyCoalesced_bp(hilda, *args):
-    src = hilda.registers.x0
-    end = hilda.registers.x1
+def _TLV8CopyCoalesced_bp(hilda, *args):
     type_ = hilda.registers.x2
     out_len = hilda.registers.x3
     out_len.item_size = 4
@@ -56,7 +54,7 @@ def TLV8CopyCoalesced_bp(hilda, *args):
     hilda.cont()
 
 
-def TLV8BufferAppend_bp(hilda, *args):
+def _TLV8BufferAppend_bp(hilda, *args):
     buffer = hilda.registers.x0
     type_ = hilda.registers.x1
     buffer = hilda.registers.x2
@@ -68,9 +66,7 @@ def TLV8BufferAppend_bp(hilda, *args):
     hilda.cont()
 
 
-def SRPClientStart_libsrp_bp(hilda, *args):
-    client = hilda.registers.x0
-    params = hilda.registers.x1
+def _SRPClientStart_libsrp_bp(hilda, *args):
     username = hilda.registers.x2
     username_len = hilda.registers.x3
     password = hilda.registers.x4
@@ -91,8 +87,7 @@ def SRPClientStart_libsrp_bp(hilda, *args):
     hilda.cont()
 
 
-def cced25519_sign_bp(hilda, *args):
-    digest_info = hilda.registers.x0
+def _cced25519_sign_bp(hilda, *args):
     sig = hilda.registers.x1
     len = hilda.registers.x2
     msg = hilda.registers.x3
@@ -109,8 +104,7 @@ def cced25519_sign_bp(hilda, *args):
     hilda.cont()
 
 
-def cced25519_verify_bp(hilda, *args):
-    digest_info = hilda.registers.x0
+def _cced25519_verify_bp(hilda, *args):
     sig = hilda.registers.x3
     len = hilda.registers.x1
     msg = hilda.registers.x2
@@ -125,7 +119,7 @@ def cced25519_verify_bp(hilda, *args):
     hilda.cont()
 
 
-def CryptoHKDF_bp(hilda, *args):
+def _CryptoHKDF_bp(hilda, *args):
     descriptor = hilda.registers.x0
     key = hilda.registers.x1.peek(hilda.registers.x2)
     salt = hilda.registers.x3
@@ -177,14 +171,14 @@ def _chacha20_poly1305_decrypt_all_bp(hilda, *args):
 def monitor_crypto_functions() -> None:
     hilda_client = lldb.hilda_client
 
-    hilda_client.symbols.TLV8CopyCoalesced.bp(TLV8CopyCoalesced_bp)
-    hilda_client.symbols.TLV8BufferAppend.bp(TLV8BufferAppend_bp)
-    hilda_client.symbols.SRPClientStart_libsrp.bp(SRPClientStart_libsrp_bp)
+    hilda_client.symbols.TLV8CopyCoalesced.bp(_TLV8CopyCoalesced_bp)
+    hilda_client.symbols.TLV8BufferAppend.bp(_TLV8BufferAppend_bp)
+    hilda_client.symbols.SRPClientStart_libsrp.bp(_SRPClientStart_libsrp_bp)
     hilda_client.symbols.SRPClientVerify_libsrp.monitor()
     hilda_client.symbols.SRPServerStart_libsrp.monitor()
     hilda_client.symbols.SRPServerVerify_libsrp.monitor()
-    hilda_client.symbols.cced25519_sign.bp(cced25519_sign_bp)
-    hilda_client.symbols.cced25519_verify.bp(cced25519_verify_bp)
-    hilda_client.symbols.CryptoHKDF.bp(CryptoHKDF_bp)
+    hilda_client.symbols.cced25519_sign.bp(_cced25519_sign_bp)
+    hilda_client.symbols.cced25519_verify.bp(_cced25519_verify_bp)
+    hilda_client.symbols.CryptoHKDF.bp(_CryptoHKDF_bp)
     hilda_client.symbols._chacha20_poly1305_encrypt_all.bp(_chacha20_poly1305_encrypt_all_bp)
     hilda_client.symbols._chacha20_poly1305_decrypt_all.bp(_chacha20_poly1305_decrypt_all_bp)

hilda/snippets/uuid.py

@@ -1,4 +1,4 @@
-from construct import Struct, Int64ul, Int32ul, Int8ul, Array
+from construct import Array, Int8ul, Int32ul, Int64ul, Struct
 
 uuid_t = Struct(
     'time_low' / Int64ul,

hilda/snippets/xpc.py

@@ -54,6 +54,15 @@ def from_xpc_object(address: int):
     return lldb.hilda_client.from_ns(f'_CFXPCCreateCFObjectFromXPCObject({address})')
 
 
+def disable_transaction_exit():
+    """
+    xpc_transaction_exit_clean will kill the process when transaction is done.
+    By patching this function the process will stay alive.
+    """
+    hilda = lldb.hilda_client
+    hilda.symbols.xpc_transaction_exit_clean.poke_text('ret')
+
+
 def to_xpc_object(obj: object):
     """
     Convert python object to XPC object.

hilda/symbol.py

@@ -1,7 +1,8 @@
-from construct import FormatField
-from contextlib import contextmanager
-import struct
 import os
+import struct
+from contextlib import contextmanager
+
+from construct import FormatField
 
 from hilda.objective_c_class import Class
 
@@ -119,8 +120,11 @@ class Symbol(int):
     def poke(self, buf):
         return self._client.poke(self, buf)
 
-    def peek_str(self, encoding=None):
-        return self._client.peek_str(self, encoding)
+    def poke_text(self, code: str) -> int:
+        return self._client.poke_text(self, code)
+
+    def peek_str(self):
+        return self._client.peek_str(self)
 
     def monitor(self, **args):
         return self._client.monitor(self, **args)

hilda/symbols_jar.py

@@ -2,7 +2,7 @@ from contextlib import suppress
 
 import lldb
 
-from hilda.exceptions import SymbolAbsentError, AddingLldbSymbolError
+from hilda.exceptions import AddingLldbSymbolError, SymbolAbsentError
 
 
 class SymbolsJar(dict):

hilda/ui/colors.json

@@ -0,0 +1,13 @@
+{
+  "title": "green",
+  "address": "bright_blue",
+  "regs_title": "green",
+  "regs_name": "cyan",
+  "regs_value": "white",
+  "mnemonic": "white",
+  "operands": "white",
+  "basename": "yellow",
+  "stack_offset": "white",
+  "stack_data": "white",
+  "diff": "red"
+}