b18: S7 exit router + dstub trap + docs
This commit is contained in:
SashegDev
+403
-5
@@ -1,263 +1,661 @@
|
||||
#!/usr/bin/env python3
|
||||
|
||||
"""sbl_patch.py — reproduce all WIP file patches for SBL1 bring-up.
|
||||
|
||||
Usage: ./tools/sbl_patch.py fw/sbl/img0.elf out-dir/
|
||||
|
||||
Produces img0_bl.elf, img0_b2..b8.elf (cumulative variants, see STEPS).
|
||||
|
||||
Each step is documented with WHY (all WIP, to be replaced by real PBL).
|
||||
|
||||
"""
|
||||
|
||||
import os
|
||||
|
||||
import sys
|
||||
|
||||
|
||||
|
||||
SEG_OFF, SEG_VA = 0x3000, 0x8005800
|
||||
|
||||
|
||||
|
||||
BLX2BL = { # blx-imm -> bl (stay Thumb): set bit12 of 2nd halfword
|
||||
|
||||
0x802F658: ('d8f7c2ed', 'd8f7c2fd'),
|
||||
|
||||
0x802F660: ('d8f702ec', 'd8f702fc'),
|
||||
|
||||
}
|
||||
|
||||
NOPS = { # call -> NOP NOP (skip unmodellable init/assert; r0/r5 ignored)
|
||||
|
||||
0x802F664: 'e4f77efc', # bl walker (result ignored by caller)
|
||||
|
||||
0x802F672: 'e6f7bbfa', # bl 0x8015bec (assert-hang)
|
||||
|
||||
0x802F678: None, # bl 0x8018a78, see REDIRECT (installer runs!)
|
||||
|
||||
0x801B71E: '9847fee7', # blx r3 + b.n self (terminal assert, 4B)
|
||||
|
||||
0x8016184: 'fdf790fc', # bl 0x8013aa8 (subtree nopped, see b8)
|
||||
|
||||
}
|
||||
|
||||
REDIRECT = {
|
||||
|
||||
# bl target off-by-N fixes (verified by disasm + QEMU traces):
|
||||
|
||||
0x8013AA8: ('07f026be', '07f027be'), # jump-table case0: +2
|
||||
|
||||
0x802F678: ('e9f7fef9', 'e9f700fa'), # bl 0x8018a78 -> 0x8018a7c (+4)
|
||||
|
||||
}
|
||||
|
||||
POOLS = {
|
||||
|
||||
# literal pool words redirected to owned scratch (orig struct garbage):
|
||||
|
||||
0x801B76C: ('280b0508', '00000708'), # -> 0x08070000
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
def off(va):
|
||||
|
||||
return SEG_OFF + (va - SEG_VA)
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
def hx(d, va, n=4):
|
||||
|
||||
return d[off(va):off(va) + n].hex()
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
def set4(d, va, hexbytes):
|
||||
|
||||
d[off(va):off(va) + 4] = bytes.fromhex(hexbytes)
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
def main():
|
||||
|
||||
src, outdir = sys.argv[1], sys.argv[2]
|
||||
|
||||
os.makedirs(outdir, exist_ok=True)
|
||||
|
||||
base = bytearray(open(src, 'rb').read())
|
||||
|
||||
|
||||
|
||||
def save(d, name):
|
||||
|
||||
p = os.path.join(outdir, name)
|
||||
|
||||
open(p, 'wb').write(bytes(d))
|
||||
|
||||
print('wrote', p, len(d))
|
||||
|
||||
|
||||
|
||||
d = bytearray(base)
|
||||
|
||||
for va, (a, b) in BLX2BL.items():
|
||||
|
||||
assert hx(d, va) == a, (hex(va), hx(d, va))
|
||||
|
||||
set4(d, va, b)
|
||||
|
||||
save(d, 'img0_bl.elf')
|
||||
|
||||
|
||||
|
||||
# b2 = bl + walker NOP
|
||||
|
||||
o = off(0x802F664)
|
||||
|
||||
assert d[o:o + 4].hex() == 'e4f77efc'
|
||||
|
||||
d[o:o + 4] = bytes.fromhex('c046c046')
|
||||
|
||||
save(d, 'img0_b2.elf')
|
||||
|
||||
# b3 = b2 + 0x8015bec NOP
|
||||
|
||||
o = off(0x802F672)
|
||||
|
||||
assert d[o:o + 4].hex() == 'e6f7bbfa', hx(d, 0x802F672)
|
||||
|
||||
d[o:o + 4] = bytes.fromhex('c046c046')
|
||||
|
||||
save(d, 'img0_b3.elf')
|
||||
|
||||
# b4 = b3 + 0x8018a78 NOP
|
||||
|
||||
o = off(0x802F678)
|
||||
|
||||
assert d[o:o + 4].hex() == 'e9f7fef9', hx(d, 0x802F678)
|
||||
|
||||
d[o:o + 4] = bytes.fromhex('c046c046')
|
||||
|
||||
save(d, 'img0_b4.elf')
|
||||
|
||||
# b5 = b4 + jump-table +2
|
||||
|
||||
o = off(0x8013AA8)
|
||||
|
||||
assert d[o:o + 4].hex() == '07f026be'
|
||||
|
||||
d[o:o + 4] = bytes.fromhex('07f027be')
|
||||
|
||||
save(d, 'img0_b5.elf')
|
||||
|
||||
# b6 = b5 + terminal assert NOP (4B)
|
||||
|
||||
o = off(0x801B71E)
|
||||
|
||||
assert d[o:o + 4].hex() == '9847fee7'
|
||||
|
||||
d[o:o + 4] = bytes.fromhex('c046c046')
|
||||
|
||||
save(d, 'img0_b6.elf')
|
||||
|
||||
# b7 = b6 + redirect bl to installer entry (undoes b4 NOP)
|
||||
|
||||
o = off(0x802F678)
|
||||
|
||||
assert d[o:o + 4].hex() == 'c046c046'
|
||||
|
||||
d[o:o + 4] = bytes.fromhex('e9f700fa')
|
||||
|
||||
save(d, 'img0_b7.elf')
|
||||
|
||||
# b8 = b7 + subtree NOP + pool redirect
|
||||
|
||||
o = off(0x8016184)
|
||||
|
||||
assert d[o:o + 4].hex() == 'fdf790fc', hx(d, 0x8016184)
|
||||
|
||||
d[o:o + 4] = bytes.fromhex('c046c046')
|
||||
|
||||
o = off(0x801B76C)
|
||||
|
||||
assert d[o:o + 4].hex() == '280b0508'
|
||||
|
||||
d[o:o + 4] = bytes.fromhex('00000708')
|
||||
|
||||
save(d, 'img0_b8.elf')
|
||||
|
||||
# b9 = b8 + hole-call NOP (EDL-dead padding slide at 0x80068FC)
|
||||
|
||||
o = off(0x8008396)
|
||||
|
||||
assert d[o:o + 4].hex() == 'fef780f9', hx(d, 0x8008396)
|
||||
|
||||
d[o:o + 4] = bytes.fromhex('c046c046')
|
||||
|
||||
save(d, 'img0_b9.elf')
|
||||
|
||||
# b10 = b9 with installer-bl reverted to NOP (S2 lands mid-NOPs safely,
|
||||
|
||||
# falls into the 0x8013b7c call; installer skipped, structs via maze)
|
||||
|
||||
o = off(0x802F678)
|
||||
|
||||
assert d[o:o + 4].hex() == 'e9f700fa', hx(d, 0x802F678)
|
||||
|
||||
d[o:o + 4] = bytes.fromhex('c046c046')
|
||||
|
||||
save(d, 'img0_b10.elf')
|
||||
|
||||
# b11 = b10 with installer-bl restored (redirect, installer runs again)
|
||||
|
||||
o = off(0x802F678)
|
||||
|
||||
assert d[o:o + 4].hex() == 'c046c046'
|
||||
|
||||
d[o:o + 4] = bytes.fromhex('e9f700fa')
|
||||
|
||||
save(d, 'img0_b11.elf')
|
||||
|
||||
# b12: b10-variant with jump-table entry0 NOP (fall into entry1/case-1);
|
||||
|
||||
# rebuilt from b10 base (installer stays skipped)
|
||||
|
||||
d = bytearray(base)
|
||||
|
||||
for va, (a, b) in BLX2BL.items():
|
||||
|
||||
set4(d, va, b)
|
||||
|
||||
for va, exp, new in [
|
||||
|
||||
(0x802F664, 'e4f77efc', 'c046c046'),
|
||||
|
||||
(0x802F672, 'e6f7bbfa', 'c046c046'),
|
||||
|
||||
(0x802F678, 'e9f7fef9', 'c046c046'),
|
||||
|
||||
(0x801B71E, '9847fee7', 'c046c046'),
|
||||
|
||||
(0x8008396, 'fef780f9', 'c046c046'),
|
||||
|
||||
(0x8016184, 'fdf790fc', 'c046c046'),
|
||||
|
||||
(0x801B76C, '280b0508', '00000708'),
|
||||
|
||||
]:
|
||||
|
||||
assert hx(d, va) == exp, (hex(va), hx(d, va))
|
||||
|
||||
set4(d, va, new)
|
||||
|
||||
o = off(0x8013AA8)
|
||||
|
||||
assert d[o:o + 4].hex() == '07f026be', hx(d, 0x8013AA8)
|
||||
|
||||
d[o:o + 4] = bytes.fromhex('c046c046')
|
||||
|
||||
save(d, 'img0_b12.elf')
|
||||
|
||||
# b15 = b14 + force table-loop count (0x8013ba6 ldrh r0,[r7,#4] ->
|
||||
|
||||
# movs r0,#0xff): exit pop reads clobbered slot (->0); looping builds
|
||||
|
||||
# tables via helpers instead. 2-byte patch.
|
||||
|
||||
d = bytearray(base)
|
||||
|
||||
for va, (a, b) in BLX2BL.items():
|
||||
|
||||
set4(d, va, b)
|
||||
|
||||
for va, exp, new in [
|
||||
|
||||
(0x802F664, 'e4f77efc', 'c046c046'),
|
||||
|
||||
(0x802F672, 'e6f7bbfa', 'c046c046'),
|
||||
|
||||
(0x802F678, 'e9f7fef9', 'c046c046'),
|
||||
|
||||
(0x801B71E, '9847fee7', 'c046c046'),
|
||||
|
||||
(0x8008396, 'fef780f9', 'c046c046'),
|
||||
|
||||
(0x8016184, 'fdf790fc', 'c046c046'),
|
||||
|
||||
(0x801B76C, '280b0508', '00000708'),
|
||||
|
||||
(0x8006684, '01f807bd', '46c046c0'),
|
||||
(0x8017AFC, 'bde8fc87', 'eef7afbe'),
|
||||
|
||||
(0x8017AFC, 'bde8fc87', 'eef74fb8'),
|
||||
|
||||
]:
|
||||
|
||||
assert hx(d, va) == exp, (hex(va), hx(d, va))
|
||||
|
||||
set4(d, va, new)
|
||||
|
||||
o = off(0x8013AA8)
|
||||
|
||||
assert d[o:o + 4].hex() == '07f026be', hx(d, 0x8013AA8)
|
||||
|
||||
d[o:o + 4] = bytes.fromhex('c046c046')
|
||||
|
||||
o = off(0x8013BA6)
|
||||
|
||||
assert d[o:o + 2].hex() == 'b888', (hex(0x8013BA6), hx(d, 0x8013BA6, 2))
|
||||
|
||||
d[o:o + 2] = bytes.fromhex('ff20')
|
||||
|
||||
save(d, 'img0_b15.elf')
|
||||
|
||||
# b16 = b15 + banner call redirect (0x802f690 blx r3 -> bl banner stub
|
||||
|
||||
# at 0x08062150; table[0] is garbage 0x690ce0ee). Stub prints r0 string
|
||||
|
||||
# via UARTDM, returns 0 -> falls into cbz path (banner done).
|
||||
|
||||
d = bytearray(base)
|
||||
|
||||
for va, (a, b) in BLX2BL.items():
|
||||
|
||||
set4(d, va, b)
|
||||
|
||||
for va, exp, new in [
|
||||
|
||||
(0x802F664, 'e4f77efc', 'c046c046'),
|
||||
|
||||
(0x802F672, 'e6f7bbfa', 'c046c046'),
|
||||
|
||||
(0x802F678, 'e9f7fef9', 'c046c046'),
|
||||
|
||||
(0x801B71E, '9847fee7', 'c046c046'),
|
||||
|
||||
(0x8008396, 'fef780f9', 'c046c046'),
|
||||
|
||||
(0x8016184, 'fdf790fc', 'c046c046'),
|
||||
|
||||
(0x801B76C, '280b0508', '00000708'),
|
||||
|
||||
(0x8006684, '01f807bd', '46c046c0'),
|
||||
(0x8017AFC, 'bde8fc87', 'eef7afbe'),
|
||||
(0x802F690, '9847fee7', 'd7f7ecb8'),
|
||||
|
||||
(0x8017AFC, 'bde8fc87', 'eef74fb8'),
|
||||
|
||||
(0x802F690, '9847fee7', 'd7f7ba8c'),
|
||||
|
||||
]:
|
||||
|
||||
assert hx(d, va) == exp, (hex(va), hx(d, va))
|
||||
|
||||
set4(d, va, new)
|
||||
|
||||
o = off(0x8013AA8)
|
||||
|
||||
assert d[o:o + 4].hex() == '07f026be', hx(d, 0x8013AA8)
|
||||
|
||||
d[o:o + 4] = bytes.fromhex('c046c046')
|
||||
|
||||
o = off(0x8013BA6)
|
||||
|
||||
assert d[o:o + 2].hex() == 'b888', (hex(0x8013BA6), hx(d, 0x8013BA6, 2))
|
||||
|
||||
d[o:o + 2] = bytes.fromhex('ff20')
|
||||
|
||||
save(d, 'img0_b16.elf')
|
||||
|
||||
# b14 = b13 + redirect S6 pop (0x8017afc ldmia.w sp!,{r2-r9,sl,pc})
|
||||
|
||||
# to S6 stublet at 0x08062140 (pc slot clobbered to 0 at runtime)
|
||||
|
||||
d = bytearray(base)
|
||||
|
||||
for va, (a, b) in BLX2BL.items():
|
||||
|
||||
set4(d, va, b)
|
||||
|
||||
for va, exp, new in [
|
||||
|
||||
(0x802F664, 'e4f77efc', 'c046c046'),
|
||||
|
||||
(0x802F672, 'e6f7bbfa', 'c046c046'),
|
||||
|
||||
(0x802F678, 'e9f7fef9', 'c046c046'),
|
||||
|
||||
(0x801B71E, '9847fee7', 'c046c046'),
|
||||
|
||||
(0x8008396, 'fef780f9', 'c046c046'),
|
||||
|
||||
(0x8016184, 'fdf790fc', 'c046c046'),
|
||||
|
||||
(0x801B76C, '280b0508', '00000708'),
|
||||
|
||||
(0x8006684, '01f807bd', '46c046c0'),
|
||||
(0x8017AFC, 'bde8fc87', 'eef7afbe'),
|
||||
|
||||
(0x8017AFC, 'bde8fc87', 'eef74fb8'),
|
||||
|
||||
]:
|
||||
|
||||
assert hx(d, va) == exp, (hex(va), hx(d, va))
|
||||
|
||||
set4(d, va, new)
|
||||
|
||||
o = off(0x8013AA8)
|
||||
|
||||
assert d[o:o + 4].hex() == '07f026be', hx(d, 0x8013AA8)
|
||||
|
||||
d[o:o + 4] = bytes.fromhex('c046c046')
|
||||
|
||||
save(d, 'img0_b14.elf')
|
||||
|
||||
# b13 = b12 + NOP strb.w fp,[r1,#-7]! at 0x8006684 (helper stores
|
||||
|
||||
# fp into struct r1, but r1 arrives NULL from 0x8007e82 chain;
|
||||
|
||||
# store to [0-7]=0xfffffff9 faults; struct unrecoverable here)
|
||||
|
||||
d = bytearray(base)
|
||||
|
||||
for va, (a, b) in BLX2BL.items():
|
||||
|
||||
set4(d, va, b)
|
||||
|
||||
for va, exp, new in [
|
||||
|
||||
(0x802F664, 'e4f77efc', 'c046c046'),
|
||||
|
||||
(0x802F672, 'e6f7bbfa', 'c046c046'),
|
||||
|
||||
(0x802F678, 'e9f7fef9', 'c046c046'),
|
||||
|
||||
(0x801B71E, '9847fee7', 'c046c046'),
|
||||
|
||||
(0x8008396, 'fef780f9', 'c046c046'),
|
||||
|
||||
(0x8016184, 'fdf790fc', 'c046c046'),
|
||||
|
||||
(0x801B76C, '280b0508', '00000708'),
|
||||
|
||||
(0x8006684, '01f807bd', '46c046c0'),
|
||||
|
||||
]:
|
||||
|
||||
assert hx(d, va) == exp, (hex(va), hx(d, va))
|
||||
|
||||
set4(d, va, new)
|
||||
|
||||
o = off(0x8013AA8)
|
||||
|
||||
assert d[o:o + 4].hex() == '07f026be', hx(d, 0x8013AA8)
|
||||
|
||||
d[o:o + 4] = bytes.fromhex('c046c046')
|
||||
|
||||
save(d, 'img0_b13.elf')
|
||||
|
||||
# b17 = b16 with banner call NOPed (blx r3 + b.n self -> NOP NOP):
|
||||
|
||||
# logger is non-essential; banner stub tail gets heap-clobbered and
|
||||
|
||||
# the 4B bl return lands mid-insn. Fall through to 0x802f694.
|
||||
|
||||
d = bytearray(base)
|
||||
|
||||
for va, (a, b) in BLX2BL.items():
|
||||
|
||||
set4(d, va, b)
|
||||
|
||||
for va, exp, new in [
|
||||
|
||||
(0x802F664, 'e4f77efc', 'c046c046'),
|
||||
|
||||
(0x802F672, 'e6f7bbfa', 'c046c046'),
|
||||
|
||||
(0x802F678, 'e9f7fef9', 'c046c046'),
|
||||
|
||||
(0x801B71E, '9847fee7', 'c046c046'),
|
||||
|
||||
(0x8008396, 'fef780f9', 'c046c046'),
|
||||
|
||||
(0x8016184, 'fdf790fc', 'c046c046'),
|
||||
|
||||
(0x801B76C, '280b0508', '00000708'),
|
||||
|
||||
(0x8006684, '01f807bd', '46c046c0'),
|
||||
(0x8017AFC, 'bde8fc87', 'eef7afbe'),
|
||||
|
||||
(0x8017AFC, 'bde8fc87', 'eef74fb8'),
|
||||
|
||||
(0x802F690, '9847fee7', 'c046c046'),
|
||||
|
||||
]:
|
||||
|
||||
assert hx(d, va) == exp, (hex(va), hx(d, va))
|
||||
|
||||
set4(d, va, new)
|
||||
|
||||
o = off(0x8013AA8)
|
||||
|
||||
assert d[o:o + 4].hex() == '07f026be', hx(d, 0x8013AA8)
|
||||
|
||||
d[o:o + 4] = bytes.fromhex('c046c046')
|
||||
|
||||
o = off(0x8013BA6)
|
||||
|
||||
assert d[o:o + 2].hex() == 'b888', (hex(0x8013BA6), hx(d, 0x8013BA6, 2))
|
||||
|
||||
d[o:o + 2] = bytes.fromhex('ff20')
|
||||
|
||||
save(d, 'img0_b17.elf')
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
# b18 = b17 + S7 exit router (delay-epilogue leak fix):
|
||||
# 0x8013BAC pop{r3-r7,pc} pops 0x18 with no matching push; S3-slot
|
||||
# restarts (0x8013BA5) multiply it into a stack-eating cycle
|
||||
# (slots->fill->zeros->null-loop->IMEM overflow). Route the epilogue
|
||||
# to S7 (0x08006C10, scaffold stublet): r4<=0xff -> restart loop,
|
||||
# else restore r4/r5/sl/fp and return to sbl_main (0x802f681).
|
||||
# NOTE: overwrites BAE-path head (ldr r2,[pc,#0x28], only used when
|
||||
# [r7]==2 — never in our flow, r7=0).
|
||||
d = bytearray(base)
|
||||
|
||||
for va, (a, b) in BLX2BL.items():
|
||||
|
||||
set4(d, va, b)
|
||||
|
||||
for va, exp, new in [
|
||||
|
||||
(0x802F664, 'e4f77efc', 'c046c046'),
|
||||
|
||||
(0x802F672, 'e6f7bbfa', 'c046c046'),
|
||||
|
||||
(0x802F678, 'e9f7fef9', 'c046c046'),
|
||||
|
||||
(0x801B71E, '9847fee7', 'c046c046'),
|
||||
|
||||
(0x8008396, 'fef780f9', 'c046c046'),
|
||||
|
||||
(0x8016184, 'fdf790fc', 'c046c046'),
|
||||
|
||||
(0x801B76C, '280b0508', '00000708'),
|
||||
|
||||
(0x8006684, '01f807bd', '46c046c0'),
|
||||
|
||||
(0x8017AFC, 'bde8fc87', 'eef74fb8'),
|
||||
|
||||
(0x802F690, '9847fee7', 'c046c046'),
|
||||
|
||||
(0x8013BAC, 'f8bd0a4a', 'f3f730b8'),
|
||||
|
||||
]:
|
||||
|
||||
assert hx(d, va) == exp, (hex(va), hx(d, va))
|
||||
|
||||
set4(d, va, new)
|
||||
|
||||
o = off(0x8013AA8)
|
||||
|
||||
assert d[o:o + 4].hex() == '07f026be', hx(d, 0x8013AA8)
|
||||
|
||||
d[o:o + 4] = bytes.fromhex('c046c046')
|
||||
|
||||
o = off(0x8013BA6)
|
||||
|
||||
assert d[o:o + 2].hex() == 'b888', (hex(0x8013BA6), hx(d, 0x8013BA6, 2))
|
||||
|
||||
d[o:o + 2] = bytes.fromhex('ff20')
|
||||
|
||||
save(d, 'img0_b18.elf')
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
# b19 = b17 + 0x80065d6 ldrb r0,[r1] -> movs r0,#2 (NULL table entry:
|
||||
|
||||
# type 2 takes exit-ish path instead of faulting on bx lr=0)
|
||||
|
||||
d = bytearray(base)
|
||||
|
||||
for va, (a, b) in BLX2BL.items():
|
||||
|
||||
set4(d, va, b)
|
||||
|
||||
for va, exp, new in [
|
||||
|
||||
(0x802F664, 'e4f77efc', 'c046c046'),
|
||||
|
||||
(0x802F672, 'e6f7bbfa', 'c046c046'),
|
||||
|
||||
(0x802F678, 'e9f7fef9', 'c046c046'),
|
||||
|
||||
(0x801B71E, '9847fee7', 'c046c046'),
|
||||
|
||||
(0x8008396, 'fef780f9', 'c046c046'),
|
||||
|
||||
(0x8016184, 'fdf790fc', 'c046c046'),
|
||||
|
||||
(0x801B76C, '280b0508', '00000708'),
|
||||
|
||||
(0x8006684, '01f807bd', '46c046c0'),
|
||||
|
||||
(0x8017AFC, 'bde8fc87', 'eef74fb8'),
|
||||
|
||||
(0x802F690, '9847fee7', 'c046c046'),
|
||||
|
||||
]:
|
||||
|
||||
assert hx(d, va) == exp, (hex(va), hx(d, va))
|
||||
|
||||
set4(d, va, new)
|
||||
|
||||
o = off(0x8013AA8)
|
||||
|
||||
assert d[o:o + 4].hex() == '07f026be', hx(d, 0x8013AA8)
|
||||
|
||||
d[o:o + 4] = bytes.fromhex('c046c046')
|
||||
|
||||
o = off(0x8013BA6)
|
||||
|
||||
assert d[o:o + 2].hex() == 'b888', (hex(0x8013BA6), hx(d, 0x8013BA6, 2))
|
||||
|
||||
d[o:o + 2] = bytes.fromhex('ff20')
|
||||
|
||||
o = off(0x80065D6)
|
||||
|
||||
assert d[o:o + 2].hex() == '0878', (hex(0x80065D6), d[o:o+2].hex())
|
||||
|
||||
d[o:o + 2] = bytes.fromhex('0220')
|
||||
|
||||
save(d, 'img0_b19.elf')
|
||||
|
||||
# b20 = b19 with 0x80065d6 movs#2 -> movs#1 (helper returns 1:
|
||||
# caller cmp/beq falls through to cmp #0x25 path instead of skip)
|
||||
|
||||
o = off(0x80065D6)
|
||||
|
||||
assert d[o:o + 2].hex() == '0220'
|
||||
|
||||
d[o:o + 2] = bytes.fromhex('0120')
|
||||
|
||||
save(d, 'img0_b20.elf')
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
||||
main()
|
||||
|
||||
|
||||
@@ -0,0 +1,506 @@
|
||||
#!/usr/bin/env python3
|
||||
"""sbl_uni.py — быстрый harness SBL1 на Unicorn (без пересборки QEMU).
|
||||
Карта RAM как в saimaa; ELF-сегменты; UARTDM/TF в stdout; MMIO->0.
|
||||
Использование:
|
||||
./tools/sbl_uni.py fw/img/patch/img0_b17.elf --thumb 0x802f63f [--regs r0=0x220000,...]
|
||||
[--fill 0x085F0000:0x10000:0x08006831] [--poke 0xADDR=0xVAL] [--limit 1000000]
|
||||
Печатает: выполнено инстр., последний PC, fault-адрес, UART.
|
||||
"""
|
||||
import struct
|
||||
import sys
|
||||
|
||||
from unicorn import (Uc, UC_ARCH_ARM, UC_MODE_THUMB, UC_HOOK_MEM_UNMAPPED,
|
||||
UC_HOOK_MEM_WRITE, UC_HOOK_CODE)
|
||||
from unicorn.arm_const import (UC_ARM_REG_R0, UC_ARM_REG_R1, UC_ARM_REG_R2,
|
||||
UC_ARM_REG_R3, UC_ARM_REG_R4, UC_ARM_REG_R5,
|
||||
UC_ARM_REG_R6, UC_ARM_REG_R7, UC_ARM_REG_SP,
|
||||
UC_ARM_REG_LR, UC_ARM_REG_PC,
|
||||
UC_ARM_REG_CPSR)
|
||||
_REGS = (UC_ARM_REG_R0, UC_ARM_REG_R1, UC_ARM_REG_R2, UC_ARM_REG_R3,
|
||||
UC_ARM_REG_R4, UC_ARM_REG_R5, UC_ARM_REG_R6, UC_ARM_REG_R7)
|
||||
|
||||
RAMS = [
|
||||
(0x00000000, 0x00001000), # zero page (QEMU-compat: [0] writes succeed)
|
||||
(0x00200000, 0x00100000), # OCIMEM
|
||||
(0x00400000, 0x07400000), # RPM range (heap-ish)
|
||||
(0x08000000, 0x00600000), # DDRLOW
|
||||
(0x08600000, 0x00010000), # IMEM
|
||||
(0x80000000, 0x07C00000), # DDRHIGH_A
|
||||
(0x87C00000, 0x00800000), # SMEM(+SBL BSS)
|
||||
(0x078AF000, 0x00001000), # UARTDM page
|
||||
(0x13000000, 0x00002000), # UEFI tables (already above, keep)
|
||||
]
|
||||
UART_TF = 0x078AF070
|
||||
UART_SR = 0x078AF008
|
||||
|
||||
|
||||
def load_elf(mu, path):
|
||||
d = open(path, "rb").read()
|
||||
assert d[:4] == b"\x7fELF"
|
||||
entry = struct.unpack("<I", d[24:28])[0]
|
||||
phoff = struct.unpack("<I", d[28:32])[0]
|
||||
phnum = struct.unpack("<H", d[44:46])[0]
|
||||
for k in range(phnum):
|
||||
p = d[phoff + k * 32:phoff + (k + 1) * 32]
|
||||
t, off, v, pa, fsz, msz, fl, al = struct.unpack("<IIIIIIII", p)
|
||||
if t != 1:
|
||||
continue
|
||||
if fsz and v != 0x00220000: # QEMU parity: skip OCIMEM seg file-bytes
|
||||
mu.mem_write(v, d[off:off + fsz])
|
||||
for z in range(v + fsz, v + msz, 4):
|
||||
mu.mem_write(z, b"\x00\x00\x00\x00")
|
||||
return entry
|
||||
|
||||
|
||||
def main():
|
||||
path = sys.argv[1]
|
||||
thumb = int(sys.argv[sys.argv.index("--thumb") + 1], 0)
|
||||
mu = Uc(UC_ARCH_ARM, UC_MODE_THUMB)
|
||||
for base, size in RAMS:
|
||||
mu.mem_map(base, size)
|
||||
uart_out = []
|
||||
unmapped = {"n": 0, "first": []}
|
||||
|
||||
def hook_unmapped(mu, access, addr, size, value, data):
|
||||
unmapped["n"] += 1
|
||||
if len(unmapped["first"]) < 5:
|
||||
unmapped["first"].append((hex(addr), size, access))
|
||||
return False
|
||||
|
||||
mu.hook_add(UC_HOOK_MEM_UNMAPPED, hook_unmapped)
|
||||
# SR reads return TX-ready
|
||||
mu.mem_write(UART_SR, struct.pack("<I", 0xA0))
|
||||
mu.mem_write(0x13000000, struct.pack("<II", 0x49535953, 0x54535953))
|
||||
|
||||
def hook_uw(mu, access, addr, size, value, data):
|
||||
if addr == UART_TF:
|
||||
uart_out.append(chr(value & 0xFF))
|
||||
|
||||
mu.hook_add(UC_HOOK_MEM_WRITE, hook_uw, begin=UART_TF, end=UART_TF)
|
||||
entry = load_elf(mu, path)
|
||||
for r in range(13):
|
||||
mu.reg_write(UC_ARM_REG_R0 + r, 0)
|
||||
if "--regs" in sys.argv:
|
||||
for kv in sys.argv[sys.argv.index("--regs") + 1].split(","):
|
||||
r, v = kv.split("=")
|
||||
mu.reg_write(UC_ARM_REG_R0 + int(r[1:]), int(v, 0))
|
||||
mu.reg_write(UC_ARM_REG_SP, 0x085FFF00)
|
||||
from unicorn.arm_const import UC_ARM_REG_LR as _LR
|
||||
mu.reg_write(_LR, 0x08006B8D) # QEMU parity: stale lr -> maze
|
||||
mu.reg_write(UC_ARM_REG_CPSR, 0x13)
|
||||
if "--fill" in sys.argv:
|
||||
for spec in sys.argv[sys.argv.index("--fill") + 1].split(","):
|
||||
a, sz, v = spec.split(":")
|
||||
a, sz, v = int(a, 0), int(sz, 0), int(v, 0)
|
||||
mu.mem_write(a, struct.pack("<I", v) * (sz // 4))
|
||||
if "--poke" in sys.argv:
|
||||
for spec in sys.argv[sys.argv.index("--poke") + 1].split(","):
|
||||
a, v = spec.split("=")
|
||||
mu.mem_write(int(a, 0), struct.pack("<I", int(v, 0)))
|
||||
count = [0]
|
||||
last = [0]
|
||||
from collections import deque
|
||||
hist = deque(maxlen=20000)
|
||||
calls = [] if "--calltrace" in sys.argv else None
|
||||
rets = [] if "--retrace" in sys.argv else None
|
||||
qlog = [] if "--querylog" in sys.argv else None
|
||||
_spmax = [0x085FFF00]
|
||||
_splog = [] if "--spytrack" in sys.argv else None
|
||||
elog = [] if "--entrylog" in sys.argv else None
|
||||
_prev = [0]
|
||||
_eranges = []
|
||||
_inrng = []
|
||||
if "--entrylog" in sys.argv:
|
||||
for _spec in sys.argv[sys.argv.index("--entrylog") + 1].split(","):
|
||||
_lo, _sz = _spec.split(":")
|
||||
_lo, _sz = int(_lo, 0), int(_sz, 0)
|
||||
_eranges.append((_lo, _lo + _sz))
|
||||
_inrng.append(False)
|
||||
from unicorn.arm_const import UC_ARM_REG_CPSR as _CPSR
|
||||
|
||||
def hook_code(mu, addr, size, data):
|
||||
count[0] += 1
|
||||
last[0] = addr
|
||||
if _splog is not None:
|
||||
try:
|
||||
sp = mu.reg_read(UC_ARM_REG_SP)
|
||||
except Exception:
|
||||
sp = 0
|
||||
if sp > _spmax[0] and len(_splog) < 40:
|
||||
_spmax[0] = sp
|
||||
_splog.append((count[0], addr, sp))
|
||||
if _dirty[0]:
|
||||
# deferred restore: MEM_WRITE hooks fire BEFORE the write lands,
|
||||
# so in-hook restore gets overwritten by the instruction itself
|
||||
_inww[0] = True
|
||||
try:
|
||||
for a, b in _dirty[1]:
|
||||
mu.mem_write(a, stub_snap[a - STUB_LO:b - STUB_LO])
|
||||
finally:
|
||||
_inww[0] = False
|
||||
_dirty[0] = False
|
||||
del _dirty[1][:]
|
||||
try:
|
||||
thumb = (mu.reg_read(_CPSR) >> 5) & 1
|
||||
except Exception:
|
||||
thumb = 1
|
||||
hist.append((addr, thumb))
|
||||
if qlog is not None and addr in (0x8017EA4, 0x8017C60):
|
||||
try:
|
||||
vals = [mu.reg_read(_REGS[i]) for i in range(8)]
|
||||
except Exception:
|
||||
vals = []
|
||||
qlog.append((addr, vals,
|
||||
mu.reg_read(UC_ARM_REG_SP),
|
||||
mu.reg_read(UC_ARM_REG_LR)))
|
||||
if elog is not None:
|
||||
for _i, (_elo, _ehi) in enumerate(_eranges):
|
||||
inside = _elo <= addr < _ehi
|
||||
if inside and not _inrng[_i]:
|
||||
if len(elog) < 20000:
|
||||
elog.append((count[0], _prev[0], addr))
|
||||
_inrng[_i] = inside
|
||||
_prev[0] = addr
|
||||
if calls is not None and size in (2, 4):
|
||||
try:
|
||||
if size == 2:
|
||||
h = struct.unpack("<H", mu.mem_read(addr & ~1, 2))[0]
|
||||
is_blx = (h & 0xFF80) == 0x4780
|
||||
rm = (h >> 3) & 7 if is_blx else -1
|
||||
# bx Rm (jump, no link): 010001110 Rm:000
|
||||
is_bx = (h & 0xFF80) == 0x4700
|
||||
if is_bx:
|
||||
bxrm = (h >> 3) & 15
|
||||
try:
|
||||
if bxrm < 8:
|
||||
bxt = mu.reg_read(_REGS[bxrm])
|
||||
elif bxrm == 14:
|
||||
bxt = mu.reg_read(_LR)
|
||||
else:
|
||||
bxt = -1
|
||||
except Exception:
|
||||
bxt = -1
|
||||
if len(calls) < 8000:
|
||||
calls.append((addr, 100 + bxrm, bxt))
|
||||
if rets is not None and 0x8017E00 <= addr < 0x8018000:
|
||||
# pop {..,pc} (0xBD00+) or bx lr (0x4770)
|
||||
if h == 0x4770 or (h & 0xFF00) == 0xBD00:
|
||||
try:
|
||||
rv = mu.reg_read(_REGS[0])
|
||||
except Exception:
|
||||
rv = -1
|
||||
if len(rets) < 200:
|
||||
rets.append((addr, rv))
|
||||
else:
|
||||
w = struct.unpack("<I", mu.mem_read(addr & ~3, 4))[0]
|
||||
# ARM bx/blx Rm: cond(4) 0001001011111111111100x1 Rm(4)
|
||||
is_blx = (w & 0x0FFFFFF0) in (0x012FFF10, 0x012FFF30)
|
||||
rm = w & 15 if is_blx else -1
|
||||
tgt = -1
|
||||
if not is_blx and calls is not None:
|
||||
# Thumb32 BL: h0=11110S+imm10, h1=1111x+J+imm11
|
||||
h0 = w & 0xFFFF
|
||||
h1 = (w >> 16) & 0xFFFF
|
||||
if (h0 & 0xF800) == 0xF000 and (h1 & 0xE000) == 0xE000:
|
||||
S = (h0 >> 10) & 1
|
||||
J1 = (h1 >> 13) & 1
|
||||
J2 = (h1 >> 11) & 1
|
||||
I1 = 1 - (J1 ^ S)
|
||||
I2 = 1 - (J2 ^ S)
|
||||
off = (I1 << 23) | (I2 << 22) | ((h0 & 0x3FF) << 12) | ((h1 & 0x7FF) << 1)
|
||||
if S:
|
||||
off -= 0x1000000
|
||||
if len(calls) < 8000:
|
||||
calls.append((addr, 200, (addr + 4 + off) & 0xFFFFFFFF))
|
||||
if rets is not None and 0x8017E00 <= addr < 0x8018000:
|
||||
# pop.w {...,pc}: 0xE8BDxxxx with bit15 set
|
||||
if (w & 0xFFFF8000) == 0xE8BD8000:
|
||||
try:
|
||||
rv = mu.reg_read(_REGS[0])
|
||||
except Exception:
|
||||
rv = -1
|
||||
if len(rets) < 200:
|
||||
rets.append((addr, rv))
|
||||
if is_blx:
|
||||
try:
|
||||
tgt = mu.reg_read(_REGS[rm])
|
||||
except Exception:
|
||||
tgt = -1
|
||||
if len(calls) < 4000:
|
||||
calls.append((addr, rm, tgt))
|
||||
except Exception:
|
||||
return
|
||||
|
||||
mu.hook_add(UC_HOOK_CODE, hook_code)
|
||||
# null-fetch redirect: branch-to-0 lands in maze (movs r0,#0; bx lr),
|
||||
# immune to [0]-writes that clobber a static maze copy
|
||||
from unicorn.arm_const import UC_ARM_REG_PC as _PC
|
||||
_nulllog = []
|
||||
|
||||
def hook_null(mu, addr, size, data):
|
||||
if len(_nulllog) < 10:
|
||||
try:
|
||||
r = [mu.reg_read(_REGS[i]) for i in range(4)]
|
||||
lr = mu.reg_read(_LR)
|
||||
sp = mu.reg_read(UC_ARM_REG_SP)
|
||||
except Exception:
|
||||
r, lr, sp = [], -1, -1
|
||||
# walk back: find the branch source from hist
|
||||
_nulllog.append((count[0], r, lr, sp))
|
||||
mu.reg_write(_PC, STUB + 1)
|
||||
|
||||
mu.hook_add(UC_HOOK_CODE, hook_null, begin=0x0, end=0xFFF)
|
||||
if "--watchcode" in sys.argv:
|
||||
from unicorn.arm_const import UC_ARM_REG_PC as _PC2
|
||||
wlog = []
|
||||
|
||||
def hook_ww(mu, access, addr, size, value, data):
|
||||
if len(wlog) < 30:
|
||||
try:
|
||||
pc = mu.reg_read(_PC2)
|
||||
except Exception:
|
||||
pc = -1
|
||||
wlog.append((pc, addr, size, value))
|
||||
|
||||
mu.hook_add(UC_HOOK_MEM_WRITE, hook_ww,
|
||||
begin=0x8005800, end=0x8039254)
|
||||
import atexit
|
||||
|
||||
def _dump():
|
||||
print(f"code-writes: {len(wlog)}")
|
||||
for pc, a, sz, v in wlog[:30]:
|
||||
print(f" pc={pc:#x} [{a:#x}] sz={sz} val={v:#x}")
|
||||
atexit.register(_dump)
|
||||
# --- machine scaffold parity (saimaa.c values, verbatim) ---
|
||||
def W32(a, v):
|
||||
mu.mem_write(a, struct.pack("<I", v & 0xFFFFFFFF))
|
||||
S, STUB, STUBV = 0x08006B80, 0x08006B8C, 0x08006B8D
|
||||
W32(S, S + 8)
|
||||
W32(S + 4, STUBV)
|
||||
W32(S + 8, STUBV)
|
||||
# maze blob (18B)
|
||||
mu.mem_write(STUB, bytes([
|
||||
0x00, 0x20, 0x4f, 0xea, 0x1e, 0x6c, 0xbc, 0xf1,
|
||||
0x08, 0x0f, 0x00, 0xd1, 0x70, 0x47, 0x72, 0xb6,
|
||||
0xfd, 0xe7]))
|
||||
print("maze-rb:", bytes(mu.mem_read(STUB, 18)).hex())
|
||||
for a in (0x087c29d18, 0x08050b28, 0x08070000):
|
||||
W32(a, S)
|
||||
# S6 stublet (14B @0x08006B9E)
|
||||
mu.mem_write(0x08006B9E, bytes([
|
||||
0xbd, 0xe8, 0xfc, 0x47, 0x43, 0xf6, 0xa5, 0x3e,
|
||||
0xc0, 0xf6, 0x01, 0x0e, 0x70, 0x47]))
|
||||
# banner stub (34B @0x08006BAC, prints r0 via UARTDM)
|
||||
mu.mem_write(0x08006BAC, bytes([
|
||||
0x10, 0xb5, 0x4f, 0xf2, 0x00, 0x03, 0xc0, 0xf2,
|
||||
0x8a, 0x73, 0x21, 0x21, 0x19, 0x67, 0x10, 0xf8,
|
||||
0x01, 0x1b, 0x09, 0xb1, 0x19, 0x67, 0xfa, 0xe7,
|
||||
0x4f, 0xf2, 0x94, 0x6e, 0xc0, 0xf6, 0x02, 0x0e,
|
||||
0x70, 0x47]))
|
||||
# PBL stub (52B @0x080068C0)
|
||||
mu.mem_write(0x080068C0, bytes([
|
||||
0xf0, 0xb5, 0x46, 0xf6, 0x81, 0x3c, 0xc0, 0xf6,
|
||||
0x00, 0x0c, 0xe0, 0x47, 0x40, 0xf2, 0x00, 0x00,
|
||||
0xc0, 0xf2, 0x22, 0x00, 0x05, 0x46, 0x40, 0xf2,
|
||||
0x00, 0x0a, 0xc0, 0xf6, 0x06, 0x0a, 0x41, 0xf2,
|
||||
0x00, 0x0b, 0xc0, 0xf6, 0x06, 0x0b, 0x4f, 0xf2,
|
||||
0x3f, 0x6e, 0xc0, 0xf6, 0x02, 0x0e, 0x70, 0x47,
|
||||
0x00, 0x00, 0x00, 0x00]))
|
||||
# S7 stublet (52B @0x08006C10, b18): delay-epilogue exit router.
|
||||
# cmp r4,#0xff: iterate (r4<=0xff -> restart 0x8013ba5) or done
|
||||
# (restore r4/r5/sl/fp, return to sbl_main 0x802f681).
|
||||
mu.mem_write(0x08006C10, bytes.fromhex(
|
||||
"ff2c13d940f20004c0f2220440f20005c0f2220540f2000a"
|
||||
"c0f6060a41f2000bc0f6060bdff800f081f60208dff800f0"
|
||||
"a53b0108"))
|
||||
# stack zone fill (STUBV odd)
|
||||
mu.mem_write(0x085F0000, struct.pack("<I", STUBV) * (0x10000 // 4))
|
||||
# pop-site slots (sp values from traces)
|
||||
for a, v in [(0x085FFF14, 0x802f65d), (0x085FFF1C, 0x802f665),
|
||||
(0x085FFF44, 0x8013ba5), (0x085FFF5C, 0x802f681),
|
||||
(0x085FFF74, 0x8016183)]:
|
||||
W32(a, v)
|
||||
W32(0x085FFF58, 0)
|
||||
W32(0x085FFF34, 0)
|
||||
W32(0x085FFF54, 0)
|
||||
W32(0x085FFF6C, 0)
|
||||
W32(0x08600944, 0) # IMEM poll magic
|
||||
# minimal UEFI tables (ST/BS/RS/CO + ret0 stubs)
|
||||
ST, BS, RS, CO, STUBS, LI, HEAP = (0x13000000, 0x13000100, 0x13000200,
|
||||
0x13000300, 0x13000400, 0x13000500,
|
||||
0x13001000)
|
||||
for i in range(24):
|
||||
mu.mem_write(STUBS + i * 8, bytes([0x00, 0x20, 0x70, 0x47,
|
||||
0x00, 0x00, 0x00, 0x00]))
|
||||
W32(BS + 24 + i * 4, STUBS + i * 8 + 1)
|
||||
W32(BS, 0x56524553)
|
||||
W32(ST, 0x49535953)
|
||||
W32(ST + 4, 0x54535953)
|
||||
W32(ST + 12, 0x00020000)
|
||||
W32(ST + 16, 0x13000048)
|
||||
W32(ST + 40, CO)
|
||||
W32(ST + 44, CO)
|
||||
W32(ST + 56, RS)
|
||||
W32(ST + 60, BS)
|
||||
W32(LI, 0x3130414d)
|
||||
W32(HEAP - 4, HEAP)
|
||||
# NOTE: no vendor string bytes (QEMU leaves zeros at 0x13000048)
|
||||
# map UEFI table region (already in RAMS? add 0x13000000)
|
||||
# --- end parity ---
|
||||
# stub range is readonly on HW/QEMU: ignore SBL heap-clobber writes,
|
||||
# keep maze/stublets intact (restore-on-write with reentrancy guard)
|
||||
STUB_LO, STUB_HI = 0x080068C0, 0x08006C50 # +S7 + banner tail
|
||||
stub_snap = bytes(mu.mem_read(STUB_LO, STUB_HI - STUB_LO))
|
||||
_inww = [False]
|
||||
_swn = [0]
|
||||
_swlog = []
|
||||
_dirty = [False, []]
|
||||
print("stub-snap:", stub_snap[:24].hex())
|
||||
print("stub-snap-maze:", stub_snap[0x2CC:0x2CC + 18].hex())
|
||||
|
||||
def hook_stubw(mu, access, addr, size, value, data):
|
||||
if _inww[0]:
|
||||
return
|
||||
if addr + size <= STUB_LO or addr >= STUB_HI:
|
||||
return
|
||||
_swn[0] += 1
|
||||
if len(_swlog) < 8:
|
||||
try:
|
||||
_pc = mu.reg_read(_PC)
|
||||
except Exception:
|
||||
_pc = -1
|
||||
_swlog.append((_pc, addr, size))
|
||||
# record for deferred restore (see hook_code); in-hook restore
|
||||
# would be overwritten by the faulting instruction itself
|
||||
a = max(addr, STUB_LO)
|
||||
b = min(addr + size, STUB_HI)
|
||||
if b > a and len(_dirty[1]) < 16:
|
||||
_dirty[1].append((a, b))
|
||||
_dirty[0] = True
|
||||
|
||||
#hook all DDRLOW, filter in python (catches writes starting below LO)
|
||||
mu.hook_add(UC_HOOK_MEM_WRITE, hook_stubw,
|
||||
begin=0x08000000, end=0x085FFFFF)
|
||||
if "--watchmaze" in sys.argv:
|
||||
from unicorn.arm_const import UC_ARM_REG_PC as _PC3
|
||||
mzlog = []
|
||||
|
||||
def hook_mz(mu, access, addr, size, value, data):
|
||||
if len(mzlog) < 40:
|
||||
try:
|
||||
pc = mu.reg_read(_PC3)
|
||||
except Exception:
|
||||
pc = -1
|
||||
mzlog.append((pc, addr, size, value))
|
||||
|
||||
mu.hook_add(UC_HOOK_MEM_WRITE, hook_mz,
|
||||
begin=0x08006B8C, end=0x08006B9D)
|
||||
import atexit as _ax
|
||||
|
||||
def _dmz():
|
||||
print(f"maze-writes: {len(mzlog)}")
|
||||
for pc, a, sz, v in mzlog[:40]:
|
||||
print(f" pc={pc:#x} [{a:#x}] sz={sz} val={v:#x}")
|
||||
_ax.register(_dmz)
|
||||
if "--watchlow" in sys.argv:
|
||||
_spec = sys.argv[sys.argv.index("--watchlow") + 1].split(":")
|
||||
_wlo, _whi = int(_spec[0], 0), int(_spec[0], 0) + int(_spec[1], 0)
|
||||
from unicorn.arm_const import UC_ARM_REG_PC as _PC4
|
||||
wlolog = []
|
||||
|
||||
def hook_wlo(mu, access, addr, size, value, data):
|
||||
if len(wlolog) < 60:
|
||||
try:
|
||||
pc = mu.reg_read(_PC4)
|
||||
except Exception:
|
||||
pc = -1
|
||||
wlolog.append((pc, addr, size, value))
|
||||
|
||||
mu.hook_add(UC_HOOK_MEM_WRITE, hook_wlo,
|
||||
begin=0x08000000, end=0x085FFFFF)
|
||||
import atexit as _ax2
|
||||
|
||||
def _dwlo():
|
||||
inn = [(pc, a, sz, v) for pc, a, sz, v in wlolog
|
||||
if not (a + sz <= _wlo or a >= _whi)]
|
||||
print(f"low-writes-in-range: {len(inn)}")
|
||||
for pc, a, sz, v in inn[:60]:
|
||||
print(f" pc={pc:#x} [{a:#x}] sz={sz} val={v:#x}")
|
||||
_ax2.register(_dwlo)
|
||||
limit = 2000000
|
||||
if "--limit" in sys.argv:
|
||||
limit = int(sys.argv[sys.argv.index("--limit") + 1])
|
||||
try:
|
||||
mu.emu_start(thumb | 1, 0xFFFFFFFF, 0, limit)
|
||||
except Exception as e:
|
||||
print("EMU-EXC:", str(e)[:120])
|
||||
print("insns:", count[0], "last-pc:", hex(last[0]))
|
||||
print("unmapped:", unmapped["n"], unmapped["first"][:4])
|
||||
print("regs:",
|
||||
" ".join(f"r{i}={mu.reg_read(_REGS[i]):#x}" for i in range(8)),
|
||||
f"sp={mu.reg_read(UC_ARM_REG_SP):#x}",
|
||||
f"lr={mu.reg_read(UC_ARM_REG_LR):#x}",
|
||||
f"pc={mu.reg_read(UC_ARM_REG_PC):#x}")
|
||||
try:
|
||||
from capstone import Cs, CS_ARCH_ARM, CS_MODE_THUMB, CS_MODE_ARM
|
||||
md_t = Cs(CS_ARCH_ARM, CS_MODE_THUMB)
|
||||
md_a = Cs(CS_ARCH_ARM, CS_MODE_ARM)
|
||||
real = [(pc, th) for pc, th in hist
|
||||
if not (0 <= (pc & ~1) < 0x1000)][-48:]
|
||||
for pc, thumb in real:
|
||||
try:
|
||||
base = pc & ~1
|
||||
code = mu.mem_read(base, 8 if thumb else 12)
|
||||
md = md_t if thumb else md_a
|
||||
for ins in md.disasm(code, base):
|
||||
print(f" {base:#x}{'t' if thumb else 'a'}: {ins.mnemonic} {ins.op_str}")
|
||||
break
|
||||
except Exception:
|
||||
print(f" {pc:#x}: <unreadable>")
|
||||
except ImportError:
|
||||
print("hist:", [hex(pc) for pc, _ in list(hist)[-12:]])
|
||||
if elog is not None:
|
||||
print(f"entries: {len(elog)}")
|
||||
for n, prev, cur in elog[-30:]:
|
||||
print(f" insn#{n} {prev:#x} -> {cur:#x}")
|
||||
if _splog is not None:
|
||||
print(f"sp-highs: {len(_splog)}")
|
||||
for n, pc, sp in _splog:
|
||||
print(f" insn#{n} {pc:#x} sp={sp:#x}")
|
||||
if _nulllog:
|
||||
print(f"null-entries: {len(_nulllog)}")
|
||||
for n, r, lr, sp in _nulllog:
|
||||
print(f" insn#{n} r0-r3={[hex(x) for x in r]} lr={lr:#x} sp={sp:#x}")
|
||||
if qlog is not None:
|
||||
print(f"querylog: {len(qlog)}")
|
||||
for pc, r, sp, lr in qlog[:20]:
|
||||
print(f" {pc:#x} r0-r7={[hex(x) for x in r]} sp={sp:#x} lr={lr:#x}")
|
||||
if rets is not None:
|
||||
print(f"rets-in-range: {len(rets)}")
|
||||
for pc, rv in rets[-20:]:
|
||||
print(f" ret {pc:#x} r0={rv:#x}" if rv >= 0 else f" ret {pc:#x} r0=?")
|
||||
if calls is not None:
|
||||
print(f"blx-calls: {len(calls)}")
|
||||
bls = [(pc, tgt) for pc, rm, tgt in calls if rm == 200]
|
||||
print(f"bl-immed: {len(bls)}")
|
||||
for pc, tgt in bls[-30:]:
|
||||
print(f" {pc:#x}: bl #{tgt:#x}")
|
||||
for pc, rm, tgt in calls[-12:]:
|
||||
if rm == 200:
|
||||
continue
|
||||
tag = f"bx r{rm - 100}" if rm >= 100 else f"blx r{rm}"
|
||||
print(f" {pc:#x}: {tag} -> {tgt:#x}" if tgt >= 0 else f" {pc:#x}: {tag} -> ?")
|
||||
if "--dumpmem" in sys.argv:
|
||||
for spec in sys.argv[sys.argv.index("--dumpmem") + 1].split(","):
|
||||
a, sz = spec.split(":")
|
||||
a, sz = int(a, 0), int(sz, 0)
|
||||
print(f"mem[{a:#x}+{sz:#x}]:")
|
||||
print(bytes(mu.mem_read(a, sz)).hex())
|
||||
print("UART:", "".join(uart_out)[:160])
|
||||
print(f"stubguard-hits: {_swn[0]}")
|
||||
for _pc, _a, _s in _swlog:
|
||||
print(f" guarded pc={_pc:#x} [{_a:#x}] sz={_s}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
Reference in New Issue
Block a user