patch_kernel_extended.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""patch_kernel_extended.py — безопасный патч 32-bit watchOS kernel (ARMv7).

Отличия от старой версии:
  * Строгая валидация: is_function_start() принимает ТОЛЬКО PUSH {R7,LR},
    PUSH {R4-R7,LR}, PUSH.W {LR} или MOVS R0,#imm; BX LR.
  * MOVW/MOVT в начале = НЕ функция → SKIP с предупреждением.
  * Проверка «функция заканчивается на BX LR/POP {PC} в пределах 0x100 байт».
  * AMFI-патчи: _amfi_interface_register → return 0.
  * --dry-run: показать, что будет сделано, без записи.
  * --strict: только функции с подтверждённым прологом.
"""
import sys, struct, argparse

FAT_MAGIC = 0xcafebabe
MH_MAGIC  = 0xfeedface
LC_SEGMENT = 0x1
LC_SYMTAB  = 0x2

MOVS_R0_1_BXLR = bytes([0x01, 0x20, 0x70, 0x47])
MOVS_R0_0_BXLR = bytes([0x00, 0x20, 0x70, 0x47])

# Только функции с подтверждённым PUSH-прологом
PATCH_MAP = {
    # --- Настоящие функции (PUSH-пролог) ---
    '_PE_enter_debugger':                    ('func_ret_1', 'enter debugger'),
    '_cs_valid':                             ('func_ret_1', 'always valid'),
    '_cs_restricted':                        ('func_ret_0', 'not restricted'),
    '_pmap_is_trust_cache_loaded':           ('func_ret_1', 'TC loaded'),
    '_pmap_load_image4_trust_cache':         ('func_ret_1', 'image4 ok'),
    '_pmap_load_legacy_trust_cache':         ('func_ret_1', 'legacy ok'),
    '_pmap_match_compilation_service_cdhash':('func_ret_0', 'no match'),
    '_amfi_interface_register':              ('func_ret_0', 'AMFI off'),
    # --- Функции, скомпилированные в inline return 1/0 ---
    '_cs_process_enforcement':               ('func_ret_0', 'disable CS'),
    '_cs_process_global_enforcement':        ('func_ret_0', 'disable global'),
    '_cs_system_enforcement':                ('func_ret_0', 'disable sys CS'),
    '_cs_require_lv':                        ('func_ret_0', 'no LV'),
    '_cs_system_require_lv':                 ('func_ret_0', 'no sys LV'),
    # --- Переменные в __DATA (только если явно разрешено) ---
    '_cs_debug_fail_on_unsigned_code':       ('var_0', 'dont fail'),
    '_cs_debug_unsigned_exec_failures':      ('var_0', 'dont fail'),
}

# Символы, которые в этой сборке НЕ функции — всегда SKIP
SKIP_SYMBOLS = {
    '_PE_i_can_has_debugger',
    '_PE_i_can_has_kernel_configuration',
}

AUTO_DISCOVER = [
    ('_cs_process_', 0),
    ('_cs_require_', 0),
    ('_cs_system_',  0),
    ('_cs_restrict', 0),
    ('_cs_valid',    1),
    ('_cs_allow',    1),
    ('_pmap_is_trust', 1),
    ('_amfi_',       0),
]


def parse_fat(d):
    if len(d) < 8: return None
    magic, nfat = struct.unpack_from('>II', d, 0)
    if magic != FAT_MAGIC: return None
    out, off = [], 8
    for _ in range(nfat):
        if off + 20 > len(d): break
        ct, cst, fo, fs, al = struct.unpack_from('>IIIII', d, off)
        out.append({'ct': ct, 'off': fo}); off += 20
    return out


def load_macho(d, base_off):
    if base_off + 28 > len(d): return None
    mh = struct.unpack_from('<7I', d, base_off)
    if mh[0] != MH_MAGIC: return None
    segments, symtab = [], None
    off = base_off + 28
    for _ in range(mh[4]):
        if off + 8 > len(d): break
        cmd, cmdsize = struct.unpack_from('<II', d, off)
        if cmd == LC_SEGMENT:
            name = d[off+8:off+24].rstrip(b'\x00').decode('ascii', 'replace')
            vm, vs, fo, fs = struct.unpack_from('<IIII', d, off+24)
            segments.append({'name': name, 'vm': vm, 'vs': vs,
                             'fo': fo, 'fs': fs, 'absfo': base_off + fo})
        elif cmd == LC_SYMTAB:
            so, ns, stro, _ = struct.unpack_from('<IIII', d, off+8)
            symtab = {'symoff': base_off + so, 'nsyms': ns,
                      'stroff': base_off + stro}
        off += cmdsize
    return segments, symtab


def load_symbols(d, symtab):
    out = {}
    if not symtab: return out
    for i in range(symtab['nsyms']):
        so = symtab['symoff'] + i * 12
        if so + 12 > len(d): break
        n_strx, _, _, _, n_value = struct.unpack_from('<IBBHI', d, so)
        sto = symtab['stroff'] + n_strx
        if sto >= len(d): continue
        end = d.find(b'\x00', sto)
        if end < 0: end = len(d)
        nm = d[sto:end].decode('ascii', 'ignore')
        if nm: out[nm] = n_value
    return out


def va2file(va, segments):
    for s in segments:
        if s['vm'] <= va < s['vm'] + s['vs']:
            return s['absfo'] + (va - s['vm'])
    return None


def is_function_start(b):
    """СТРОГАЯ проверка начала ARMv7 Thumb-функции.

    Принимает:
      * PUSH {R7,LR}         = B5 80
      * PUSH {R4,R7,LR}      = B5 90
      * PUSH {R4-R7,LR}      = B5 F0
      * PUSH.W {..,LR}       = E92D xxxx с LR
      * MOVS R0,#imm; BX LR  (короткая return-функция)
      * MOVS Rd,#imm; BX LR  (общий случай)
    Отклоняет MOVW/MOVT (литералы данных).
    """
    if len(b) < 4:
        return False
    hw = b[0] | (b[1] << 8)
    # PUSH-прологи
    if hw in (0xB580, 0xB590, 0xB5F0):
        return True
    if hw == 0xE92D:
        hw2 = b[2] | (b[3] << 8)
        if (hw2 & 0x4000) != 0:
            return True
    # MOVS Rd,#imm; BX LR  (короткие return-функции)
    hw2 = b[2] | (b[3] << 8)
    if (hw & 0xF800) == 0x2000 and hw2 == 0x4770:
        return True
    return False

def func_has_exit(d, foff, max_len=0x200):
    """Проверяет, что в пределах max_len байт есть BX LR или POP {..,PC}."""
    end = min(foff + max_len, len(d) - 4)
    for i in range(foff, end, 2):
        hw = d[i] | (d[i+1] << 8)
        if hw == 0x4770:                    # BX LR (T16)
            return True
        if (hw & 0xFF00) == 0xBD00:         # POP {..,PC} (T16)
            return True
        if hw == 0xE8BD:                    # POP.W {..,PC}
            hw2 = d[i+2] | (d[i+3] << 8)
            if (hw2 & 0x8000) != 0:
                return True
    return False


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("src", help="kernelcache.raw.orig")
    ap.add_argument("dst", help="kernelcache.patched")
    ap.add_argument("--dry-run", action="store_true",
                    help="Не записывать, только показать")
    ap.add_argument("--strict", action="store_true",
                    help="Патчить только функции с подтверждённым PUSH-прологом")
    ap.add_argument("--no-vars", action="store_true",
                    help="Не трогать переменные в __DATA")
    args = ap.parse_args()

    with open(args.src, 'rb') as f:
        data = bytearray(f.read())

    print("=" * 70)
    print("  Extended Kernel Patcher — Apple Watch S3 (ARMv7) [SAFE v2]")
    print("=" * 70)
    print(f"  Файл: {args.src}")
    print(f"  Размер: {len(data)} байт")
    if args.dry_run:
        print("  Режим: DRY-RUN (без записи)")

    fat_off = 0
    fat = parse_fat(data)
    if fat:
        for a in fat:
            if a['ct'] == 12:
                fat_off = a['off']; break
        print(f"  FAT offset: 0x{fat_off:x}")

    result = load_macho(data, fat_off)
    if not result:
        print("  ❌ Не Mach-O"); return 1
    segments, symtab = result
    syms = load_symbols(data, symtab)
    print(f"  Сегментов: {len(segments)}, символов: {len(syms)}")
    print()

    # === 1. Известные патчи ===
    print("=" * 70)
    print("  1. ИЗВЕСТНЫЕ ПАТЧИ")
    print("=" * 70)

    applied = 0
    skipped = []
    variables = []

    for name, (kind, desc) in PATCH_MAP.items():
        if name in SKIP_SYMBOLS:
            skipped.append((name, 'в SKIP_SYMBOLS (не функция)'))
            continue
        va = syms.get(name)
        if va is None:
            continue
        foff = va2file(va, segments)
        if foff is None:
            continue
        cur4 = bytes(data[foff:foff+4])

        if kind in ('func_ret_1', 'func_ret_0'):
            if not is_function_start(cur4):
                print(f"  ⚠️  {name}: НЕ функция ({cur4.hex()}) — SKIP")
                skipped.append((name, f'не функция: {cur4.hex()}'))
                continue
            if not func_has_exit(data, foff, max_len=0x100):
                print(f"  ⚠️  {name}: нет BX LR/POP в 0x100 байт — SKIP")
                skipped.append((name, 'нет exit в 0x100'))
                continue
            target = MOVS_R0_1_BXLR if kind == 'func_ret_1' else MOVS_R0_0_BXLR
            if cur4 == target:
                print(f"  ·  {name}: уже {target.hex()}")
                continue
            if args.dry_run:
                print(f"  [dry] {name:42s} {cur4.hex()} → {target.hex()}")
            else:
                data[foff:foff+4] = target
                print(f"  ✅ {name:42s} {cur4.hex()} → {target.hex()}  [{desc}]")
            applied += 1

        elif kind in ('var_1', 'var_0'):
            if args.no_vars:
                print(f"  ·  {name}: пропущено (--no-vars)")
                continue
            # Переменные обычно в __DATA — проверяем сегмент
            seg_of_var = None
            for s in segments:
                if s['vm'] <= va < s['vm'] + s['vs']:
                    seg_of_var = s['name']; break
            if seg_of_var and '__DATA' not in seg_of_var:
                print(f"  ⚠️  {name}: в {seg_of_var} (не __DATA) — SKIP")
                skipped.append((name, f'не __DATA ({seg_of_var})'))
                continue
            target = b'\x01\x00\x00\x00' if kind == 'var_1' else b'\x00\x00\x00\x00'
            if cur4 == target:
                print(f"  ·  {name}: уже {target.hex()}")
                continue
            if args.dry_run:
                print(f"  [dry] {name:42s} {cur4.hex()} → {target.hex()}")
            else:
                data[foff:foff+4] = target
                print(f"  ✅ {name:42s} {cur4.hex()} → {target.hex()}  [{desc}]")
            variables.append(name)
            applied += 1

    print(f"\n  Применено: {applied}   Пропущено: {len(skipped)}")
    if skipped:
        print("\n  Пропущены:")
        for name, reason in skipped:
            print(f"    {name:42s}  ({reason})")

    # === 2. Auto-discovery ===
    print()
    print("=" * 70)
    print("  2. AUTO-DISCOVERY")
    print("=" * 70)

    already = set(PATCH_MAP.keys()) | SKIP_SYMBOLS
    auto_applied = 0

    for prefix, ret_value in AUTO_DISCOVER:
        matches = [n for n in syms.keys()
                   if n.startswith(prefix) and n not in already]
        if not matches:
            continue

        for name in matches:
            foff = va2file(syms[name], segments)
            if foff is None:
                continue
            cur4 = bytes(data[foff:foff+4])
            if not is_function_start(cur4):
                continue
            if not func_has_exit(data, foff, max_len=0x100):
                continue
            target = MOVS_R0_1_BXLR if ret_value == 1 else MOVS_R0_0_BXLR
            if cur4 == target:
                continue
            if args.dry_run:
                print(f"  [dry] {name:42s} {cur4.hex()} → {target.hex()}")
            else:
                data[foff:foff+4] = target
                print(f"  ✅ {name:42s} {cur4.hex()} → {target.hex()}")
            auto_applied += 1

    print(f"\n  Auto: {auto_applied}")

    if not args.dry_run:
        with open(args.dst, 'wb') as f:
            f.write(bytes(data))
        print()
        print("=" * 70)
        print(f"  ✅ Сохранено: {args.dst}")
        print(f"  Всего патчей: {applied + auto_applied}")
        print("=" * 70)
    else:
        print("\n  [dry-run] Файл не изменён.")
    return 0


if __name__ == '__main__':
    sys.exit(main())