Skip to content

Run a virtual iPhone on an Apple Silicon Mac.

Swift
7.0 KB
Raw Blame
import Foundation

// MARK: - App Detail

/// What the App Info inspector shows for one app, filled in as each guest
/// call returns: `apps.info`, `apps.binary`, `apps.url_schemes` and
/// `apps.network_policy`.
struct VPhoneAppDetail {
    let bundleID: String

    // apps.info
    var name = ""
    var version = ""
    var build = ""
    var type = ""
    var signer = ""
    var minimumOS = ""
    var sdk = ""
    var bundlePath = ""
    var dataPath = ""
    var groupContainers: [VPhoneAppContainer] = []
    var claimedSchemes: [String] = []
    var hasInfo = false
    var infoError: String?

    // apps.binary
    var executable = ""
    var encrypted: Bool?
    var entitlements: [VPhoneAppEntitlement] = []
    var entitlementsPlist = ""
    var signingError: String?
    var hasBinary = false
    var binaryError: String?

    /// apps.url_schemes
    var declaredSchemes: [String] = []

    // apps.network_policy
    var networkPolicy: VPhoneAppNetworkPolicy?
    var networkPolicyError: String?

    init(bundleID: String, record: VPhoneAppRecord? = nil) {
        self.bundleID = bundleID
        guard let record else { return }
        name = record.name
        version = record.version
        build = record.build
        bundlePath = record.bundlePath
        dataPath = record.dataPath
    }

    var displayName: String {
        name.isEmpty ? bundleID : name
    }

    /// Schemes from the bundle's Info.plist first, then any LaunchServices
    /// also records as claimed.
    var urlSchemes: [String] {
        var seen = Set<String>()
        return (declaredSchemes + claimedSchemes).filter { seen.insert($0).inserted }
    }

    mutating func apply(info: [String: Any]) {
        name = info.string("name") ?? name
        version = info.string("version") ?? version
        build = info.string("build") ?? build
        type = info.string("type") ?? ""
        signer = info.string("signer") ?? ""
        minimumOS = info.string("minimum_os") ?? ""
        sdk = info.string("sdk") ?? ""
        bundlePath = info.string("bundle_path") ?? bundlePath
        dataPath = info.string("data_path") ?? ""
        executable = info.string("executable") ?? executable
        groupContainers = (info.object("group_containers") ?? [:])
            .compactMap { key, value in
                (value as? String).map { VPhoneAppContainer(identifier: key, path: $0) }
            }
            .sorted { $0.identifier < $1.identifier }
        claimedSchemes = info["schemes"] as? [String] ?? []
        if !hasBinary {
            applySigning(info)
        }
        hasInfo = true
        infoError = nil
    }

    mutating func apply(binary: [String: Any]) {
        executable = binary.string("executable") ?? executable
        applySigning(binary)
        hasBinary = true
        binaryError = nil
    }

    private mutating func applySigning(_ result: [String: Any]) {
        encrypted = result.bool("encrypted") ?? encrypted
        signingError = result.string("signing_error")
        let dictionary = result.object("entitlements") ?? [:]
        entitlements = VPhoneAppEntitlement.entries(from: dictionary)
        entitlementsPlist = VPhoneAppEntitlement.plistText(dictionary)
    }
}

// MARK: - Group Container

struct VPhoneAppContainer: Identifiable, Hashable {
    let identifier: String
    let path: String

    var id: String {
        identifier
    }
}

// MARK: - Entitlement

/// One top-level entitlement key with its value rendered as readable lines.
struct VPhoneAppEntitlement: Identifiable, Hashable {
    let key: String
    let value: String

    var id: String {
        key
    }

    static func entries(from dictionary: [String: Any]) -> [VPhoneAppEntitlement] {
        dictionary.keys.sorted().map { key in
            VPhoneAppEntitlement(key: key, value: render(dictionary[key] as Any, indent: ""))
        }
    }

    /// The entitlements as an XML property list, the form codesign prints.
    static func plistText(_ dictionary: [String: Any]) -> String {
        guard !dictionary.isEmpty,
              let data = try? PropertyListSerialization.data(fromPropertyList: dictionary, format: .xml, options: 0)
        else { return "" }
        return String(decoding: data, as: UTF8.self)
    }

    private static func isContainer(_ value: Any) -> Bool {
        (value as? [Any]).map { !$0.isEmpty } ?? (value as? [String: Any]).map { !$0.isEmpty } ?? false
    }

    private static func render(_ value: Any, indent: String) -> String {
        switch value {
        case let number as NSNumber where CFGetTypeID(number) == CFBooleanGetTypeID():
            return number.boolValue ? "true" : "false"
        case let number as NSNumber:
            return number.stringValue
        case let string as String:
            return string
        case let array as [Any]:
            guard !array.isEmpty else { return "[]" }
            return array.map { isContainer($0) ? render($0, indent: indent) : indent + render($0, indent: indent) }
                .joined(separator: "\n")
        case let dictionary as [String: Any]:
            guard !dictionary.isEmpty else { return "{}" }
            return dictionary.keys.sorted().map { key in
                let value = dictionary[key] as Any
                return isContainer(value)
                    ? "\(indent)\(key):\n\(render(value, indent: indent + "  "))"
                    : "\(indent)\(key) = \(render(value, indent: indent))"
            }.joined(separator: "\n")
        default:
            return String(describing: value)
        }
    }
}

// MARK: - Network Policy

/// CoreTelephony's per-app data policy: the Wireless Data switch that can
/// leave a sideloaded app without network access.
struct VPhoneAppNetworkPolicy {
    struct Entry: Identifiable, Hashable {
        let title: String
        let value: String

        var id: String {
            title
        }
    }

    let allowed: Bool
    let changed: Bool?
    let entries: [Entry]

    init(json: [String: Any]) {
        allowed = json.bool("allowed") ?? false
        changed = json.bool("changed")
        let policy = json.object("policy") ?? [:]
        entries = policy.keys.sorted().map { key in
            Entry(title: Self.title(forKey: key), value: Self.title(forValue: policy.string(key) ?? ""))
        }
    }

    private static func title(forKey key: String) -> String {
        switch key {
        case "kCTCellularDataUsagePolicy": String(localized: "Cellular", bundle: VPhoneLocalization.bundle)
        case "kCTWiFiDataUsagePolicy": String(localized: "Wi-Fi", bundle: VPhoneLocalization.bundle)
        default: key
        }
    }

    /// `kCTCellularDataUsagePolicyAlwaysAllow` → `Always Allow`.
    private static func title(forValue value: String) -> String {
        let prefix = "kCTCellularDataUsagePolicy"
        guard value.hasPrefix(prefix), value.count > prefix.count else { return value }
        var words = ""
        for character in value.dropFirst(prefix.count) {
            if character.isUppercase, !words.isEmpty {
                words.append(" ")
            }
            words.append(character)
        }
        return words
    }
}