Skip to content

Run a virtual iPhone on an Apple Silicon Mac.

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

struct KDKRecoveryTests {
    @Test func `symbol map formats`() throws {
        let data = Data(#"{"0xfffffe0000000000":"_one","18446741874686296065":["_two","_alias"]}"#.utf8)
        let map = try KDKLinkSymbols.loadKnown(data)
        #expect(map[0xFFFF_FE00_0000_0000] == ["_one"])
        #expect(map[0xFFFF_FE00_0000_0001] == ["_two", "_alias"])
        #expect(throws: PatcherError.self) { try KDKLinkSymbols.loadKnown(Data(#"{"no-address":"_bad"}"#.utf8)) }
        #expect(throws: PatcherError.self) { try KDKLinkSymbols.loadKnown(Data(#"{"0x1234":42}"#.utf8)) }
    }

    @Test func `bounded ULEB`() throws {
        var cursor = KDKCursor([0xE5, 0x8E, 0x26])
        #expect(try cursor.uleb() == 624_485)
        var malformed = KDKCursor([0x80])
        #expect(throws: PatcherError.self) { try malformed.uleb() }
        var overflow = KDKCursor(Array(repeating: UInt8(0xFF), count: 10))
        #expect(throws: PatcherError.self) { try overflow.uleb() }
    }

    @Test(.enabled(if: ProcessInfo.processInfo.environment["KDK_PARITY_ROOT"] != nil))
    func `recovered inputs and exports match reference`() throws {
        let root = try URL(fileURLWithPath: #require(ProcessInfo.processInfo.environment["KDK_PARITY_ROOT"]))
        struct Symbol: Decodable {
            var name: String
            var indirectName: String?
            var type: UInt8
            var sect: UInt8
            var desc: UInt16
            var value: UInt64
            var model: KDKSymbol {
                .init(name: name, indirectName: indirectName ?? "", type: type, sect: sect, desc: desc, value: value)
            }
        }
        struct Input: Decodable {
            var entryID: String
            var output: String
            var baseAddress: UInt64
            var symbols: [Symbol]
            var references: [KDKReference]
        }
        let fm = FileManager.default
        var verified = 0
        for (label, kernel) in [("donor", "vphone600"), ("research", "vresearch101")] {
            print("KDK native recovery starting: \(label)")
            let collection = try KDKKernelCollection(Data(contentsOf: root.appending(path: "data/264beta/kernelcache.release.\(kernel).decompressed"), options: .mappedIfSafe))
            let recovery = try KDKRecovery(collection)
            let references = try recovery.recover()
            let corpus = root.appending(path: "parity/\(label)")
            let files = try fm.contentsOfDirectory(at: corpus.appending(path: "inputs"), includingPropertiesForKeys: nil)
                .filter { $0.pathExtension == "json" }.sorted { $0.lastPathComponent < $1.lastPathComponent }
            let inputs = try files.map { try JSONDecoder().decode(Input.self, from: Data(contentsOf: $0)) }
            var differences = 0
            for input in inputs {
                let expected = Set(input.references), actual = Set(references[input.entryID] ?? [])
                if actual != expected {
                    let missing = expected.subtracting(actual).sorted { ($0.source, $0.kind, $0.extra) < ($1.source, $1.kind, $1.extra) }
                    let extra = actual.subtracting(expected).sorted { ($0.source, $0.kind, $0.extra) < ($1.source, $1.kind, $1.extra) }
                    print("KDK recovery difference \(label)/\(input.entryID): missing \(missing.count), extra \(extra.count)")
                    for r in missing.prefix(5) {
                        print("  missing kind=\(r.kind) source=\(String(r.source, radix: 16)) target=\(String(r.target, radix: 16)) extra=\(String(r.extra, radix: 16))")
                    }
                    for r in extra.prefix(5) {
                        print("  extra kind=\(r.kind) source=\(String(r.source, radix: 16)) target=\(String(r.target, radix: 16)) extra=\(String(r.extra, radix: 16))")
                    }
                    let payload = ["missing": missing, "extra": extra]
                    try JSONEncoder().encode(payload).write(to: root.appending(path: "recovery-\(label)-\(input.entryID).json"))
                    differences += 1
                }
            }
            guard differences == 0 else { Issue.record("\(label): reference differences in \(differences) images")
                return
            }
            let knownURL = corpus.appending(path: "symbols.json")
            let known = fm.fileExists(atPath: knownURL.path) ? try KDKLinkSymbols.loadKnown(Data(contentsOf: knownURL)) : [:]
            let symbols = try recovery.synthesizeSymbols(references: references, known: known)
            for input in inputs {
                let generated = (symbols.exports[input.entryID] ?? []) + (symbols.imports[input.entryID] ?? [])
                let expected = input.symbols.map(\.model)
                guard generated == expected else {
                    let difference = zip(generated, expected).enumerated().first { $0.element.0 != $0.element.1 }?.offset ?? min(generated.count, expected.count)
                    print("KDK symbol difference \(label)/\(input.entryID) at \(difference), native \(generated.count), reference \(expected.count)")
                    if difference < generated.count {
                        print("native: \(generated[difference])")
                    }
                    if difference < expected.count {
                        print("reference: \(expected[difference])")
                    }
                    Issue.record("symbol synthesis differs: \(input.entryID)")
                    return
                }
                var image = try #require(recovery.images[input.entryID])
                if input.entryID == "com.apple.kernel", let thread = collection.unixThread,
                   let i = image.commands.firstIndex(where: { $0.command == KDKMachO.lcUnixThread })
                {
                    image.commands[i] = thread
                }
                var writer = try KDKImageExport(collection: collection, image: image, baseAddress: input.baseAddress,
                                                symbols: generated, references: references[input.entryID] ?? [], addressOnlyBinds: true)
                let output = try writer.export(), golden = try Data(contentsOf: corpus.appending(path: "out").appending(path: input.output))
                guard output == golden else {
                    try output.write(to: root.appending(path: "native-\(label)-\(input.entryID)"))
                    Issue.record("native export differs: \(label)/\(input.entryID)")
                    return
                }
                verified += 1
            }
            print("KDK native recovery verified: \(label), \(inputs.count) images; unresolved \(symbols.unresolved.count)")
        }
        #expect(verified == 264)
        print("KDK native recovery: all 264 reference sets, symbol arrays and output binaries match")
    }
}