"""Instrumentation: memory-write tracing, region watchpoints, call tracing. The write tracer is the main investigative tool -- it records every store with the PC that issued it, which lets a harness reconstruct the exact extent of a memcpy (i.e. answer "how far did this copy actually reach?") without needing any hardware crash oracle. """ from collections import namedtuple Write = namedtuple("Write", "pc addr size value") class WriteTracer: """Records writes, optionally filtered to regions of interest.""" def __init__(self, ranges=None, limit=200000): self.ranges = list(ranges or []) # [(lo, hi, label)] self.writes = [] self.limit = limit self.truncated = False def watch(self, lo, hi, label): self.ranges.append((lo, hi, label)) def _interesting(self, addr, size): if not self.ranges: return True for lo, hi, _ in self.ranges: if addr < hi and addr + size > lo: return True return False def hook(self, uc, access, address, size, value, user): if not self._interesting(address, size): return if len(self.writes) >= self.limit: self.truncated = True return import unicorn pc = uc.reg_read(unicorn.arm_const.UC_ARM_REG_PC) self.writes.append(Write(pc, address, size, value)) # ---------------------------------------------------------------- queries def label_of(self, addr): for lo, hi, lab in self.ranges: if lo <= addr < hi: return lab return None def extent(self, lo, hi): """(min_addr, max_addr_exclusive, count) of writes landing in [lo,hi).""" hits = [w for w in self.writes if lo <= w.addr < hi] if not hits: return None return (min(w.addr for w in hits), max(w.addr + w.size for w in hits), len(hits)) def writes_by_pc(self): out = {} for w in self.writes: e = out.setdefault(w.pc, [0, None, None]) e[0] += 1 e[1] = w.addr if e[1] is None else min(e[1], w.addr) e[2] = w.addr + w.size if e[2] is None else max(e[2], w.addr + w.size) return {pc: dict(count=c, lo=lo, hi=hi) for pc, (c, lo, hi) in out.items()} def summary(self, top=20): lines = [] for pc, d in sorted(self.writes_by_pc().items(), key=lambda kv: -kv[1]["count"])[:top]: span = d["hi"] - d["lo"] lines.append(f" pc={pc:#010x} n={d['count']:<6} range={d['lo']:#010x}..{d['hi']:#010x} ({span:#x} bytes)") if self.truncated: lines.append(f" ... truncated at {self.limit} writes") return "\n".join(lines) or " (no writes recorded)" class ContentDiff: """Hook-free write measurement: sentinel-fill, run, then diff. PREFER THIS over WriteTracer for load-bearing measurements. Unicorn's UC_HOOK_MEM_WRITE desynchronises Thumb ITSTATE, so stores that are conditionally skipped (`it hs` / `it mi` tails in the optimised memcpy/memset routines) *do* execute while a write hook is installed. Verified on HDCP ta_memclr(0x4ff980, 0x20): 32 bytes written with no hook, 47 bytes "written" with a hook installed. Any extent derived from hook callbacks inside IT-heavy code is therefore unreliable. """ def __init__(self, comp, regions, sentinel=b"\xA5"): self.comp = comp self.regions = list(regions) # [(addr, size, label)] self.sentinel = sentinel self.before = {} def fill(self): for addr, size, label in self.regions: blob = (self.sentinel * ((size // len(self.sentinel)) + 1))[:size] self.comp.write(addr, blob) self.before[label] = blob return self def snapshot(self): for addr, size, label in self.regions: self.before[label] = self.comp.read(addr, size) return self def diff(self): """-> {label: (first_changed_off, last_changed_off_exclusive, nbytes)}""" out = {} for addr, size, label in self.regions: now = self.comp.read(addr, size) old = self.before.get(label, b"") changed = [i for i in range(min(len(now), len(old))) if now[i] != old[i]] out[label] = (changed[0], changed[-1] + 1, len(changed)) if changed else None return out class Watchpoint: """Fires a callback when a specific address range is written.""" def __init__(self, lo, hi, label, on_hit=None): self.lo, self.hi, self.label = lo, hi, label self.hits = [] self.on_hit = on_hit def hook(self, uc, access, address, size, value, user): if address < self.hi and address + size > self.lo: import unicorn pc = uc.reg_read(unicorn.arm_const.UC_ARM_REG_PC) self.hits.append(Write(pc, address, size, value)) if self.on_hit: self.on_hit(uc, pc, address, size, value) class CallTracer: """Records BL/BLX targets (coarse: logs every block entry).""" def __init__(self, symbols=None, limit=20000): self.symbols = symbols or {} self.blocks = [] self.limit = limit def hook_block(self, uc, address, size, user): if len(self.blocks) < self.limit: self.blocks.append(address) def named(self): return [(a, self.symbols.get(a)) for a in self.blocks if a in self.symbols]