Skip to content

Run a virtual iPhone on an Apple Silicon Mac.

Swift
10.0 KB
Raw Blame
@testable import FirmwarePatcher
import Foundation
import Testing
import VPhonePatchKit

@Suite("Paravirtual GPU Task3")
struct KernelParavirtTask3Tests {
    // The raw vphone600 research kernel is operator supplied, never redistributed.
    static var fixture: String? { ProcessInfo.processInfo.environment["VPHONE_TASK3_KERNEL"] }

    private func prepared(_ data: Data) -> KernelCustomFirmwarePatcher {
        let patcher = KernelCustomFirmwarePatcher(data: data)
        patcher.parseMachO()
        patcher.buildADRPIndex()
        return patcher
    }

    @Test(.enabled(if: fixture != nil))
    func `discovers the complete patch in the supplied kernel`() throws {
        let data = try Data(contentsOf: URL(fileURLWithPath: #require(Self.fixture)))
        let patcher = prepared(data)
        #expect(patcher.patchParavirtTask3Version())
        #expect(patcher.patches.count == 5)
        let ids = Set(patcher.patches.map(\.patchID))
        let prefix = FirmwarePatchSetCatalog.paravirtTask3Patch
        #expect(ids == Set(["request", "features", "features_code", "identity_hook", "identity_code"].map { prefix + "." + $0 }))

        let code = try #require(patcher.patches.first { $0.patchID == prefix + ".identity_code" })
        let hook = try #require(patcher.patches.first { $0.patchID == prefix + ".identity_hook" })
        for availability in [(true, true), (false, true), (true, false)] {
            try executeTrampoline(code, hook: hook, procAvailable: availability.0, hashAvailable: availability.1)
        }

        // Hosts grant 252 (macOS 27), their own maximum (245 on 26.4, 233 on
        // 26.0, 209 on 15.6.1) or a refusal. Only a version above the kext's
        // own becomes the kext's own.
        let features = try #require(patcher.patches.first { $0.patchID == prefix + ".features" })
        let clamp = try #require(patcher.patches.first { $0.patchID == prefix + ".features_code" })
        for (granted, expected): (UInt64, UInt64) in [(252, 245), (246, 245), (245, 245), (233, 233), (209, 209), (0x8000_00F5, 0x8000_00F5)] {
            #expect(try executeFeatureClamp(clamp, branch: features, granted: granted) == expected)
        }

        let second = prepared(patcher.patchedData)
        #expect(!second.patchParavirtTask3Version())
        #expect(second.patches.isEmpty)
    }

    /// Run the feature-version clamp from the branch that replaced the
    /// `mov x0, xV` and return `x0` where it rejoins the kext, one past that site.
    private func executeFeatureClamp(_ code: PatchRecord, branch: PatchRecord, granted: UInt64) throws -> UInt64 {
        let decoder = ARM64Disassembler()
        let jump = try #require(decoder.disassemble(branch.patchedBytes, at: UInt64(branch.fileOffset)).first)
        let displaced = try #require(decoder.disassemble(branch.originalBytes, at: UInt64(branch.fileOffset)).first)
        let grantedRegister = try #require(displaced.detail?.operands.last?.reg)
        #expect(jump.mnemonic == "b" && jump.detail?.operands.first?.imm == Int64(code.fileOffset))
        let instructions = decoder.disassemble(code.patchedBytes, at: UInt64(code.fileOffset))
        // tbnz names the W register for bits below 32; keep one X slot per register.
        func wide(_ r: ARM64Register) -> ARM64Register {
            (0 ... 30).first { ARM64Register.w($0) == r }.map { .x($0) } ?? r
        }
        var registers: [ARM64Register: UInt64] = [wide(grantedRegister): granted, .x(0): 0x1234]
        var pc = code.fileOffset
        for _ in 0 ..< 10 {
            if pc == branch.fileOffset + 4 { break }
            let i = try #require(instructions.first { $0.address == UInt64(pc) })
            let p = try #require(i.detail?.operands)
            var next = pc + 4
            switch i.mnemonic {
            case "sub": registers[wide(p[0].reg)] = registers[wide(p[1].reg), default: 0] &- UInt64(p[2].imm)
            case "tbnz": if registers[wide(p[0].reg), default: 0] >> UInt64(p[1].imm) & 1 == 1 { next = Int(p[2].imm) }
            case "mov" where p[1].type == .immediate: registers[wide(p[0].reg)] = UInt64(p[1].imm)
            case "mov": registers[wide(p[0].reg)] = registers[wide(p[1].reg), default: 0]
            case "b": next = Int(p[0].imm)
            default: Issue.record("Unexpected clamp instruction: \(i)")
            }
            pc = next
        }
        #expect(pc == branch.fileOffset + 4)
        #expect(registers[wide(grantedRegister)] == granted)
        return registers[.x(0), default: 0]
    }

    /// Execute the emitted instructions with hostile caller-saved register
    /// clobbers at the two helper calls. This catches stack/LR/root-pointer
    /// mistakes and over-copying that a disassembly snapshot would miss.
    private func executeTrampoline(_ code: PatchRecord, hook: PatchRecord, procAvailable: Bool, hashAvailable: Bool) throws {
        let decoder = ARM64Disassembler()
        let instructions = decoder.disassemble(code.patchedBytes, at: UInt64(code.fileOffset))
        let original = try #require(decoder.disassemble(hook.originalBytes, at: UInt64(hook.fileOffset)).first)
        let displaced = try #require(original.detail?.operands)
        let selfReg = displaced[1].mem.base
        let rootReg = try #require(instructions.first?.detail?.operands.last?.mem.base)
        let taskLoad = try #require(instructions.first {
            $0.mnemonic == "ldr" && $0.detail?.operands.last?.mem.base == selfReg
        })
        let ownerOffset = try #require(taskLoad.detail?.operands.last?.mem.disp)
        var registers = Dictionary(uniqueKeysWithValues: (0 ... 30).map { (ARM64Register.x($0), UInt64(0x100 + $0)) })
        registers[selfReg] = 0x300000
        registers[rootReg] = 0x200000
        let saved = registers
        var sp: UInt64 = 0x100000
        var memory: [UInt64: UInt8] = [:]
        func readRegister(_ r: ARM64Register) -> UInt64 {
            if r == .sp { return sp }
            if let n = (0 ... 30).first(where: { ARM64Register.w($0) == r }) {
                return registers[.x(n), default: 0] & 0xffff_ffff
            }
            return registers[r, default: 0]
        }
        func writeRegister(_ r: ARM64Register, _ value: UInt64) {
            if r == .sp { sp = value }
            else if let n = (0 ... 30).first(where: { ARM64Register.w($0) == r }) { registers[.x(n)] = value & 0xffff_ffff }
            else if r != .xzr && r != .wzr { registers[r] = value }
        }
        func store(_ address: UInt64, _ value: UInt64, _ count: Int) {
            for byte in 0 ..< count { memory[address + UInt64(byte)] = UInt8(truncatingIfNeeded: value >> (byte * 8)) }
        }
        func load(_ address: UInt64, _ count: Int) -> UInt64 {
            (0 ..< count).reduce(0) { $0 | UInt64(memory[address + UInt64($1), default: 0]) << ($1 * 8) }
        }
        func address(_ operand: ARM64Operand) -> UInt64 { readRegister(operand.mem.base) &+ UInt64(bitPattern: Int64(operand.mem.disp)) }
        store(0x300000 + UInt64(ownerOffset), 0x400000, 8)
        store(0x300000 + UInt64(displaced[1].mem.disp), 0xdeadbeef, 8)
        for byte in 0 ..< 80 { memory[0x200000 + UInt64(byte)] = 0xcc }
        let hash = (0 ..< 20).map { UInt8($0 + 1) }
        for byte in 0 ..< 20 { memory[0x600000 + UInt64(byte)] = hash[byte] }
        var pc = code.fileOffset
        var calls = 0
        for _ in 0 ..< 150 {
            if pc == hook.fileOffset + 4 { break }
            let i = try #require(instructions.first { $0.address == UInt64(pc) })
            let p = try #require(i.detail?.operands)
            var next = pc + 4
            switch i.mnemonic {
            case "sub", "add":
                let left = readRegister(p[1].reg), right = UInt64(p[2].imm)
                writeRegister(p[0].reg, i.mnemonic == "add" ? left &+ right : left &- right)
            case "stp":
                store(address(p[2]), readRegister(p[0].reg), 8)
                store(address(p[2]) + 8, readRegister(p[1].reg), 8)
            case "ldr", "str":
                let width = (0 ... 30).contains { ARM64Register.w($0) == p[0].reg } || p[0].reg == .wzr ? 4 : 8
                if i.mnemonic == "ldr" { writeRegister(p[0].reg, load(address(p[1]), width)) }
                else { store(address(p[1]), readRegister(p[0].reg), width) }
            case "bl":
                #expect(readRegister(.x(0)) == (calls == 0 ? 0x400000 : 0x500000))
                for reg in 0 ... 17 { registers[.x(reg)] = UInt64(0x700000 + reg) }
                registers[.x(30)] = UInt64(pc + 4)
                registers[.x(0)] = calls == 0 ? (procAvailable ? 0x500000 : 0) : (hashAvailable ? 0x600000 : 0)
                calls += 1
            case "cbz":
                if readRegister(p[0].reg) == 0 { next = Int(p[1].imm) }
            case "b": next = Int(p[0].imm)
            default: Issue.record("Unexpected trampoline instruction: \(i)")
            }
            pc = next
        }
        #expect(pc == hook.fileOffset + 4)
        #expect(sp == 0x100000)
        #expect(calls == (procAvailable ? 2 : 1))
        for reg in 1 ... 30 { #expect(registers[.x(reg)] == saved[.x(reg)]) }
        #expect(registers[.x(0)] == 0xdeadbeef)
        let key = (0 ..< 20).map { memory[0x200028 + UInt64($0), default: 0] }
        #expect(key == (procAvailable && hashAvailable ? hash : Array(repeating: 0, count: 20)))
        #expect((0 ..< 40).allSatisfy { memory[0x200000 + UInt64($0)] == 0xcc })
        #expect((60 ..< 80).allSatisfy { memory[0x200000 + UInt64($0)] == 0xcc })
    }

    @Test(.enabled(if: fixture != nil), arguments: [
        "%s: Failed to create Page Table Lock\n",
        "(%u): failed to get the cdhash\n",
    ])
    func `missing identity anchor leaves every Task3 site unchanged`(text: String) throws {
        var data = try Data(contentsOf: URL(fileURLWithPath: #require(Self.fixture)))
        let anchor = Data(text.utf8)
        let range = try #require(data.range(of: anchor))
        data[range.lowerBound] = 0
        let patcher = prepared(data)
        #expect(!patcher.patchParavirtTask3Version())
        #expect(patcher.patches.isEmpty)
        #expect(patcher.patchedData == data)
    }
}