Skip to content

Run a virtual iPhone on an Apple Silicon Mac.

Swift
13.6 KB
Raw Blame
// Cross-image names for stripped collections, from ipsw#1372 symbols.go.
import Foundation
import VPhonePatchKit

struct KDKLinkSymbols {
    var imports: [String: [KDKSymbol]] = [:]
    var exports: [String: [KDKSymbol]] = [:]
    var unresolved: [(String, UInt64)] = []

    static func loadKnown(_ data: Data) throws -> [UInt64: [String]] {
        guard let raw = try JSONSerialization.jsonObject(with: data) as? [String: Any] else { throw PatcherError.invalidFormat("invalid KDK symbol map") }
        var result: [UInt64: [String]] = [:]
        for (key, value) in raw {
            let address: UInt64? = if key.hasPrefix("0x") || key.hasPrefix("0X") {
                UInt64(key.dropFirst(2), radix: 16)
            } else if key.hasPrefix("0o") {
                UInt64(key.dropFirst(2), radix: 8)
            } else if key.hasPrefix("0b") {
                UInt64(key.dropFirst(2), radix: 2)
            } else if key.count > 1, key.first == "0" {
                UInt64(key, radix: 8)
            } else {
                UInt64(key)
            }
            guard let address, let names = (value as? [String]) ?? (value as? String).map({ [$0] }) else {
                throw PatcherError.invalidFormat("invalid symbol map entry: \(key)")
            }
            result[address] = names
        }
        return result
    }
}

extension KDKKernelCollection {
    func plist(at address: UInt64, count: UInt64) throws -> [String: Any] {
        var data = try read(Int(count), at: address)
        while data.last == 0 {
            data.removeLast()
        }
        guard let result = try PropertyListSerialization.propertyList(from: Data(data), format: nil) as? [String: Any] else {
            throw PatcherError.invalidFormat("KDK metadata is not a dictionary plist")
        }
        return result
    }

    func prelinkInfo() throws -> [[String: Any]] {
        guard let segment = segments.first(where: { $0.name == "__PRELINK_INFO" }) else { throw PatcherError.invalidFormat("missing __PRELINK_INFO") }
        return try plist(at: segment.address, count: segment.fileSize)["_PrelinkInfoDictionary"] as? [[String: Any]] ?? []
    }
}

extension KDKRecovery {
    struct SymbolRange {
        var entry: String
        var index: UInt8
        var section: KDKMachO.Section
    }

    func synthesizeSymbols(references: [String: [KDKReference]], known: [UInt64: [String]] = [:]) throws -> KDKLinkSymbols {
        let kernelID = "com.apple.kernel"
        guard let kernel = images[kernelID], kernel.symbols.isEmpty else {
            throw PatcherError.invalidFormat("native KDK symbol synthesis requires a stripped kernel")
        }
        let infos = try collection.prelinkInfo()
        var ranges: [SymbolRange] = []
        for id in images.keys.sorted() {
            for (index, section) in images[id]!.sections.enumerated() where section.size > 0 {
                guard let ordinal = UInt8(exactly: index + 1) else { throw PatcherError.invalidFormat("too many Mach-O sections") }
                ranges.append(.init(entry: id, index: ordinal, section: section))
            }
        }
        ranges.sort { $0.section.address < $1.section.address }
        let starts = ranges.map(\.section.address)
        func lookup(_ address: UInt64) -> SymbolRange? {
            let i = starts.upperBound(address) - 1
            return i >= 0 && ranges[i].section.contains(address) ? ranges[i] : nil
        }
        var needs: [(String, UInt64)] = []
        for (id, refs) in references {
            var seen = Set<UInt64>()
            for ref in refs where ref.kind == 2 || ref.kind == 7 {
                guard let owner = lookup(ref.target), owner.entry != id, seen.insert(ref.target).inserted else { continue }
                needs.append((id, ref.target))
            }
        }
        needs.sort { ($0.0, $0.1) < ($1.0, $1.1) }
        let functionStarts = functions.mapValues { $0.map(\.start).sorted() }
        func positionName(_ owner: SymbolRange, _ target: UInt64) -> String {
            func trim(_ name: String) -> String {
                String(name.drop(while: { $0 == "_" }))
            }
            let section = trim(owner.section.segmentName) + "." + trim(owner.section.name)
            if owner.section.flags & 0x8000_0400 != 0 {
                let functions = functionStarts[owner.entry] ?? [], i = functions.upperBound(target) - 1
                if i >= 0, functions[i] >= owner.section.address {
                    return section + ".f\(i)" + (functions[i] == target ? "" : "_" + String(target - functions[i], radix: 16))
                }
            }
            return section + ".d" + String(target - owner.section.address, radix: 16)
        }
        var sets: [[String: Any]] = [], fallback = ""
        if let section = kernel.sections.first(where: { $0.segmentName == "__LINKINFO" && $0.name == "__symbolsets" }) {
            let plist = try collection.plist(at: section.address, count: section.size)
            sets = plist["SymbolsSets"] as? [[String: Any]] ?? []
            fallback = (plist["WeakRefFallbackSymbol"] as? [String: Any])?["SymbolName"] as? String ?? ""
        }
        var setNames: [String: [String]] = [:], privatePrefixes: [String] = [], reserved = Set<String>()
        for set in sets {
            let id = set["CFBundleIdentifier"] as? String ?? ""
            for symbol in set["Symbols"] as? [[String: Any]] ?? [] {
                let name = symbol["SymbolName"] as? String ?? "", prefix = symbol["SymbolPrefix"] as? String ?? "", alias = symbol["AliasTarget"] as? String ?? ""
                if !prefix.isEmpty {
                    if id == "com.apple.kpi.private" {
                        privatePrefixes.append(prefix)
                    }
                } else if !alias.isEmpty {
                    reserved.insert(name)
                    reserved.insert(alias)
                } else if !name.isEmpty {
                    setNames[id, default: []].append(name)
                }
            }
        }
        if !fallback.isEmpty {
            reserved.insert(fallback)
        }
        var dependencies: [String: [String]] = [:]
        for info in infos {
            if let id = info["CFBundleIdentifier"] as? String, let libs = info["OSBundleLibraries"] as? [String: Any] {
                dependencies[id] = libs.keys.sorted()
            }
        }
        var deps: [String: [String]] = [:]
        for (id, direct) in dependencies {
            var seen: Set<String> = [id], queue = direct, index = 0, closure: [String] = []
            while index < queue.count {
                let dep = queue[index]
                index += 1
                if !seen.insert(dep).inserted {
                    continue
                }
                closure.append(dep)
                queue += dependencies[dep] ?? []
            }
            deps[id] = closure.sorted()
        }
        var result = KDKLinkSymbols(), defined: [String: UInt64] = [:], namesAt: [UInt64: [String]] = [:]
        func define(_ owner: SymbolRange, _ name: String, _ target: UInt64) {
            if defined[name] != nil {
                return
            }
            defined[name] = target
            namesAt[target, default: []].append(name)
            result.exports[owner.entry, default: []].append(.init(name: name, type: 0xF, sect: owner.index, desc: 0, value: target))
        }
        var knownOwners: [String: Set<String>] = [:]
        let knownAddresses = known.keys.filter { lookup($0) != nil }.sorted()
        for address in knownAddresses {
            let owner = lookup(address)!
            for name in known[address]! {
                knownOwners[name, default: []].insert(owner.entry)
            }
        }
        let textStart = kernel.sections.first { $0.segmentName == "__TEXT_EXEC" && $0.name == "__text" }?.address ?? 0
        for address in knownAddresses {
            let owner = lookup(address)!
            for name in known[address]! where !name.isEmpty && name != "_kmod_info" {
                if reserved.contains(name), address == textStart {
                    continue
                }
                if owner.entry != kernelID, knownOwners[name, default: []].count > 1 {
                    result.exports[owner.entry, default: []].append(.init(name: name, type: 0xE, sect: owner.index, desc: 0, value: address))
                } else {
                    define(owner, name, address)
                }
            }
        }
        func knownImport(_ importer: String, _ owner: SymbolRange, _ target: UInt64) -> String? {
            for name in known[target] ?? [] where defined[name] == target {
                if owner.entry != kernelID {
                    return name
                }
                for dep in deps[importer] ?? [] {
                    if setNames[dep, default: []].contains(name) {
                        return name
                    }
                    if dep == "com.apple.kpi.private", privatePrefixes.contains(where: { name.hasPrefix($0) }) {
                        return name
                    }
                }
            }
            return nil
        }
        func unique(_ name: String, _ target: UInt64) -> String {
            var candidate = name, suffix = 1
            while let address = defined[candidate], address != target {
                candidate = "\(name).\(suffix)"
                suffix += 1
            }
            return candidate
        }
        func vtable(_ name: String) -> Bool {
            name.hasPrefix("__ZTV") || name.contains("10gMetaClassE") || name.contains("10superClassE") || name.contains("9MetaClassE")
        }
        var nextName: [String: Int] = [:]
        for (importer, target) in needs {
            let owner = lookup(target)!
            var name = knownImport(importer, owner, target)
            if name == nil, owner.entry != kernelID {
                name = unique("_kc.\(owner.entry)." + positionName(owner, target), target)
            } else if name == nil {
                if deps[importer, default: []].contains("com.apple.kpi.private"), let prefix = privatePrefixes.first {
                    name = unique(prefix + "_kc." + positionName(owner, target), target)
                } else {
                    for candidate in namesAt[target] ?? [] {
                        for dep in deps[importer] ?? [] where setNames[dep, default: []].contains(candidate) {
                            name = candidate
                        }
                    }
                    for dep in deps[importer] ?? [] {
                        let names = setNames[dep] ?? []
                        while name == nil, nextName[dep, default: 0] < names.count {
                            let candidate = names[nextName[dep, default: 0]]
                            nextName[dep, default: 0] += 1
                            if defined[candidate] == nil, !reserved.contains(candidate), !vtable(candidate) {
                                name = candidate
                            }
                        }
                    }
                }
            }
            guard let name else { result.unresolved.append((importer, target))
                continue
            }
            if let other = defined[name], other != target {
                throw PatcherError.invalidFormat("ambiguous synthesized import \(name)")
            }
            define(owner, name, target)
            result.imports[importer, default: []].append(.init(name: name, type: 1, sect: 0, desc: 0, value: target))
        }
        if let text = kernel.sections.first(where: { $0.segmentName == "__TEXT_EXEC" && $0.name == "__text" }), let textOwner = lookup(text.address) {
            for name in reserved.sorted() {
                var isAliasTarget = false, aliasAddress: UInt64 = 0
                for set in sets {
                    for symbol in set["Symbols"] as? [[String: Any]] ?? [] where symbol["AliasTarget"] as? String == name {
                        isAliasTarget = true
                        if let alias = symbol["SymbolName"] as? String, let address = defined[alias], aliasAddress == 0, lookup(address)?.entry == kernelID {
                            aliasAddress = address
                        }
                    }
                }
                if let address = defined[name], lookup(address)?.entry == kernelID {
                    continue
                }
                if aliasAddress != 0, let owner = lookup(aliasAddress) {
                    if defined[name] != nil {
                        result.exports[kernelID, default: []].append(.init(name: name, type: 0xF, sect: owner.index, desc: 0, value: aliasAddress))
                    } else {
                        define(owner, name, aliasAddress)
                    }
                } else if isAliasTarget || name == fallback {
                    if defined[name] != nil {
                        result.exports[kernelID, default: []].append(.init(name: name, type: 0xF, sect: textOwner.index, desc: 0, value: text.address))
                    } else {
                        define(textOwner, name, text.address)
                    }
                }
            }
        }
        for info in infos {
            guard let id = info["CFBundleIdentifier"] as? String, images[id] != nil,
                  let number = info["_PrelinkKmodInfo"] as? NSNumber else { continue }
            let address = number.uint64Value
            if let owner = lookup(address), owner.entry == id {
                result.exports[id, default: []].append(.init(name: "_kmod_info", type: 0xF, sect: owner.index, desc: 0, value: address))
            }
        }
        for id in result.exports.keys {
            result.exports[id]!.sort { $0.name < $1.name }
        }
        for id in result.imports.keys {
            result.imports[id]!.sort { $0.name < $1.name }
        }
        return result
    }
}