Skip to content

Run a virtual iPhone on an Apple Silicon Mac.

Swift
11.3 KB
Raw Blame
// ARM64E_X1 admission; reveal procedure is in Research/0_binary_patch_comparison.md.

import Foundation
import VPhonePatchKit

extension KernelCustomFirmwarePatcher {
    @discardableResult
    func patchArm64eX1Admission() -> Bool {
        let identifier = "kernel-boot-arm64e_x1"
        guard gate.isEnabled(identifier) else { return false }
        guard let (start, end) = kernTextRange else { return false }

        var grades: [(entry: Int, compare: Int)] = []
        let raw = buffer.original
        for block in stride(from: start, to: end, by: 0x4000) {
            let scanStart = max(start, block - 16)
            let stop = min(end, block + 0x4000 + 0x100)
            let instructions = disasm.disassemble(raw.subdata(in: scanStart ..< stop), at: UInt64(scanStart))
            for (index, instruction) in instructions.enumerated() where instruction.address >= UInt64(block) && instruction.address < UInt64(block + 0x4000) {
                guard x1RegImmediate(instruction, mnemonic: "cmp", register: .w(1), immediate: 2),
                      index >= 3, index + 7 < instructions.count
                else { continue }
                let tail = Array(instructions[(index - 3) ... (index + 7)])
                guard x1GradeTail(tail) else { continue }

                // ml_grade_binary has no PAC prologue; anchor its entry on the per-CPU load and BL xref.
                let compare = Int(instruction.address)
                let prefix = disasm.disassemble(in: raw, at: max(start, compare - 0x100), count: min(0x100, compare - start) / 4)
                let entries = prefix.filter { candidate in
                    guard candidate.mnemonic == "mrs", blIndex[Int(candidate.address)] != nil else { return false }
                    let head = disasm.disassemble(in: raw, at: Int(candidate.address), count: 3)
                    guard head.count == 3,
                          let register = head[0].detail?.operands.first?.reg,
                          let first = head[1].detail?.operands, first.count == 2,
                          first[0].type == .register, first[0].reg == register,
                          first[1].type == .memory, first[1].mem.base == register,
                          let second = head[2].detail?.operands, second.count == 2,
                          second[1].type == .memory, second[1].mem.base == register,
                          second[1].mem.disp == 8
                    else { return false }
                    return head[1].mnemonic == "ldr" && head[2].mnemonic == "ldr"
                }
                if entries.count == 1 { grades.append((Int(entries[0].address), compare)) }
            }
        }
        guard grades.count == 1 else {
            log("  [-] ARM64E_X1: ml_grade_binary not unique (\(grades.count))")
            return false
        }
        let grade = grades[0]
        var execSites: [(offset: Int, register: UInt32)] = []
        for caller in blIndex[grade.entry] ?? [] {
            let instructions = disasm.disassemble(in: raw, at: caller + 4, count: 32)
            for index in instructions.indices where index >= 2 && index + 6 < instructions.count {
                if let register = x1ExecPACGate(Array(instructions[(index - 2) ... (index + 6)])) {
                    execSites.append((Int(instructions[index].address), register))
                }
            }
        }
        guard execSites.count == 1 else {
            log("  [-] ARM64E_X1: exec IMGPF_NOJOP gate not unique (\(execSites.count))")
            return false
        }

        // The successful shared-region path retains subtype 2 for the existing auth pagers.
        guard let shared = x1ExecSharedRegionGate(after: execSites[0].offset) else {
            log("  [-] ARM64E_X1: exec shared-region PAC gate not unique")
            return false
        }
        let sites: [(offset: Int, register: UInt32, name: String)] = [
            (grade.compare, 1, "grade"),
            (execSites[0].offset, execSites[0].register, "exec_ptrauth"),
            (shared.offset, shared.register, "exec_shared_region"),
        ]
        guard let cave = findCodeCave(size: sites.count * 12) else {
            log("  [-] ARM64E_X1: no executable cave")
            return false
        }
        var writes: [(offset: Int, data: Data, name: String)] = []
        for (index, site) in sites.enumerated() {
            let trampoline = cave + index * 12
            guard let entry = ARM64Encoder.encodeB(from: site.offset, to: trampoline),
                  let cmp = ARM64Encoder.encodeCmpWImmediate(rn: site.register, imm12: 12),
                  let ccmp = ARM64Encoder.encodeCcmpWImmediate(rn: site.register, imm5: 2, nzcv: 6, condition: .ne),
                  let resume = ARM64Encoder.encodeB(from: trampoline + 8, to: site.offset + 4)
            else { return false }
            // NZCV=0110 makes subtype 12 equivalent to CMP Wn,#2 with Wn=2.
            writes.append((trampoline, cmp + ccmp + resume, site.name + ".cave"))
            writes.append((site.offset, entry, site.name))
        }
        for write in writes {
            emit(write.offset, write.data, patchID: identifier + "." + write.name,
                 virtualAddress: fileOffsetToVA(write.offset),
                 description: "ARM64E_X1 subtype 12 or legacy subtype 2 [\(write.name)]")
        }
        return true
    }

    private func x1RegImmediate(_ instruction: ARM64Instruction, mnemonic: String, register: ARM64Register, immediate: Int64) -> Bool {
        guard instruction.mnemonic == mnemonic, let ops = instruction.detail?.operands, ops.count == 2 else { return false }
        return ops[0].type == .register && ops[0].reg == register && ops[1].type == .immediate && ops[1].imm == immediate
    }

    private func x1ExecSharedRegionGate(after execCompare: Int) -> (offset: Int, register: UInt32)? {
        let instructions = disasm.disassemble(in: buffer.original, at: execCompare + 4,
                                              count: min(0x800, buffer.original.count - execCompare - 4) / 4)
        var hits: [(Int, UInt32)] = []
        for index in instructions.indices where index >= 2 && index + 3 < instructions.count {
            let i = Array(instructions[(index - 2) ... (index + 3)])
            guard i[0].mnemonic == "ldr", let load = i[0].detail?.operands, load.count == 2,
                  load[0].type == .register, load[1].type == .memory,
                  i[1].mnemonic == "and", let mask = i[1].detail?.operands, mask.count == 3,
                  mask[0].reg == load[0].reg, mask[1].reg == load[0].reg,
                  mask[2].type == .immediate, mask[2].imm == 0x0FFF_FFFF,
                  x1RegImmediate(i[2], mnemonic: "cmp", register: load[0].reg, immediate: 2),
                  let reject = x1BranchTarget(i[3], mnemonic: "b.ne"),
                  i[4].mnemonic == "ldr", let flags = i[4].detail?.operands, flags.count == 2,
                  flags[1].type == .memory, flags[1].mem.disp == 0x48,
                  x1BranchTarget(i[5], mnemonic: "tbnz") == reject,
                  let bit = i[5].detail?.operands, bit.count == 3,
                  bit[0].reg == flags[0].reg, bit[1].type == .immediate, bit[1].imm == 31
            else { continue }
            let failure = disasm.disassemble(in: buffer.original, at: reject, count: 1)
            let success = disasm.disassemble(in: buffer.original, at: reject - 12, count: 1)
            guard failure.count == 1, success.count == 1,
                  let subtypeRegister = failure[0].detail?.operands.first?.reg,
                  x1RegImmediate(failure[0], mnemonic: "mov", register: subtypeRegister, immediate: 0),
                  x1RegImmediate(success[0], mnemonic: "mov", register: subtypeRegister, immediate: 2),
                  let register = (0 ... 30).first(where: { ARM64Register.w($0) == load[0].reg })
            else { continue }
            hits.append((Int(i[2].address), UInt32(register)))
        }
        return hits.count == 1 ? hits[0] : nil
    }

    private func x1BranchTarget(_ instruction: ARM64Instruction, mnemonic: String) -> Int? {
        guard instruction.mnemonic == mnemonic, let op = instruction.detail?.operands.last, op.type == .immediate else { return nil }
        return Int(exactly: op.imm)
    }

    private func x1ReturnsGrade(at offset: Int, grade: Int64) -> Bool {
        let instructions = disasm.disassemble(in: buffer.original, at: offset, count: 2)
        return instructions.count == 2 && x1RegImmediate(instructions[0], mnemonic: "mov", register: .w(0), immediate: grade)
            && instructions[1].mnemonic == "ret"
    }

    private func x1GradeTail(_ i: [ARM64Instruction]) -> Bool {
        guard let all = x1BranchTarget(i[0], mnemonic: "cbz"), i[0].detail?.operands.first?.reg == .w(1),
              x1ReturnsGrade(at: all, grade: 9),
              x1RegImmediate(i[1], mnemonic: "cmp", register: .w(1), immediate: 1),
              let v8 = x1BranchTarget(i[2], mnemonic: "b.eq"), x1ReturnsGrade(at: v8, grade: 10),
              let reject = x1BranchTarget(i[4], mnemonic: "b.ne"), x1ReturnsGrade(at: reject, grade: 0),
              x1RegImmediate(i[5], mnemonic: "tst", register: .w(2), immediate: 0x0F00_0000),
              i[6].mnemonic == "mov", let mov = i[6].detail?.operands, mov.count == 2,
              mov[0].type == .register, mov[1].type == .immediate, mov[1].imm == 11,
              i[7].mnemonic == "cinc", let cinc = i[7].detail?.operands, cinc.count == 2,
              cinc[0].reg == mov[0].reg, cinc[1].reg == mov[0].reg,
              i[8].mnemonic == "and", let result = i[8].detail?.operands, result.count == 3,
              result[0].reg == .w(0), result[1].reg == mov[0].reg, result[2].reg == .w(2),
              i[9].mnemonic == "ret"
        else { return false }
        return true
    }

    private func x1ExecPACGate(_ i: [ARM64Instruction]) -> UInt32? {
        guard i[0].mnemonic == "ldr", let load = i[0].detail?.operands, load.count == 2,
              load[0].type == .register, load[1].type == .memory, load[1].mem.disp == 8,
              i[1].mnemonic == "and", let mask = i[1].detail?.operands, mask.count == 3,
              mask[0].reg == load[0].reg, mask[1].reg == load[0].reg,
              mask[2].type == .immediate, mask[2].imm == 0x0FFF_FFFF,
              x1RegImmediate(i[2], mnemonic: "cmp", register: load[0].reg, immediate: 2),
              let disabled = x1BranchTarget(i[3], mnemonic: "b.ne"),
              i[4].mnemonic == "and", let clear = i[4].detail?.operands, clear.count == 3,
              clear[2].type == .immediate, clear[2].imm == 0x7FFF_FFFF,
              let common = x1BranchTarget(i[5], mnemonic: "b"),
              x1RegImmediate(i[6], mnemonic: "mov", register: .w(0), immediate: 86)
        else { return nil }
        let set = disasm.disassemble(in: buffer.original, at: disabled, count: 1)
        let store = disasm.disassemble(in: buffer.original, at: common, count: 1)
        guard set.count == 1, set[0].mnemonic == "orr", let ops = set[0].detail?.operands, ops.count == 3,
              ops[0].reg == clear[0].reg, ops[1].reg == clear[1].reg,
              ops[2].type == .immediate, UInt32(truncatingIfNeeded: ops[2].imm) == 0x8000_0000,
              store.count == 1, store[0].mnemonic == "str", let str = store[0].detail?.operands, str.count == 2,
              str[0].reg == clear[0].reg, str[1].type == .memory, str[1].mem.disp == 0x48
        else { return nil }
        return (0 ... 30).first(where: { ARM64Register.w($0) == load[0].reg }).map(UInt32.init)
    }
}