Emulator fidelity — what the hardware work taught us
Notes on making pspemu behave more like the real PSP, grounded in findings from
the hardware/RE effort (see ../psp_out/ docs). Implemented items are done;
opportunities are ranked by value.
Implemented (this pass)
1. Per-load stack canary (SVC 0xA2 TRNG + loader write) — DONE
The biggest emulator/hardware gap, flagged in
../psp_out/VULN-ASD-202-CANARY-LEAK.md: "the emulator uses the build-time guard
placeholder; on hardware the same code discloses the runtime (loader-randomised)
guard."
Mechanism recovered from bl_load_ta_image (sos2 0x1665A): the TA header field
at image_base+0x20 holds the VA of __stack_chk_guard; the loader reads one CCP
TRNG word (SVC 0xA2) and stores it there. The shipped image only carries the
0x33333333 placeholder.
Now modelled:
Component.trng_word()— seedable TRNG source (config['trng_seed']).svc_read_trng(SVC 0xA2) — returns a fresh TRNG word.Component._randomize_canary()— at load, readsimage_base+0x20and writes a TRNG word to__stack_chk_guard(HDCP0x404334, ASD0xD19878, verified).config['randomize_canary']=Falsekeeps the placeholder for deterministic runs.
Effect: emulated stack overflows now hit a random canary (can't pass without a leak), and canary-leak PoCs disclose the runtime-random value — matching hardware. Reproducible per seed.
2. Optional stale-memory fill — DONE
Real hardware does not zero stack/scratch between calls, so uninitialised reads
return stale data — that is precisely how the ASD 0x202 leak (uninit src[4])
and the bl_derive_key 4-byte kernel-stack leak disclose secrets. Unicorn
zero-fills, hiding them.
config['stale_fill']=<byte> pre-fills stack+scratch with a recognisable pattern
so uninitialised-read disclosures surface instead of reading 0. Default None
(zero) preserves existing behaviour and tests. Combined with the canary model, the
0x202 leak reproduces naturally: prime via 0x308 (writes the random canary onto
the stack frame), then 0x202 reads the stale word back.
Opportunities — INVESTIGATED, confirmed not worth implementing
An SVC-usage survey across the whole TA command surface (HDCP 0x00-0x15, ASD
0x100/0x103/0x160/0x180/0x1a0/0x1a7/0x200/0x202/0x300/0x308) settled these
empirically: the only SVCs any TA execution path invokes are 0xF2 (RPC gate)
and 0x8D (ASIC id) — both handled, zero unhandled. The rest never arise.
A. Correct SVC 0x5A/0x5B semantics — confirmed LOW value
svc_5A_5B_wait_events (sos2 0x6E40) is a wait-on-events primitive, not the
map/reserve an older name implied. But no TA path invokes 0x5A/0x5B at all (the
survey shows only 0xF2/0x8D), so the ZERO_SVCS treatment is never exercised
by a TA harness. Only relevant to a full mailbox-loop/scheduler model — not built.
B. TMR fence poison — confirmed LOW value
Hardware fences the TMR (host reads 0xFF, writes dropped;
../psp_out/VULN-CONFIRMED-TMR-RANGE-ROLLBACK.md). TAs never address the TMR;
confirmed — no TA path touches it. Only a full-boot/SYS_DRV model would need it.
C. Crypto DACR confinement — already modelled architecturally
SERVICE1-CRYPTO-ANALYSIS.md: the crypto service (SVC 0xF2 id 1) writes only into
the caller's MMU domain (DACR switch), which is why its overflow stays TA-side.
The emulator gives each TA its own Unicorn instance mapping only that TA's
regions, so a crypto write outside the caller's space faults on unmapped
memory — exactly the boundary the DACR enforces. The confinement is therefore
modelled by construction; no explicit check needed.
D. Reachability facts — harness-shaping, already followed
- ASD refuses host
INVOKE_CMD(0x4); reachable only as SVC 0xF2 service 2 from a TA. Harnesses drive ASD via the RPC gate / its dispatcher, not a host-invoke. - The GFX-ring allow-list is bypassed at runtime (
ring==0xFFFF); reachable SYS_DRV RPC set is ~30, not 8.sysdrv_envalready exercises the broad set.
Bonus: the canary model reproduces the exact hardware crash
With the per-load canary in place, driving HDCP subcmd12 into the crypto MAC
overrun now faults at pc=0x0040433c -> read of 0xdeadbeef — byte-for-byte
the __stack_chk_fail crash signature recorded in
../psp_out/HANG-ROOT-CAUSE.md (fault_lr 0x40173e, PC 0x40433c, FAR
0xdeadbeef). Before the model the canary was the placeholder; the crash location
is now hardware-accurate, which is what makes the emulator usable for judging
canary-gated exploitability.
Caveats carried over
sysdrv_env's synthesised config/flash overlays only unblock init — any fuzzing fault touching cfg-derived state is SUSPECT until checked on real config.- The
.53builds were extracted from a linux-firmware container; prefer the../psp_out/handover/elf/versions/copies for version-accurate work.
Boot-chain emulation (self-bootstrapping) — foundation built, roadmap
Goal: instead of running one module with stubbed boundaries, have the components
run each other — sOS stands up, SYS_DRV/ASD register as services, a TA's
SVC 0xF2 reaches the REAL SYS_DRV/ASD code. This finds bugs the stubbed model
cannot (real crypto, real sysdrv_tee_map_shared_mem, real cross-component flow).
Done: pspemu/system.py — the unified address space
The resident components occupy non-overlapping ranges (verified), so System
maps sOS (0x0), ASD (0xD00000), SYS_DRV (0xE00000) and a TA window (0x400000)
into ONE Unicorn instance plus the shared MMIO/mailbox/host-shm apertures.
Demonstrated: real sOS memmove_aligned executes in the shared space with all
three other images resident. This is the prerequisite brick for everything below.
The four remaining pieces, ranked by value/effort
-
Nested SVC 0xF2 routing (MEDIUM effort, HIGHEST value).
System.route_svc_f2is a stub hook point. Real routing = when a TA traps on SVC 0xF2, save its frame, enter sOS'ssvc_f2_rpc_gate(0x22B4) with the caller's R0/R1, run to its return (a magic-return trampoline), then resume the TA with R0. This alone turns the stubs into real inter-component calls and is the single biggest step. -
"Warm-boot" service state (MEDIUM). Rather than run the hardware-coupled cold boot, synthesise the post-init state sOS/SYS_DRV need: the
service_desc_table(so 0xF2 routes id 1->crypto, 2->ASD, SYS_DRV), the resource/PCB tables, and the per-process caps (so the SVC type-gate behaves).sysdrv_envalready does this piecemeal for SYS_DRV standalone; generalise it. -
Cooperative scheduler (MEDIUM-LARGE). sOS spawns tasks (
bl_legacy_mailbox_loop,bl_ring_service_loop) and yields via SVC 0x60 / 0x56 / 0x5B (wait-events). A real boot needs a run queue and context switch. Only needed to model the event-driven command delivery, not single RPCs. -
ARM MMU / DACR — ~~LARGE, or SKIP~~ SUPERSEDED; do not follow this item. It recommended running flat-physical and no-opping the MMU SVCs. That advice is obsolete and contradicts the measured section "Unicorn does have an ARM MMU" below in this same file: the MMU is enabled by sOS's own init, QEMU honours the short-descriptor tables, and
DACR = 0x00004505is live.
Domain enforcement is not merely present but effective, and this is now
checked by harness/sos_gate.py rather than asserted: a section placed in a
no-access domain faults, a client domain with AP=0 faults, and the manager
case reads cleanly as a positive control. sOS's own DACR writes
(mcr p15,0,rX,c3,c0,0 at 0x1B4 / 0x264 / 0x294) execute 3944 times in a
bounded boot. Nothing here needs building; it needed measuring.
Cold boot vs warm boot — the honest call
A fully faithful cold boot (sOS reset vector -> init -> load SYS_DRV -> ...) needs
the whole SoC hardware model (SPI, CCP, IRQ controller, SMU, MMU) and the on-chip
boot ROM (not in any image we have). That is a multi-week effort with steep
hardware-modelling risk. The warm-boot path (items 1+2, flat MMU) reaches the
valuable end state — real inter-component RPC execution — for a fraction of the
cost, and is the recommended next milestone. System is the foundation it builds on.
3. SVC 0x72 heap-pool provider — DONE (the SYS_DRV heap was DEAD)
The single biggest SYS_DRV fidelity gap found so far: every heap_alloc in the
emulator failed, so gp_object_allocate, gp_operation_allocate,
object_buffer_realloc and the whole chunk allocator were unreachable. No
emulator fuzzing had ever executed SYS_DRV heap code.
Mechanism, recovered from heap_alloc (0xE08884):
r0 = client ; r1 = sp+4 ; r2 = sp
svc #0x72
cbnz r0, bail ; NONZERO RETURN = ERROR
r0 = [sp+4] ; pool BASE written by the syscall
r1 = [sp] ; pool SIZE written by the syscall
bl heap_pool_init
0x72 is an out-parameter syscall: write pool base to *R1, pool size to
*R2, return 0. It was unregistered, so it defaulted to 0, [sp+4] stayed 0,
and heap_alloc dereferenced 0+4 — READ_UNMAPPED at 0x4, pc=0xE088A6 — or
silently returned NULL. A first attempt that returned the pool pointer as the
return value also failed, because cbnz r0 reads any nonzero as an error.
Also note heap_pool_get (0xE0ECB0) is not a getter: it is
MOV.W R1,#0x2A000 ; SVC 0x7D, i.e. it asks the kernel for the pool. The
generic svc_reg_block stub ignored R1 and returned a fresh 0x40 block per
call, so the "pool pointer" changed on every call. 0x2A000 is the pool size the
firmware itself requests, and is now the make(pool_size=...) default.
Implemented as _install_heap_pool() in pspemu/sysdrv_env.py; make() calls
it and exposes c.heap_pool = {"base","size"} for harnesses.
Verified: after make() + run_init(), six heap_alloc calls succeed and the
chunk list walks cleanly — 7 live chunks, 32-byte headers, payload at node+32,
magic 0x56, free tail sized 0x29D60.
4. Instrumentation gotcha: mem-write hooks perturb or corrupt
Measured in this Unicorn/Python build, and the reason
harness/fuzz_sysdrv_hostreach.py uses snapshot/diff rather than a PC-filtered
UC_HOOK_MEM_WRITE:
- Adding a mem-write hook after the first
emu_startcorrupts execution:heap_allocthen returns into its own literal pool (READ_UNMAPPED at 0x01c4ae40, pc=0xE088DC, which is data, not code). - Adding it before
run_initperturbs init itself: the pool lands at a different base, the 2nd allocation fails (returns 0) and the 3rd and 4th return the same pointer. Raisingcountfrom 2e6 to 5e7 changes nothing, so it is not instruction-budget exhaustion.
Rule: install instrumentation before any emulation, or prefer snapshot/diff. Snapshot/diff cannot perturb the guest and was validated with an explicit positive control (a 0x48-byte memcpy into a 0x40 payload is detected reaching the adjacent chunk header) and negative control (0 diffs when idle).
5. Faithful param-slot population (do not patch param_slot_lookup)
gp_crypto_dispatch/sysdrv_rpc_dispatch reject a whole request with
-65521 (0xFFFF000F) when a {ptr,len} slot is non-zero but
param_slot_lookup(opcode, slot) returns 0 for it. A harness that fills all
four slots therefore gets 0xFFFF000F for every GP opcode and fuzzes nothing —
observed directly.
harness/fuzz_sysdrv.py patches param_slot_lookup to return 1, which makes
every slot a pointer slot — more permissive than hardware, and the source of
the "scalars in pointer slots clobber stack" artifacts its own docstring warns
about. The better approach, used in fuzz_sysdrv_hostreach.py, is to query
param_slot_lookup(op, slot) in the guest and populate only the slots the
firmware itself expects. Faithful and it unblocks the path.
Full sOS boot from the reset vector (harness/boot_sos_full.py)
sOS boots from image offset 0 (ARM mode, reset = b #0x98) through to
bl_main's service loop: 42.8 M instructions, 255 distinct blocks, 17 M SVCs.
See psp_out/FINDING-FULL-SOS-BOOT-IN-EMULATOR.md.
Three divergences this harness deliberately introduces — do not draw security conclusions through them:
- Two CP15 writes are NOP'd:
0x5274 MCR p15,0,r0,c1,c1,0(SCR) and0x527a MCR p15,0,r0,c12,c0,1(MVBAR). Unicorn's Cortex-A5 model has no TrustZone banked registers and raisesUC_ERR_INSN_INVALID. Both are write-only config on this path, but if anything later reads SCR back this harness is silently wrong. (They are Thumb T32 encodings; an ARM-mode-only disassembly scan finds neither.) - All SVCs return 0. The boot path only branches on failure
(
CBNZ R0 -> bl_fatal_hang), so 0 = success everywhere. This makes the boot permissive: some of those 17 M SVCs would fail on hardware and take other branches. The boot proves the path is executable, not faithful. - ~~Page tables are not honoured.
sos_mmu_initruns andmmu_map_pageexecutes, but Unicorn has no ARM MMU, so everything stays flat/identity. In particular the real TA page attributes (RW+X,DACR=0x55555555) are not modelled.~~
RETRACTED — this is wrong. Unicorn is QEMU and implements the ARMv7
short-descriptor MMU fully; measured after a normal boot,
SCTLR = 0x00C5107D (M=1, MMU enabled). From the moment sos_mmu_init
sets SCTLR.M, every guest access is translated by sOS's own page tables and
uc.mem_map() only controls what physical memory exists behind them. See
"RETRACTION: Unicorn DOES implement the ARM MMU" later in this file for the
measurement and for the count= trap that follows from it. The retraction
is repeated here because this list is what a reader hits first, and the
project rule is to propagate retractions to the text they contradict.
AXI apertures must be mapped explicitly and around sos_map()'s existing
mmio_lo/mmio_hi (0x3000000-0x3240000): SMN 0x1000000-0x3000000,
fabric reg 0x3240000, Syshub 0x4000000+. An overlapping mem_map() fails
silently (UcError swallowed), which produced a phantom "address still
unmapped" fault during bring-up. Also note a second UC_HOOK_MEM_INVALID
handler is shadowed by Component's own, so on-demand mapping added from
outside the class never fires.
CCP device model (pspemu/ccp.py)
CCP5-generation block: MMIO register file, 3 command queues with in-memory rings, 32-byte descriptors, 128x32-byte LSB. Engines implemented: PASSTHRU, SHA-256/384/512, RSA, ZLIB. AES/XTS/DES3/ECC deliberately raise rather than silently succeeding — a CCP that quietly "works" for an unimplemented engine would manufacture false negatives in every harness above it.
Validated by running the firmware's own drivers, not reimplementations:
harness/ccp_selftest.py— sOSccp_sha2/ccp_sha256/ccp_hmac_sha2, 11/11 vs hashlib/hmac, including multi-part midstate.harness/ccp_sysdrv_rsa.py— SYS_DRVrsa_modexp, 6/6 vspow()at 1024/2048/4096 bits with both short and long exponents.
Facts that were derived, not assumed
- LSB byte order is proven. The context is the big-endian state reversed
across the whole region — the firmware's IV table
dword_7028is byte-for-bytesha256_iv_be[::-1], with SHA-384 at+0x20and SHA-512 at+0x60. - SHA-384 truncation is load-bearing. On EOM the hardware must place the 48-byte digest reversed in the low 48 bytes, not the whole reversed 64-byte state — otherwise SHA-384 comes out rotated by exactly 16 bytes while SHA-256/512 (where digest == context length) are unaffected.
- Two different completion protocols. sOS polls
HEAD_LOuntil it equals the doorbell; SYS_DRV pollsINT_STATUS(queue+0x10) bit 1 and readsQ_STATUS(queue+0x100) & 0x3F as an error code. Completion must raise INT_STATUS bit 1 orcrypto_wait_completionspins forever. - The tail wraps.
ccp_ring_doorbellwritesring_pa + 32*((slot+1) & (size-1)), so once the ring fills the tail is numerically below the head; a linear head..tail walk runs off the end. Ring base is recovered by masking, which is sound becauseccp_queue_initrejects rings not aligned to size*32. - RSA operand layout came from RAW DISASSEMBLY. Hex-Rays renders
rsa_modexp's three memcpys asmemcpy_thunk(15007744)with arguments hidden — the same failure that hid the copy_state overflow. Layout: base at0xE50000(verbatim), exponent at+keysize(byte-reversed), modulus at0xE51000(verbatim),keysize = round_up(size,32),ctrl = flags|0x18|(keysize<<8)|0x400000. - RSA input is little-endian but output is BIG-endian.
rsa_modexpreverses the result on the way out while copying base/modulus verbatim. Confirmed independently:rsa_pad_and_verifychecksv22[modlen-1] == 0xBC, the PSS trailer, which is only last in big-endian. Getting this backwards produces a perfect byte-reversal of the right answer — a failure mode that looks like a broken engine.
Known divergence / shortcut
harness/ccp_sysdrv_rsa.py publishes the scratch globals
(dword_E257D0/D4, ring VA/PA) directly instead of running
desc_query_and_map, whose SVC 0x78/0x59 contract is not yet modelled. It does
run the real ccp_base_set, ccp_queue_reset and ccp_queue_config. The
shortcut touches no value the RSA operation itself consumes.
FIRMWARE BUG found via the model
ccp_hmac_sha2 computes a wrong HMAC-SHA512. ccp_scratch is 372 bytes;
the inner digest lands at +128+blocksize and ccp_sha2's init pass memcpy's
the IV to +304. For SHA-512 those are [256:320] and [304:368], so the opad
pass clobbers the last 16 bytes of the inner digest with the head of the
reversed SHA-512 IV before it is hashed. The emulator's output matches the
clobbered value byte-exactly, which is what shows the emulator is right and
the firmware is wrong. SHA-256 overlaps by 0; SHA-384 ends exactly at 304 —
correct with zero margin. Both in-tree callers
(sos_s3_build_auth_blob, sos_s3_verify_resume_cmd) pass alg=4, so the broken
path is dead code.
RETRACTION: Unicorn DOES implement the ARM MMU, and sOS turns it on
Earlier notes in this file and in psp_out/FINDING-FULL-SOS-BOOT-IN-EMULATOR.md
state that "Unicorn has no ARM MMU, so everything stays flat/identity" and that
sos_mmu_init runs but its page tables "are not honoured". Both are wrong.
Measured after a normal boot (CP15 read via UC_ARM_REG_CP_REG):
SCTLR (c1,c0,0,0) = 0x00C5107D -> M=1 (MMU ENABLED), C=1, I=1
TTBR0 (c2,c0,0,0) = 0x0000FC48
DACR (c3,c0,0,0) = 0x00004505
Unicorn is QEMU, and QEMU implements the ARMv7 short-descriptor MMU fully. So
from the moment sos_mmu_init sets SCTLR.M, every guest access is translated
by sOS's own page tables, and uc.mem_map() only controls what physical
memory exists behind them.
Why this mattered in practice
Running the stage-2 task (bl_stage2_task, VA 0x204894) faulted immediately at
strb.w r0,[sp,#0x1c] with a repeating intno=4 (EXCP_DATA_ABORT) and an
empty c.faults list. That combination is diagnostic:
c.faultsempty => not a host-unmapped access (UC_HOOK_MEM_INVALID never fired), somem_mapwas not the problem;intno=4looping => a GUEST MMU fault, re-raised forever because the INTR handler only understands SVC and leaves PC on the faulting insn.
bl_main requests the task stack with SVC 0x62 (va=0x280000, pa, 0x51 pages,
flags=0xC0000000). Stubbing that SVC to return 0 reports success while
creating no translation, so the VA is genuinely absent from the guest tables.
Host-mapping 0x280000 changes nothing.
Consequence
Any SVC that establishes or removes a mapping (0x62 map, 0x63 unmap, 0x7D window reserve, 0x68 cache maintenance) cannot be stubbed once the MMU is on -- it must actually edit the page tables. An "SVC returns 0" stub is not neutral here; it is a silent lie that surfaces much later as an unexplained abort.
This also means the emulator can model the real page permissions (AP bits, XN, domains) rather than treating memory as flat -- so the RW+X TA pages and the DACR domain model are observable, not just inferred.
TRAP: once the MMU is on, count= does NOT bound emu_start
An access to a VA with no guest translation takes an abort that retires zero
instructions. Unicorn's count= limit only decrements on retired
instructions, so the abort loop is unbounded: emu_start(..., count=1000) and
emu_start(..., count=200000) both hang forever, identically. It presents as
"the emulator is slow", which is misleading -- it is not slow, it is stuck.
Two symptoms that identify it:
c.faultsis EMPTY (UC_HOOK_MEM_INVALID never fires -- the host memory is mapped; it is the guest translation that is missing);- an instruction trace shows a block restarting with registers rolled back,
e.g.
sub sp,#0x28appearing to have no effect on SP.
Use armmmu.PageTableEditor.require_mapped(pc=..., sp=..., ret=..., arg=...)
before any post-boot emu_start. It refuses in microseconds instead of hanging.
All existing harnesses are unaffected: ccp_selftest, ccp_sysdrv_rsa,
verify_real_image, fuzz_pss_differential and the SYS_DRV/TA fuzzers never
boot sOS, so the MMU is off and VA == PA for them. The trap only applies to
work that runs after sos_mmu_init.
UNRESOLVED: even with pc/sp/ret/arg all verified mapped, calling an
arbitrary sOS function post-boot still hangs. So the missing-translation case
above is a cause, not the only one. Do not treat require_mapped() passing
as proof that a post-boot call is safe.
Harness runtime: where the wall-clock actually went
The boot harnesses used to take minutes. Almost none of it was emulation of anything: it was the harnesses continuing to run a system that had already finished the work being measured. Three distinct causes, measured separately.
1. Running long after quiescence (the big one)
harness/boot_sos_full.py ran a fixed count=60_000_000 instruction budget.
sOS reaches bl_main's service loop at block ~8,700 and then spins there on
SVC 0x60 forever, because nothing drives the mailbox. The remaining budget was
spent executing the same five idle blocks 8.5M times each:
| blocks | distinct | SVCs | wall | |
|---|---|---|---|---|
| fixed 60M budget | 42,834,576 | 255 | 17,130,369 | 171.8s |
| stop at quiescence | 208,698 | 255 | 80,018 | 0.83s |
99.96% of the run was idle spin. boot() now stops when no new basic
block has been discovered for IDLE_QUIESCE_BLOCKS (200k, ~24x the blocks
needed to reach the loop) and PC is inside the service loop — i.e. when the
system has demonstrably settled, not after a guessed budget.
Equivalence was checked by set-differencing the executed-block sets of the two
runs in both directions: empty both ways, 255 distinct blocks either way.
--full restores the exhaustive run and still reproduces the old numbers
exactly (42,834,576 / 255 / 17,130,369), so the fast path is a shortcut, not a
different experiment.
The 42M-entry blocks list was also replaced by a Counter. It cost ~1.5 GB of
int objects to answer len(), set() and most_common(5), all of which a
histogram answers directly.
2. Fixed drains that outlive the thing they wait for
boot_and_mailbox.py drained for _ in range(10): run(5_000_000) after the
ring TA-load and range(8) after the invoke — 90M blocks, unconditionally,
whether or not the firmware had already finished. Replaced with
drain_until(run, cond, slices, blocks), which polls the actual success
condition (session slot present / TA_InvokeCommandEntryPoint reached).
slices*blocks equals the old N*BIG, so a slow path keeps exactly the same
patience — the only change is that the common case stops when the firmware is
done. Same fix applied to fuzz_ta_invoke.py's setup (~90s per fuzzer start;
per-invoke cost is unchanged at ~1.9s, measured against a clean worktree).
Measured decomposition for boot_and_mailbox.py, each step cumulative:
| wall | note | |
|---|---|---|
| original | 188s | fixed 90M-block drains, period_blocks=2000 |
drains -> drain_until |
32.4s | -156s; the drains were 83% of the harness |
+ TIMER_PERIOD=200 |
14.8s | -17.6s; guest clock rate (see below) |
All three produce the identical result: 8/9 mailbox commands answered, 4 ring
commands into tee_cmd_dispatch, session slot [0], 22 TA blocks,
TA_InvokeCommandEntryPoint reached, 0 faults.
3. Guest clock rate — a real fidelity knob, not free speed
boot_sos_and_tas.py showed module loads at a regular ~9s cadence (0.10s,
9.13s, 18.15s, 26.97s). That is not load work; it is the firmware sitting in
delay loops polling HW_COUNTER.
The emulated clock advances COUNTER_PER_MS once every period_blocks blocks,
so with the old period_blocks=2000 one emulated millisecond costs 2000 blocks.
A ~2-second firmware delay therefore costs ~4M blocks ≈ 9s of host time.
TIMER_PERIOD |
wall | blocks | distinct | modules | TA blocks |
|---|---|---|---|---|---|
| 2000 (old) | 40.1s | 19,397,108 | 2920 | 4 | 28 |
| 500 | 14.3s | 7,370,237 | 2960 | 4 | 28 |
| 200 (new default) | 6.5s | 3,114,159 | 2960 | 4 | 28 |
| 100 | 4.8s | 2,259,641 | 2962 | 4 | 28 |
Identical verdict and identical CCP totals (PASSTHRU 93 / SHA 30 / RSA 3,
0 errors) at every setting, and coverage goes up slightly (2920 -> 2960)
because more timer paths get exercised.
State the risk plainly. Shortening the tick makes the emulated CPU slower
relative to guest time (200 blocks/ms instead of 2000), and it was already far
slower than the real part. Anything the firmware guards with a timeout is
therefore more likely to fire, not less. The evidence that it is benign here
is empirical — same loads, same CCP descriptor counts, no new faults — and it is
a per-harness knob (TIMER_PERIOD), not a change to the device model. If a
result ever depends on it, pin TIMER_PERIOD=2000 and say so.
boot_sos_and_tas.py additionally takes a done predicate (its own success
criterion: 4 modules loaded + TA code executing), checked at WFI resume
boundaries — an already-paid poll point, ~30/s — followed by a settle window
so in-flight work finishes before the numbers are read. RUN_FULL=1 restores
the unconditional wall-clock run.
Cheap hooks
Measured cost of per-block Python callbacks over an 8M-instruction boot:
| hooks installed | blocks/s |
|---|---|
| block list + INTR (old) | 314,094 |
| block hook only | 409,835 |
| INTR hook only | 365,911 |
| none | 495,382 |
A per-block Python callback costs ~1.6x. Unicorn's begin/end arguments
filter in C, so range-scoped hooks (e.g. "TA blocks only", 0x400000..0x4FFFFF)
cost nothing on the hot path — boot_and_mailbox.py and boot_sos_and_tas.py
now use that instead of testing the address inside the callback.
Note this is a floor, not a target: Interrupts._on_block is mandatory (it
delivers IRQs and enforces the deterministic block budget), so a booting harness
always pays one per-block callback.
The crypto-service gap is real but measurably not load-bearing (for fuzz_hdcp)
The remaining fidelity row says the crypto service (SVC 0xF2, id 1) is a SHA-256 stand-in and that on hardware the "real MAC always fails for unauthenticated data". That row was checked rather than assumed, and the check produced a scare that turned out to be wrong. Both halves are recorded, because the scare is easy to re-derive.
The scare: hdcp_verify_mac appears to succeed 37.5% of the time
Instrumenting hdcp_verify_mac (0x403ff4) across 3000 fuzz_hdcp iterations:
entries : 761
return values : {0xffff0000: 120, 0x00000000: 72} (192 captured returns)
and in every one of those 192 the crypto MAC op really was invoked, so they
are not early-outs. Read naively that says the stand-in authenticates 72/192
calls that hardware would reject — which would make every fuzz result downstream
of one unfaithful, exactly the way the neutered asd_validate_ptr did.
Two refinements narrowed it without settling it: all 72 successes share one
signature (mac_len=8, dst-buf=-112), but 20 failures have mac_len=8 too,
and dst never overlaps buf, so it is not the stand-in's output aliasing its
own input.
The refutation: swap the secret and see if anything moves
Decisive test — keep the stand-in, but give each MAC call a fresh random secret, so any comparison that depends on the digest being reproducible must break:
| crypto model | verify_mac success |
harness stats |
|---|---|---|
| deterministic stand-in | 72 / 192 | ok 391, CANARY_SMASH 9 |
| fresh secret per call | 72 / 192 | ok 391, CANARY_SMASH 9 |
Identical. The R0 == 0 returns do not depend on the MAC value at all, so
they are not authentication verdicts — that call site returns 0 on a path that
does not report the comparison result. The fidelity row stands: the digest never
matches, and nothing here contradicts it.
The technique is the reusable part
Swapping the crypto model and diffing the whole result is a cheap differential
test for "does any conclusion in this harness depend on crypto fidelity?" Here
the answer is no — every statistic is bit-identical under a completely
different secret. So the crypto stand-in, while genuinely unfaithful, is not
load-bearing for fuzz_hdcp's results, and closing that gap would not change
them.
That bounds the gap instead of merely restating it. It also guards against the
inverse error: R0 from a function whose name contains "verify" is not a
verdict oracle until something shows it varies with what is being verified.
