hilda 2.0.12__tar.gz → 2.0.15__tar.gz

{hilda-2.0.12 → hilda-2.0.15}/.github/workflows/python-app.yml

@@ -16,7 +16,7 @@ jobs:
 
     strategy:
       matrix:
-        python-version: [ 3.8, 3.9, "3.10", "3.11", "3.12" ]
+        python-version: [ 3.9, "3.10", "3.11", "3.12", "3.13" ]
         os: [ macos-latest ]
 
     steps:

{hilda-2.0.12 → hilda-2.0.15}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: hilda
-Version: 2.0.12
+Version: 2.0.15
 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>
@@ -31,13 +31,13 @@ Classifier: Operating System :: MacOS
 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.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3 :: Only
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: tqdm

{hilda-2.0.12 → hilda-2.0.15}/hilda/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '2.0.12'
-__version_tuple__ = version_tuple = (2, 0, 12)
+__version__ = version = '2.0.15'
+__version_tuple__ = version_tuple = (2, 0, 15)

{hilda-2.0.12 → hilda-2.0.15}/hilda/cli.py

@@ -1,6 +1,6 @@
 import logging
 from pathlib import Path
-from typing import List, Optional
+from typing import Optional
 
 import click
 import coloredlogs
@@ -23,7 +23,7 @@ def cli():
 startup_files_option = click.option('-f', '--startup_files', multiple=True, help='Files to run on start')
 
 
-def parse_envp(ctx: click.Context, param: click.Parameter, value: List[str]) -> List[str]:
+def parse_envp(ctx: click.Context, param: click.Parameter, value: list[str]) -> list[str]:
     env_list = []
     for item in value:
         try:
@@ -38,7 +38,7 @@ def parse_envp(ctx: click.Context, param: click.Parameter, value: List[str]) ->
 @click.argument('hostname', default='localhost')
 @click.argument('port', type=click.INT, default=DEFAULT_HILDA_PORT)
 @startup_files_option
-def remote(hostname: str, port: int, startup_files: List[str]) -> None:
+def remote(hostname: str, port: int, startup_files: list[str]) -> None:
     """ Connect to remote debugserver at given address """
     with create_hilda_client_using_remote_attach(hostname, port) as hilda_client:
         hilda_client.interact(startup_files=startup_files)
@@ -48,7 +48,7 @@ def remote(hostname: str, port: int, startup_files: List[str]) -> None:
 @click.option('-n', '--name', help='process name to attach')
 @click.option('-p', '--pid', type=click.INT, help='pid to attach')
 @startup_files_option
-def attach(name: Optional[str], pid: Optional[int], startup_files: List[str]) -> None:
+def attach(name: Optional[str], pid: Optional[int], startup_files: list[str]) -> None:
     """ Attach to given process and start a lldb shell """
     if name is not None:
         hilda_client = create_hilda_client_using_attach_by_name(name)
@@ -78,9 +78,9 @@ def cli_bare() -> None:
 @click.option('--cwd', help='Set the working directory for the process')
 @click.option('--flags', type=click.INT, default=0, help='Launch flags (bitmask)')
 @startup_files_option
-def launch(exec_path: str, argv: List[str], envp: List[str], stdin: Optional[Path],
+def launch(exec_path: str, argv: list[str], envp: list[str], stdin: Optional[Path],
            stdout: Optional[Path], stderr: Optional[Path], cwd: Optional[Path], flags: Optional[int],
-           startup_files: List[str]) -> None:
+           startup_files: list[str]) -> None:
     """ Attach to a given process and start a lldb shell """
     argv = list(argv)
     envp = list(envp)

{hilda-2.0.12 → hilda-2.0.15}/hilda/common.py

@@ -1,14 +1,14 @@
 from datetime import datetime
-from typing import Any, List, Mapping, Tuple, Union
+from typing import Any, Union
 
 import inquirer3
 from inquirer3.themes import GreenPassion
 
 CfSerializable = Union[
-    Mapping[str, Any], List, Tuple[Any, ...], str, bool, float, bytes, datetime, None]
+    dict[str, Any], list, tuple[Any, ...], str, bool, float, bytes, datetime, None]
 
 
-def selection_prompt(options_list: List):
+def selection_prompt(options_list: list):
     question = [inquirer3.List('choice', message='choose device', choices=options_list, carousel=True)]
     result = inquirer3.prompt(question, theme=GreenPassion(), raise_keyboard_interrupt=True)
     return result['choice']

{hilda-2.0.12 → hilda-2.0.15}/hilda/hilda_client.py

@@ -16,7 +16,7 @@ from dataclasses import dataclass, field
 from datetime import datetime, timezone
 from functools import cached_property, wraps
 from pathlib import Path
-from typing import Any, Callable, List, Optional, Union
+from typing import Any, Callable, Optional, Union
 
 import hexdump
 import IPython
@@ -125,9 +125,29 @@ def stop_is_needed(func: Callable):
     return wrapper
 
 
-class HildaClient:
-    Breakpoint = namedtuple('Breakpoint', 'address options forced callback')
+class HildaBreakpoint:
+    def __init__(self, hilda_client: 'HildaClient', lldb_breakpoint: lldb.SBBreakpoint,
+                 address: Union[str, int], forced: bool = False, options: Optional[typing.Mapping] = None,
+                 callback: Optional[Callable] = None) -> None:
+        self._hilda_client = hilda_client
+        self.address = address
+        self.forced = forced
+        self.options = options
+        self.callback = callback
+        self.lldb_breakpoint = lldb_breakpoint
+
+    def __repr__(self) -> str:
+        return (f'<{self.__class__.__name__} LLDB:{self.lldb_breakpoint} FORCED:{self.forced} OPTIONS:{self.options} '
+                f'CALLBACK:{self.callback}>')
+
+    def __str__(self) -> str:
+        return repr(self)
 
+    def remove(self) -> None:
+        self._hilda_client.remove_hilda_breakpoint(self.lldb_breakpoint.id)
+
+
+class HildaClient:
     RETVAL_BIT_COUNT = 64
 
     def __init__(self, debugger: lldb.SBDebugger):
@@ -174,7 +194,7 @@ class HildaClient:
         # convert FDs into int
         return {int(k): v for k, v in result.items()}
 
-    def bt(self, should_print: bool = False, depth: Optional[int] = None) -> List[Union[str, lldb.SBFrame]]:
+    def bt(self, should_print: bool = False, depth: Optional[int] = None) -> list[Union[str, lldb.SBFrame]]:
         """ Print an improved backtrace. """
         backtrace = []
         for i, frame in enumerate(self.thread.frames):
@@ -473,7 +493,7 @@ class HildaClient:
         with self.stopped():
             return self.evaluate_expression(call_expression)
 
-    def monitor(self, address, condition: str = None, **options) -> lldb.SBBreakpoint:
+    def monitor(self, address, condition: str = None, **options) -> HildaBreakpoint:
         """
         Monitor every time a given address is called
 
@@ -613,7 +633,7 @@ class HildaClient:
             if remove_forced or not bp.forced:
                 self.remove_hilda_breakpoint(bp_id)
 
-    def remove_hilda_breakpoint(self, bp_id):
+    def remove_hilda_breakpoint(self, bp_id: int) -> None:
         """
         Remove a single breakpoint placed by Hilda
         :param bp_id: Breakpoint's ID
@@ -647,7 +667,7 @@ class HildaClient:
         print(highlight(entitlements, XmlLexer(), TerminalTrueColorFormatter()))
 
     def bp(self, address_or_name: Union[int, str], callback: Optional[Callable] = None, condition: str = None,
-           forced=False, module_name: Optional[str] = None, **options) -> lldb.SBBreakpoint:
+           forced=False, module_name: Optional[str] = None, **options) -> HildaBreakpoint:
         """
         Add a breakpoint
         :param address_or_name:
@@ -676,15 +696,14 @@ class HildaClient:
             bp.SetCondition(condition)
 
         # add into Hilda's internal list of breakpoints
-        self.breakpoints[bp.id] = HildaClient.Breakpoint(
-            address=address_or_name, options=options, forced=forced, callback=callback
-        )
+        self.breakpoints[bp.id] = HildaBreakpoint(self, bp, address=address_or_name, forced=forced, options=options,
+                                                  callback=callback)
 
         if callback is not None:
             bp.SetScriptCallbackFunction('lldb.hilda_client.bp_callback_router')
 
         self.log_info(f'Breakpoint #{bp.id} has been set')
-        return bp
+        return self.breakpoints[bp.id]
 
     def bp_callback_router(self, frame, bp_loc, *_):
         """
@@ -968,7 +987,7 @@ class HildaClient:
         """
         block = self.symbols.malloc(size)
         if block == 0:
-            raise IOError(f'failed to allocate memory of size: {size} bytes')
+            raise OSError(f'failed to allocate memory of size: {size} bytes')
 
         try:
             yield block
@@ -1076,7 +1095,7 @@ class HildaClient:
         self.cont()
 
     def interact(self, additional_namespace: Optional[typing.Mapping] = None,
-                 startup_files: Optional[List[str]] = None) -> None:
+                 startup_files: Optional[list[str]] = None) -> None:
         """ Start an interactive Hilda shell """
         if not self._dynamic_env_loaded:
             self.init_dynamic_environment()

{hilda-2.0.12 → hilda-2.0.15}/hilda/launch_lldb.py

@@ -3,7 +3,7 @@ import os
 import sys
 from abc import ABC, abstractmethod
 from threading import Thread
-from typing import List, Optional
+from typing import Optional
 
 from hilda.exceptions import LLDBError
 from hilda.hilda_client import HildaClient
@@ -146,7 +146,7 @@ class LLDBAttachName(LLDBListenerThread):
 
 
 class LLDBLaunch(LLDBListenerThread):
-    def __init__(self, exec_path: str, argv: Optional[List[str]] = None, envp: Optional[List[str]] = None,
+    def __init__(self, exec_path: str, argv: Optional[list[str]] = None, envp: Optional[list[str]] = None,
                  stdin: Optional[str] = None,
                  stdout: Optional[str] = None, stderr: Optional[str] = None, wd: Optional[str] = None,
                  flags: Optional[int] = 0):
@@ -167,7 +167,7 @@ class LLDBLaunch(LLDBListenerThread):
         # Launch(SBTarget self, SBListener listener, char const ** argv, char const ** envp,
         # char const * stdin_path, char const * stdout_path, char const * stderr_path, char const * working_directory,
         # uint32_t launch_flags, bool stop_at_entry, SBError error) -> SBProcess
-        logger.debug(f'Lunching process  {self.exec_path}')
+        logger.debug(f'Launching process  {self.exec_path}')
         return self.target.Launch(self.listener, self.argv, self.envp,
                                   self.stdin, self.stdout, self.stderr, self.working_directory,
                                   self.flags, True,
@@ -189,7 +189,7 @@ def create_hilda_client_using_remote_attach(
 
 
 def create_hilda_client_using_launch(
-        exec_path: str, argv: Optional[List] = None, envp: Optional[List] = None, stdin: Optional[str] = None,
+        exec_path: str, argv: Optional[list] = None, envp: Optional[list] = None, stdin: Optional[str] = None,
         stdout: Optional[str] = None, stderr: Optional[str] = None, wd: Optional[str] = None,
         flags: Optional[int] = 0) -> HildaClient:
     lldb_t = LLDBLaunch(exec_path, argv, envp, stdin, stdout, stderr, wd, flags)

{hilda-2.0.12 → hilda-2.0.15}/hilda/lldb_importer.py

@@ -8,7 +8,7 @@ logger = logging.getLogger(__name__)
 
 
 def get_lldb_python_path() -> str:
-    result = subprocess.run(['lldb', '-P'], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, check=True)
+    result = subprocess.run(['lldb', '-P'], capture_output=True, text=True, check=True)
     return result.stdout.strip()
 
 

{hilda-2.0.12 → hilda-2.0.15}/hilda/objective_c_class.py

@@ -89,7 +89,7 @@ class Method:
         return f'{prefix} {name}; // 0x{self.address:x} (returns: {self.return_type})\n'
 
 
-class Class(object):
+class Class:
     """
     Wrapper for ObjectiveC Class object.
     """
@@ -273,7 +273,7 @@ class Class(object):
                 if method.is_class:
                     result.add(method.name.replace(':', '_'))
 
-        result.update(list(super(Class, self).__dir__()))
+        result.update(list(super().__dir__()))
         return list(result)
 
     def __str__(self):

{hilda-2.0.12 → hilda-2.0.15}/hilda/objective_c_symbol.py

@@ -42,7 +42,7 @@ class ObjectiveCSymbol(Symbol):
         :return: ObjectiveCSymbol object.
         :rtype: ObjectiveCSymbol
         """
-        symbol = super(ObjectiveCSymbol, cls).create(value, client)
+        symbol = super().create(value, client)
         symbol.ivars = []  # type: List[Ivar]
         symbol.properties = []  # type: List[Property]
         symbol.methods = []  # type: List[Method]
@@ -183,12 +183,12 @@ class ObjectiveCSymbol(Symbol):
             for method in sup.methods:
                 result.add(method.name.replace(':', '_'))
 
-        result.update(list(super(ObjectiveCSymbol, self).__dir__()))
+        result.update(list(super().__dir__()))
         return list(result)
 
     def __getitem__(self, item):
         if isinstance(item, int):
-            return super(ObjectiveCSymbol, self).__getitem__(item)
+            return super().__getitem__(item)
 
         # Ivars
         for ivar in self.ivars:
@@ -217,7 +217,7 @@ class ObjectiveCSymbol(Symbol):
 
     def __setitem__(self, key, value):
         if isinstance(key, int):
-            super(ObjectiveCSymbol, self).__setitem__(key, value)
+            super().__setitem__(key, value)
             return
 
         with suppress(SettingIvarError):
@@ -232,7 +232,7 @@ class ObjectiveCSymbol(Symbol):
         try:
             self._set_ivar(key, value)
         except SettingIvarError:
-            super(ObjectiveCSymbol, self).__setattr__(key, value)
+            super().__setattr__(key, value)
 
     def __str__(self):
         return self._to_str(False)

{hilda-2.0.12 → hilda-2.0.15}/hilda/registers.py

@@ -1,4 +1,4 @@
-class Registers(object):
+class Registers:
     """
     Wrapper for more convenient access to modify current frame's registers
     """

hilda-2.0.15/hilda/snippets/libmalloc.py

@@ -0,0 +1,285 @@
+from construct import Array, BitsInteger, BitStruct, Bytes, Enum, Flag, Hex, Int32ul, Int64ul, Padding, Struct, Tell
+
+from hilda.lldb_importer import lldb
+from hilda.symbol import SymbolFormatField
+
+malloc_zone_t = Struct(
+    'RESERVED_1_CFALLOCATOR' / Hex(Int64ul),
+    'RESERVED_2_CFALLOCATOR' / Hex(Int64ul),
+    'size' / SymbolFormatField(lldb.hilda_client),
+    'malloc' / SymbolFormatField(lldb.hilda_client),
+    'calloc' / SymbolFormatField(lldb.hilda_client),
+    'valloc' / SymbolFormatField(lldb.hilda_client),
+    'free' / SymbolFormatField(lldb.hilda_client),
+    'realloc' / SymbolFormatField(lldb.hilda_client),
+    'destroy' / SymbolFormatField(lldb.hilda_client),
+    'zone_name' / SymbolFormatField(lldb.hilda_client),
+    'batch_malloc' / SymbolFormatField(lldb.hilda_client),
+    'batch_free' / SymbolFormatField(lldb.hilda_client),
+    'introspect' / SymbolFormatField(lldb.hilda_client),
+    'version' / SymbolFormatField(lldb.hilda_client),
+    'memalign' / SymbolFormatField(lldb.hilda_client),
+    'free_definite_size' / SymbolFormatField(lldb.hilda_client),
+    'pressure_relief' / SymbolFormatField(lldb.hilda_client),
+    'claimed_address' / SymbolFormatField(lldb.hilda_client),
+    'try_free_default' / SymbolFormatField(lldb.hilda_client),
+    'malloc_with_options' / SymbolFormatField(lldb.hilda_client),
+    'malloc_type_malloc' / SymbolFormatField(lldb.hilda_client),
+    'malloc_type_calloc' / SymbolFormatField(lldb.hilda_client),
+    'malloc_type_realloc' / SymbolFormatField(lldb.hilda_client),
+    'malloc_type_memalign' / SymbolFormatField(lldb.hilda_client),
+    'malloc_type_malloc_with_options' / SymbolFormatField(lldb.hilda_client),
+)
+
+nanov2_statistics_t = Struct(
+    'allocated_regions' / Hex(Int32ul),
+    'region_addresses_clhashes' / Hex(Int32ul),
+    # 'size_class_statistics' / Array(16, nanov2_size_class_statistics)
+)
+
+nanozonev2_s = Struct(
+    'address' / Tell,
+    'basic_zone' / malloc_zone_t,
+    # pad used to mprotect the first page
+    Padding(0x4000 - malloc_zone_t.sizeof()+32),
+    # metadata of arena blocks
+    'current_block' / Hex(Int64ul),
+    # current_block_lock omitted
+    Padding(0x2fd4),
+    'delegate_allocations' / Hex(Int32ul),
+    'debug_flags' / Hex(Int64ul),
+    'aslr_cookie' / Hex(Int64ul),
+    'aslr_cookie_aligned' / Hex(Int64ul),
+    'slot_freelist_cookies' / Hex(Int64ul),
+    'helper_zone' / Hex(Int64ul),
+    'block_lock' / Hex(Int32ul),
+    'regions_lock' / Hex(Int32ul),
+    'first_region_base_ptr' / Hex(Int64ul),
+    'current_region_next_arena' / Hex(Int64ul),
+    'madvise_lock' / Hex(Int64ul),
+    'nanov2_statistics_t' / nanov2_statistics_t
+)
+
+nanov2_size_class_statistics = Struct(
+    'total_allocations' / Hex(Int64ul),
+    'total_frees' / Hex(Int64ul),
+    'madvised_blocks' / Hex(Int64ul),
+    'madvise_races' / Hex(Int64ul),
+)
+
+
+class NanoV2Zone:
+
+    def __init__(self, nanov2_base_addr, helper_zone_ptr):
+        self.nanov2_base_addr = nanov2_base_addr
+        self.nanov2_struct = nanozonev2_s.parse_stream(self.nanov2_base_addr)
+        if not self._sanity_check(helper_zone_ptr):
+            self.nanov2_struct = None
+
+    def _sanity_check(self, helper_zone_ptr):
+        return helper_zone_ptr == int(str(self.nanov2_struct.helper_zone), 16)
+
+    def get_nanov2_struct(self):
+        return self.nanov2_struct
+
+
+class NanoV2Arena:
+    # You would have to iterate for 64 times to dump everything. But not going to dump 64MB...
+    # Found at nanov2_malloc.c
+    size_per_slot = [16, 32, 48, 64, 80, 96, 112, 128, 144, 160, 176, 192, 208, 224, 240, 256]
+    blocks_per_size = [2, 10, 11, 10, 5, 3, 3, 4, 3, 2, 2, 2, 2, 2, 1, 2]
+    slots_per_size = [1024, 512, 341, 256, 204, 170, 146, 128, 113, 102, 93, 85, 78, 73, 68, 64]
+
+    def __init__(self, arena_base_addr):
+        self.nanov2_arena_struct = Struct(
+            # Note that this only parses 1 CPU memblock (1MB). Modify it to be 64.
+            *[\
+                f"blocks_{idx}" / Array(self.blocks_per_size[idx], \
+                                        Struct('content' / \
+                                               Array(self.slots_per_size[idx], \
+                                                     Struct('Q' / Bytes(self.size_per_slot[idx]) \
+                                                            )\
+                                                     )\
+                                               ))\
+                for idx in range(len(self.blocks_per_size))\
+            ]
+        )
+        self.arena_struct = self.nanov2_arena_struct.parse_stream(arena_base_addr)
+
+    def get_arena_struct(self):
+        return self.arena_struct
+
+
+class NanoV2ArenaMetadataBlock:
+    # This is used by libmalloc to store the metadata of the arena blocks which is used during allocations.
+    # It is a matrix because we have a list of block sizes * CPU_NUMBER.
+
+    NEXT_SLOT = Enum(BitsInteger(11),
+                     SLOT_NULL=0,
+                     SLOT_GUARD=0x7fa,
+                     SLOT_BUMP=0x7fb,
+                     SLOT_FULL=0x7fc,
+                     SLOT_CAN_MADVISE=0x7fd,
+                     SLOT_MADVISING=0x7fe,
+                     SLOT_MADVISED=0x7ff
+                     )
+
+    block_meta_t = BitStruct(
+        'in_use' / Flag,
+        'gen_count' / Hex(BitsInteger(10)),
+        'free_count' / Hex(BitsInteger(10)),
+        'next_slot' / NEXT_SLOT,
+    )
+
+    def __init__(self, curr_block_addr):
+        self.nanov2_arena_metablock_t = Struct(
+            # We can't directly parse the block_meta with the CStruct.
+            # It has to be Int32ul first because BitStruct does not handle unalignment properly.
+            "arena_block_meta" / Array(4096, Hex(Int32ul))
+        )
+        self.curr_block_addr = curr_block_addr
+        self.arena_metadata_block = self.nanov2_arena_metablock_t.parse_stream(curr_block_addr)
+
+    def dump_arena_metadata_block(self):
+        block_idx = 0
+        for meta_block in self.arena_metadata_block.arena_block_meta:
+            hex_meta_contents = str(meta_block)[2:]
+            block_meta_struct = self.block_meta_t.parse(bytes.fromhex(hex_meta_contents))
+            if block_meta_struct.in_use:
+                print(f"Arena block index {block_idx} (CPU {int(block_idx / 64) - 1}): next: {block_meta_struct.next_slot}")
+            block_idx = block_idx + 1
+
+
+RACK_TYPE = Enum(Int32ul,
+                 RACK_TYPE_NONE=0,
+                 RACK_TYPE_TINY=1,
+                 RACK_TYPE_SMALL=2,
+                 RACK_TYPE_MEDIUM=3
+                 )
+
+region_hash_generation_t = Struct(
+    'num_regions_allocated' / Hex(Int64ul),
+    'num_regions_allocated_shift' / Hex(Int64ul),
+    'hashed_regions_ptr' / Hex(Int64ul),
+    'nextgen_ptr' / Hex(Int64ul),
+)
+
+rack_s = Struct(
+    # Keep in mind this struct is MALLOC_CACHE_ALIGN(128) aligned.
+    'address' / Tell,
+    'region_lock' / Hex(Int32ul),
+    'type' / RACK_TYPE,
+    'num_regions' / Hex(Int64ul),
+    'num_regions_dealloc' / Hex(Int64ul),
+    'region_generation_ptr' / Hex(Int64ul),
+    'rg' / Array(2, region_hash_generation_t),
+    'initial_regions' / Array(64, Hex(Int64ul)),
+    'num_magazines' / Hex(Int32ul),
+    'num_magazines_mask' / Hex(Int32ul),
+    'num_magazines_mask_shift' / Hex(Int32ul),
+    'debug_flags' / Hex(Int32ul),
+    'magazines' / Hex(Int64ul),
+    'cookie' / Hex(Int64ul),
+    'last_madvise' / Hex(Int64ul),
+)
+
+szone_t = Struct(
+    'address' / Tell,
+    'basic_zone' / malloc_zone_t,
+    # it seems like the offset is 0x4068 from the start of the basic_zone to the tiny rack
+    Padding(0x4000 - malloc_zone_t.sizeof() + 0x68),
+    'cpu_id_key' / Hex(Int64ul),
+    'debug_flags' / Hex(Int64ul),
+    'log_address' / Hex(Int64ul),
+    'tiny_rack' / rack_s,
+    Padding(0x78),
+    'small_rack' / rack_s,
+    Padding(0x78),
+    'medium_rack' / rack_s,
+    'large_szone_lock' / Hex(Int32ul),
+    'num_large_objects_in_use' / Hex(Int32ul),
+    'num_large_entries' / Hex(Int32ul),
+    'large_entries' / Hex(Int64ul),
+    'num_bytes_in_large_objects' / Hex(Int64ul),
+    # for macOS, CONFIG_LARGE_CACHE is True. For iOS is False (TODO)
+)
+
+
+class HelperZone:
+    def __init__(self, helper_zone_ptr):
+        self.szone_struct = szone_t.parse_stream(helper_zone_ptr)
+
+    def get_helper_zone(self):
+        return self.szone_struct
+
+
+def _get_nanov2_zone():
+    hilda = lldb.hilda_client
+    default_nanozone_ptr = hilda.symbols.malloc_zones[0][0]
+    # we need the helper_zone_ptr to perform a sanity check on the parsing.
+    helper_zone_ptr = hilda.symbols.malloc_zones[0][1]
+    return NanoV2Zone(default_nanozone_ptr, helper_zone_ptr)
+
+
+def dump_helper_zone():
+    hilda = lldb.hilda_client
+    helper_zone_ptr = hilda.symbols.malloc_zones[0][1]
+    helper_zone = HelperZone(helper_zone_ptr)
+    print(helper_zone.get_helper_zone())
+
+
+def dump_nanov2_zone():
+    nano_zone_class = _get_nanov2_zone()
+    print(nano_zone_class.get_nanov2_struct())
+
+
+def dump_used_arena():
+    """
+    Arena first block is the metadata
+    Afterwards, arena consists of 64 logical blocks (1 per each CPU) that each of them is 1MB.
+    Each CPU mem block is -> blocks_per_size = [2,10,11,10,5,3,3,4,3,2,2,2,2,2,1,2] -> 64 blocks
+    Something like this:
+
+    (remember, 1 block is 16k)
+        ----------------------------------
+        ARENA_METADATA_BLOCK - 16K
+        ----------------------------------
+                    (it is inline, this arrow is not a ptr. just drawing purposes.)
+        CPU_0_MEM_BLOCK - 1MB -----------> | BLOCK_16 * 2
+                                           BLOCK_32 * 10
+                                           BLOCK_48 * 11
+                                           .... (check blocks_per_size)
+        ----------------------------------
+        CPU_1_MEM_BLOCK - 1MB
+        ----------------------------------
+        CPU_X_MEM_BLOCK - 1MB (There are up to 64!)
+        ----------------------------------
+
+        Which makes an arena 64CPU mem blocks * 1 mb = 64mb + arena metadata block = 65mb.
+        A region consists of 8 arenas which results in 64mb * 8 = 512mb (no metadata accounted)
+    """
+
+    # Note there can be up to NANOV2_ARENAS_PER_REGION arenas (8). We will only dump 1 of them.
+    hilda = lldb.hilda_client
+    nano_zone_class = _get_nanov2_zone()
+    # arena base addr is always 0x0000600000000000 + aslr_cookie_enabled + 0x4000 (first block is the arena metablock)
+    first_region_base_ptr_int = int(str(nano_zone_class.get_nanov2_struct().first_region_base_ptr), 16)
+    aslr_cookie_aligned_int = int(str(nano_zone_class.get_nanov2_struct().aslr_cookie_aligned), 16)
+    arena_addr = first_region_base_ptr_int + aslr_cookie_aligned_int + 0x4000
+    nanov2_arena_struct = NanoV2Arena(hilda.symbol(arena_addr))
+    with open('/tmp/arena_contents.txt', 'w') as arena_dump_file:
+        print("Dumping 1MB of arena (CPU_0 mem block) contents into /tmp/arena_contents.txt.")
+        arena_dump_file.write(str(nanov2_arena_struct.get_arena_struct()))
+
+
+def dump_nanov2_block_metadata():
+    # The metadata block is the first logical block in the arena. Arena metadata is at arena_addr + aslr_cookie_aligned
+    hilda = lldb.hilda_client
+    nano_zone_class = _get_nanov2_zone()
+    first_region_base_ptr_int = int(str(nano_zone_class.get_nanov2_struct().first_region_base_ptr), 16)
+    aslr_cookie_aligned_int = int(str(nano_zone_class.get_nanov2_struct().aslr_cookie_aligned), 16)
+    metadata_addr = first_region_base_ptr_int + aslr_cookie_aligned_int
+    print(f"Arena metadata can be found at {metadata_addr:x}")
+    current_block_symbol = hilda.symbol(metadata_addr)
+    meta_block_class = NanoV2ArenaMetadataBlock(current_block_symbol)
+    meta_block_class.dump_arena_metadata_block()

{hilda-2.0.12 → hilda-2.0.15}/hilda/snippets/macho/all_image_infos.py

@@ -47,7 +47,7 @@ all_image_infos_t = Struct(
 )
 
 
-class AllImageInfos(object):
+class AllImageInfos:
     def reload(self):
         with lldb.hilda_client.stopped(1):
             all_image_infos_symbol = lldb.hilda_client.symbol(lldb.hilda_client.symbols.dyld_all_image_infos)
@@ -98,7 +98,7 @@ class AllImageInfos(object):
         if len(unique_images) > 1:
             image = AllImageInfos.__select_specific_image(unique_images)
 
-        dependencies = set([image_name.path for image_name in image.load_commands.dylib_commands])
+        dependencies = {image_name.path for image_name in image.load_commands.dylib_commands}
 
         return dependencies
 

{hilda-2.0.12 → hilda-2.0.15}/hilda/snippets/macho/image_info.py

@@ -22,7 +22,7 @@ dyld_uuid_info_t = Struct(
 )
 
 
-class ImageInfo(object):
+class ImageInfo:
     def __init__(self, image_info_data):
         self.__image_info_data = image_info_data
         self.__file_path = image_info_data.imageFilePath

{hilda-2.0.12 → hilda-2.0.15}/hilda/snippets/macho/macho_load_commands.py

@@ -1,5 +1,3 @@
-from typing import List
-
 from construct import Array, Bytes, Enum, Hex, Int8ul, Int32ul, Int64ul, PaddedString, Pointer, Seek, Struct, Switch, \
     Tell, this
 
@@ -142,7 +140,7 @@ load_command_t = Struct(
 )
 
 
-class LoadCommand(object):
+class LoadCommand:
     def __init__(self, load_command_data):
         self.__load_command_data = load_command_data
         self.__cmd = load_command_data.cmd
@@ -160,7 +158,7 @@ class LoadCommand(object):
 
 class DylibCommand(LoadCommand):
     def __init__(self, load_command_data):
-        super(DylibCommand, self).__init__(load_command_data)
+        super().__init__(load_command_data)
         dylib_data = load_command_data.data.dylib
 
         self.__path = dylib_data.lc_str.name
@@ -181,7 +179,7 @@ class DylibCommand(LoadCommand):
 
 class Segment64Command(LoadCommand):
     def __init__(self, load_command_data):
-        super(Segment64Command, self).__init__(load_command_data)
+        super().__init__(load_command_data)
 
         self.__segname = load_command_data.data.segname
         self.__vmaddr = load_command_data.data.vmaddr
@@ -210,7 +208,7 @@ class Segment64Command(LoadCommand):
 
 class UUIDCommand(LoadCommand):
     def __init__(self, load_command_data):
-        super(UUIDCommand, self).__init__(load_command_data)
+        super().__init__(load_command_data)
 
         self.__uuid = load_command_data.data.uuid
 
@@ -223,7 +221,7 @@ class UUIDCommand(LoadCommand):
 
 class BuildVersionCommand(LoadCommand):
     def __init__(self, load_command_data):
-        super(BuildVersionCommand, self).__init__(load_command_data)
+        super().__init__(load_command_data)
 
         self.__platform = load_command_data.data.platform
         self.__minos = load_command_data.data.platform
@@ -252,7 +250,7 @@ class BuildVersionCommand(LoadCommand):
 
 class UnimplementedCommand(LoadCommand):
     def __init__(self, load_command_data):
-        super(UnimplementedCommand, self).__init__(load_command_data)
+        super().__init__(load_command_data)
 
         self.__bytes = load_command_data.data
 
@@ -287,15 +285,15 @@ class LoadCommands:
         return self.__load_commands
 
     @property
-    def segment_commands(self) -> List[Segment64Command]:
+    def segment_commands(self) -> list[Segment64Command]:
         return [segment_command for segment_command in self.__load_commands if
                 isinstance(segment_command, Segment64Command)]
 
     @property
-    def dylib_commands(self) -> List[DylibCommand]:
+    def dylib_commands(self) -> list[DylibCommand]:
         return [dylib_command for dylib_command in self.__load_commands if isinstance(dylib_command, DylibCommand)]
 
-    def find(self, predicate=None) -> List[LoadCommand]:
+    def find(self, predicate=None) -> list[LoadCommand]:
         if predicate is None:
             return self.__load_commands
 

{hilda-2.0.12 → hilda-2.0.15}/hilda/symbol.py

@@ -18,7 +18,7 @@ class SymbolFormatField(FormatField):
     """
 
     def __init__(self, client):
-        super(SymbolFormatField, self).__init__('<', 'Q')
+        super().__init__('<', 'Q')
         self._client = client
 
     def _parse(self, stream, context, path):
@@ -139,10 +139,10 @@ class Symbol(int):
     def peek_str(self) -> str:
         return self._client.peek_str(self)
 
-    def monitor(self, **args) -> lldb.SBBreakpoint:
+    def monitor(self, **args):
         return self._client.monitor(self, **args)
 
-    def bp(self, callback=None, **args) -> lldb.SBBreakpoint:
+    def bp(self, callback=None, **args):
         return self._client.bp(self, callback, **args)
 
     def disass(self, size, **args) -> lldb.SBInstructionList:
@@ -165,7 +165,7 @@ class Symbol(int):
         elif whence == os.SEEK_SET:
             self._offset = offset - self
         else:
-            raise IOError('Unsupported whence')
+            raise OSError('Unsupported whence')
 
     def read(self, count: int) -> bytes:
         """ Construct compliance. """

{hilda-2.0.12 → hilda-2.0.15}/hilda/ui/views.py

@@ -1,6 +1,5 @@
 import shutil
 from abc import abstractmethod
-from typing import List, Mapping
 
 from click import style
 from lldb import SBAddress
@@ -9,7 +8,7 @@ from tabulate import tabulate
 WORD_SIZE = 8
 
 
-def dict_diff(d1: Mapping, d2: Mapping) -> List[str]:
+def dict_diff(d1: dict, d2: dict) -> list[str]:
     """ Returns a list of keys whose values have changed """
     changed_keys = []
     if d1 is None or d2 is None:
@@ -59,7 +58,7 @@ class StackView(View):
         """
         super().__init__(hilda_client, 'Stack', color_scheme)
         self.depth = depth
-        self.prev: Mapping[int, str] = None
+        self.prev: dict[int, str] = None
 
     def __str__(self) -> str:
         """ Format stack view for printing """
@@ -80,7 +79,7 @@ class StackView(View):
 
         return super().__str__() + '\n'.join(fmt_parts)
 
-    def _create_mapping(self) -> Mapping[int, str]:
+    def _create_mapping(self) -> dict[int, str]:
         """ Generate mapping of stack address:data"""
         base_addr = self.hilda.frame.sp
         stack_mapping = {}
@@ -103,7 +102,7 @@ class RegistersView(View):
         `prev` saves the last registers stats inorder to perform diff check.
         """
         super().__init__(hilda_client, 'Registers', color_scheme)
-        self.prev: Mapping[str, str] = None
+        self.prev: dict[str, str] = None
         self.rtype = rtype
 
     def __str__(self) -> str:
@@ -133,7 +132,7 @@ class RegistersView(View):
 
         return super().__str__() + tabulate(list(zip(*list_of_lists)), tablefmt='plain', numalign='left')
 
-    def _create_mapping(self) -> Mapping[str, str]:
+    def _create_mapping(self) -> dict[str, str]:
         """ Generate mapping of registers name:data"""
         regs = self._get_registers()
         regs_mapping = {}

{hilda-2.0.12 → hilda-2.0.15}/hilda.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: hilda
-Version: 2.0.12
+Version: 2.0.15
 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>
@@ -31,13 +31,13 @@ Classifier: Operating System :: MacOS
 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.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3 :: Only
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: tqdm

{hilda-2.0.12 → hilda-2.0.15}/hilda.egg-info/SOURCES.txt

@@ -45,6 +45,7 @@ hilda/snippets/boringssl.py
 hilda/snippets/collections.py
 hilda/snippets/dyld.py
 hilda/snippets/fs_utils.py
+hilda/snippets/libmalloc.py
 hilda/snippets/remotepairingd.py
 hilda/snippets/syslog.py
 hilda/snippets/uuid.py

{hilda-2.0.12 → hilda-2.0.15}/pyproject.toml

@@ -2,7 +2,7 @@
 name = "hilda"
 description = "LLDB wrapped and empowered by iPython's features"
 readme = "README.md"
-requires-python = ">=3.8"
+requires-python = ">=3.9"
 license = { file = "LICENSE" }
 keywords = ["python", "debugger", "lldb", "ipython", "ios", "debug"]
 authors = [
@@ -20,11 +20,11 @@ classifiers = [
     "Development Status :: 5 - Production/Stable",
     "License :: OSI Approved :: MIT License",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.8",
     "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
     "Programming Language :: Python :: 3 :: Only",
 ]
 dynamic = ["dependencies", "version"]