Cross-platform Xcode replacement. Build and deploy iOS apps with SwiftPM on Linux, Windows, macOS.
Create Supercharge Installer, overhaul executable parser
kabiroberaic4c52142bc0e
diff --git a/Supercharge Installer/ConnectionManager.swift b/Supercharge Installer/ConnectionManager.swiftnew file mode 100644index 0000000..d23225c--- /dev/null+++ b/Supercharge Installer/ConnectionManager.swift@@ -0,0 +1,94 @@+//+// ConnectionManager.swift+// Supercharge Installer+//+// Created by Kabir Oberai on 19/06/20.+// Copyright © 2020 Kabir Oberai. All rights reserved.+//++import Foundation+import SwiftyMobileDevice++protocol ConnectionManagerDelegate: class {+ func connectionManager(_ manager: ConnectionManager, clientsDidChangeFrom oldValue: [ConnectionManager.Client])+}++class ConnectionManager {++ fileprivate struct ConnectionKey: Hashable, Equatable {+ let udid: String+ /* let connectionType: USBMux.ConnectionType */+ }++ fileprivate struct ConnectionValue {+ let lockdownClient: LockdownClient+ let deviceName: String+ }++ struct Client {+ let udid: String+ let deviceName: String++ fileprivate init(key: ConnectionKey, value: ConnectionValue) {+ self.udid = key.udid+ self.deviceName = value.deviceName+ }++ func isEquivalent(to other: Client) -> Bool {+ udid == other.udid+ }+ }++ private var clientsDict: [ConnectionKey: ConnectionValue] = [:] {+ didSet {+ clientsDidChange()+ }+ }++ private(set) var clients: [Client] = [] {+ didSet {+ delegate?.connectionManager(self, clientsDidChangeFrom: oldValue)+ }+ }++ private var token: USBMux.SubscriptionToken?++ weak var delegate: ConnectionManagerDelegate?++ private func clientsDidChange() {+ clients = clientsDict.sorted { $0.0.udid < $1.0.udid }.map(Client.init)+ }++ init() throws {+ self.token = try USBMux.subscribe { [weak self] event in+ guard let self = self else { return }+ self.handleEvent(event)+ }+ }++ private func handleEvent(_ event: USBMux.Event) {+ // only handle USB. WiFi won't work because we can't re-pair over wifi afaik+ guard event.device.connectionType == .usb else { return }+ let udid = event.device.udid+ let key = ConnectionKey(udid: udid)+ switch event.kind {+ case .removed:+ clientsDict[key] = nil+ case .paired:+ return+ case .added:+ guard let device = try? Device(udid: udid),+ let client = try? LockdownClient(+ device: device,+ label: LockdownClient.installerLabel,+ performHandshake: false+ ),+ let deviceName = try? client.deviceName()+ else { return }+ clientsDict[key] = ConnectionValue(lockdownClient: client, deviceName: deviceName)+ }+ }++ deinit { try? token.map(USBMux.unsubscribe(withToken:)) }++}diff --git a/Supercharge Installer/Installer.swift b/Supercharge Installer/Installer.swiftnew file mode 100644index 0000000..3fcc04e--- /dev/null+++ b/Supercharge Installer/Installer.swift@@ -0,0 +1,404 @@+//+// Installer.swift+// Supercharge Installer+//+// Created by Kabir Oberai on 19/06/20.+// Copyright © 2020 Kabir Oberai. All rights reserved.+//++import Foundation+import Supersign+import SwiftyMobileDevice++extension LockdownClient {+ static let installerLabel = "supersign-installer"+}++protocol InstallerDelegate: class {+ func fetchCode(completion: @escaping (String?) -> Void)+ func fetchTeam(fromTeams teams: [DeveloperServicesTeam], completion: @escaping (DeveloperServicesTeam?) -> Void)+ func presentMessage(_ message: Installer.Message)+ func dismissMessage()+ func installerDidUpdate(toStage stage: String, progress: Double?)+ func installerDidComplete(withResult result: Result<(), Error>)++ /// Decompress the zipped ipa file+ ///+ /// - Parameter ipa: The `ipa` file to decompress.+ /// - Parameter directory: The directory into which `ipa` should be decompressed.+ /// - Parameter progress: A closure to which the callee can provide progress updates.+ /// - Parameter currentProgress: The current progress, or `nil` to indicate it is indeterminate.+ /// - Parameter completion: A completion handler to call once decompression is finished.+ /// - Parameter success: Whether or not extraction was successful.+ func decompress(+ ipa: URL,+ in directory: URL,+ progress: @escaping (_ currentProgress: Double?) -> Void,+ completion: @escaping (_ success: Bool) -> Void+ )++ /// An opportunity for delegates to compress the app before installation.+ ///+ /// - Parameter payloadDir: The `Payload` directory which is to be compressed.+ /// - Parameter progress: A closure to which the callee can provide progress updates.+ /// - Parameter currentProgress: The current progress, or `nil` to indicate it is indeterminate.+ /// - Parameter completion: A completion handler to call with the compressed file's URL.+ /// - Parameter url: The URL of the compressed file. The caller is responsible for cleaning this+ /// up once installation is complete. Pass `nil` to skip compression.+ ///+ /// - Note: The default implementation of this function simply calls `completion` with a+ /// `nil` value for `url`.+ func compressIfNeeded(+ payloadDir: URL,+ progress: @escaping (_ currentProgress: Double?) -> Void,+ completion: @escaping (_ url: URL?) -> Void+ )+}++extension InstallerDelegate {+ func compressIfNeeded(+ payloadDir: URL,+ progress: @escaping (Double?) -> Void,+ completion: @escaping (URL?) -> Void+ ) {+ completion(nil)+ }+}++final class Installer {++ enum Error: Swift.Error {+ case alreadyInstalling+ case deviceInfoFetchFailed+ case noTeamFound+ case userCancelled+ case appExtractionFailed+ case appCorrupted+ case appPackagingFailed+ }++ enum Message {+ case pairDevice+ case unlockDevice+ }++ let udid: String+ let appleID: String+ let password: String+ weak var delegate: InstallerDelegate?++ private var appInstaller: AppInstaller?++ private let tempDir = FileManager.default.temporaryDirectoryShim+ .appendingPathComponent("com.kabiroberai.Supercharge-Installer.Staging")+ private let installQueue =+ DispatchQueue(label: "com.kabiroberai.Supercharge-Installer.install-queue", qos: .userInitiated, attributes: [])++ private enum ExecutionState {+ case running+ case complete+ }++ private var executionStateLock = NSLock()+ private var executionState: ExecutionState = .running++ private func shouldContinue() -> Bool {+ executionStateLock.lock()+ defer { executionStateLock.unlock() }+ switch executionState {+ case .running:+ return true+ case .complete:+ return false+ }+ }++ private func completion(_ result: Result<(), Swift.Error>) {+ executionStateLock.lock()+ defer { executionStateLock.unlock() }+ guard executionState != .complete else { return }+ try? FileManager.default.removeItem(at: tempDir)+ executionState = .complete+ delegate?.installerDidComplete(withResult: result)+ delegate = nil+ }++ func cancel() {+ completion(.failure(Error.userCancelled))+ }++ private var stage: String?+ private func updateStage(to stage: String, ignoreCancellation: Bool = false) -> Bool {+ guard ignoreCancellation || shouldContinue() else { return false }+ self.stage = stage+ delegate?.installerDidUpdate(toStage: stage, progress: 0)+ return true+ }+ private func updateProgress(to progress: Double?, ignoreCancellation: Bool = false) -> Bool {+ guard ignoreCancellation || shouldContinue() else { return false }+ guard let stage = stage else {+ preconditionFailure("Cannot change progress without setting stage at least once")+ }+ delegate?.installerDidUpdate(toStage: stage, progress: progress)+ return true+ }++ init(+ udid: String,+ appleID: String,+ password: String,+ delegate: InstallerDelegate+ ) {+ self.udid = udid+ self.appleID = appleID+ self.password = password+ self.delegate = delegate+ }++ private func performWithRecovery<T>(hasPrompted: Bool = false, block: () throws -> T) throws -> T {+ guard shouldContinue() else { throw Error.userCancelled }++ func recurse(_ message: Installer.Message) throws -> T {+ if !hasPrompted { delegate?.presentMessage(message) }+ // allow some time before recursing (even if TCO, we should probably not overdo it)+ Thread.sleep(forTimeInterval: 0.5)+ return try performWithRecovery(hasPrompted: true, block: block)+ }++ do {+ let result = try block()+ if hasPrompted { delegate?.dismissMessage() }+ return result+ } catch let error as LockdownClient.Error where error == .pairingDialogResponsePending {+ return try recurse(.pairDevice)+ } catch let error as LockdownClient.Error where error == .passwordProtected {+ return try recurse(.unlockDevice)+ } catch {+ if hasPrompted { delegate?.dismissMessage() }+ throw error+ }+ }++ private func fetchPairingKeys() throws -> Data? {+ let device = try Device(udid: udid)++ guard updateProgress(to: 1/3) else { return nil }++ // we can't reuse any previously created client because we need to perform a handshake this time+ let lockdownClient = try performWithRecovery {+ try LockdownClient(device: device, label: LockdownClient.installerLabel, performHandshake: true)+ }++ try lockdownClient.setValue(udid, forDomain: "com.apple.mobile.wireless_lockdown", key: "WirelessBuddyID")+ try lockdownClient.setValue(true, forDomain: "com.apple.mobile.wireless_lockdown", key: "EnableWifiConnections")++ guard updateProgress(to: 2/3) else { return nil }++ // now create a new pair record, temporarily removing the existing one. This is necessary+ // because if two machines try accessing lockdown with the same device wirelessly, it'll+ // fail during the heartbeat+ let oldRecord = try USBMux.pairRecord(forUDID: udid)+ try USBMux.deletePairRecord(forUDID: udid)+ defer { try? USBMux.savePairRecord(oldRecord, forUDID: udid) }++ try performWithRecovery { try lockdownClient.pair() }+ return try USBMux.pairRecord(forUDID: udid)+ }++ private func install(+ deviceInfo: DeviceInfo,+ token: DeveloperServicesLoginToken,+ client: DeveloperServicesClient,+ team: DeveloperServicesTeam,+ possiblyCompressedApp: URL+ ) {+ guard shouldContinue() else { return }+ executionStateLock.lock()+ defer { executionStateLock.unlock() }+ let appInstaller = AppInstaller(app: possiblyCompressedApp, udid: udid, pairingKeys: ())+ self.appInstaller = appInstaller+ appInstaller.install(+ progress: { stage in+ _ = self.updateStage(to: stage.displayName, ignoreCancellation: true)+ _ = self.updateProgress(to: stage.displayProgress, ignoreCancellation: true)+ },+ completion: completion+ )+ }++ private func packageAndInstall(+ deviceInfo: DeviceInfo,+ token: DeveloperServicesLoginToken,+ client: DeveloperServicesClient,+ team: DeveloperServicesTeam,+ appDir: URL+ ) {+ guard self.updateStage(to: "Packaging app"),+ self.updateProgress(to: nil)+ else { return }++ delegate?.compressIfNeeded(+ payloadDir: appDir.deletingLastPathComponent(),+ progress: { progress in+ _ = self.updateProgress(to: progress, ignoreCancellation: true)+ },+ completion: { url in+ self.installQueue.async {+ self.install(+ deviceInfo: deviceInfo,+ token: token,+ client: client,+ team: team,+ possiblyCompressedApp: url ?? appDir+ )+ }+ }+ )+ }++ private func install(+ deviceInfo: DeviceInfo,+ token: DeveloperServicesLoginToken,+ client: DeveloperServicesClient,+ team: DeveloperServicesTeam,+ appDir: URL+ ) {+ guard self.updateStage(to: "Preparing device") else { return }++ do {+ guard let pairingKeys = try fetchPairingKeys()+ else { return } // nil: user cancelled+ try Superconfig(+ udid: udid,+ pairingKeys: pairingKeys,+ deviceInfo: deviceInfo,+ preferredTeamID: team.id.rawValue,+ appleID: appleID,+ token: token+ ).save(inAppDir: appDir)+ } catch {+ return completion(.failure(error))+ }++ let context: SigningContext+ do {+ context = try SigningContext(+ udid: udid,+ teamID: team.id,+ client: client,+ signingInfoManager: MemoryBackedSigningInfoManager(),+ platform: .iOS+ )+ } catch {+ return completion(.failure(error))+ }+ let signer = Signer(context: context)+ signer.sign(+ app: appDir,+ status: { status in+ _ = self.updateStage(to: status, ignoreCancellation: true)+ },+ progress: { progress in+ _ = self.updateProgress(to: progress, ignoreCancellation: true)+ }, completion: { result in+ guard result.get(withErrorHandler: self.completion) != nil else { return }+ self.packageAndInstall(+ deviceInfo: deviceInfo,+ token: token,+ client: client,+ team: team,+ appDir: appDir+ )+ }+ )+ }++ private func install(deviceInfo: DeviceInfo, token: DeveloperServicesLoginToken, appDir: URL) {+ let client = DeveloperServicesClient(loginToken: token, deviceInfo: deviceInfo)+ client.send(DeveloperServicesListTeamsRequest()) { result in+ guard let teams = result.get(withErrorHandler: self.completion) else { return }+ guard self.updateProgress(to: 1) else { return }+ switch teams.count {+ case 0:+ return self.completion(.failure(Error.noTeamFound))+ case 1:+ self.install(deviceInfo: deviceInfo, token: token, client: client, team: teams[0], appDir: appDir)+ default:+ self.delegate?.fetchTeam(fromTeams: teams) { team in+ self.installQueue.async {+ guard let team = team else { return self.completion(.failure(Error.userCancelled)) }+ self.install(deviceInfo: deviceInfo, token: token, client: client, team: team, appDir: appDir)+ }+ }+ }+ }+ }++ private func install(decompressionDidSucceed: Bool) {+ let payload = self.tempDir.appendingPathComponent("Payload")+ guard decompressionDidSucceed,+ let appDir = payload.implicitContents.first(where: { $0.pathExtension == "app" })+ else { return self.completion(.failure(Error.appExtractionFailed)) }++ guard let deviceInfo = DeviceInfo.current() else {+ return completion(.failure(Error.deviceInfoFetchFailed))+ }++ guard updateStage(to: "Logging in") else { return }+ DeveloperServicesLoginManager(deviceInfo: deviceInfo).logIn(+ withUsername: self.appleID,+ password: self.password,+ twoFactorDelegate: self+ ) { result in+ guard let token = result.get(withErrorHandler: self.completion) else { return }+ guard self.updateProgress(to: 1/2) else { return }+ self.install(deviceInfo: deviceInfo, token: token, appDir: appDir)+ }+ }++ private func installOnQueue() {+ guard self.updateStage(to: "Unpacking app") else { return }++ let ipa = Bundle.main.url(forResource: "Supercharge", withExtension: "ipa")!+ if FileManager.default.fileExists(atPath: tempDir.path) {+ try? FileManager.default.removeItem(at: tempDir)+ }++ do {+ try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)+ } catch {+ return completion(.failure(error))+ }++ delegate?.decompress(+ ipa: ipa,+ in: tempDir,+ progress: { progress in+ _ = self.updateProgress(to: progress, ignoreCancellation: true)+ },+ completion: { success in+ guard self.shouldContinue() else { return self.completion(.failure(Error.userCancelled)) }+ self.installQueue.async {+ self.install(decompressionDidSucceed: success)+ }+ }+ )+ }++ func install() {+ installQueue.async {+ self.installOnQueue()+ }+ }++}++extension Installer: TwoFactorAuthDelegate {+ func fetchCode(completion: @escaping (String?) -> Void) {+ delegate?.fetchCode { code in+ self.installQueue.async {+ completion(code)+ }+ }+ }+}diff --git a/Supersign/DeveloperServices/App IDs/DeveloperServicesAddAppOperation.swift b/Supersign/DeveloperServices/App IDs/DeveloperServicesAddAppOperation.swiftindex 6ebbf47..be4015f 100644--- a/Supersign/DeveloperServices/App IDs/DeveloperServicesAddAppOperation.swift+++ b/Supersign/DeveloperServices/App IDs/DeveloperServicesAddAppOperation.swift@@ -125,6 +125,12 @@ public struct DeveloperServicesAddAppOperation: DeveloperServicesOperation {do {try entitlements.update(teamID: self.context.teamID, bundleID: appID.bundleID)+ // set get-task-allow to YES, required for dev certs+ try entitlements.updateEntitlements { ents in+ ents.firstIndex { $0 is GetTaskAllowEntitlement }.map { idx in+ ents[idx] = GetTaskAllowEntitlement(rawValue: true)+ }+ }} catch {return completion(.failure(error))}diff --git a/Supersign/DeveloperServices/DeveloperServicesLoginManager.swift b/Supersign/DeveloperServices/DeveloperServicesLoginManager.swiftindex c12818a..f3e6d6f 100644--- a/Supersign/DeveloperServices/DeveloperServicesLoginManager.swift+++ b/Supersign/DeveloperServices/DeveloperServicesLoginManager.swift@@ -35,7 +35,7 @@ public struct DeveloperServicesLoginManager {customAnisetteProvider: AnisetteDataProvider? = nil) {self.deviceInfo = deviceInfo- self.anisetteProvider = customAnisetteProvider ?? ComputedAnisetteDataProvider(deviceInfo: deviceInfo)+ self.anisetteProvider = customAnisetteProvider ?? SupersetteDataProvider(deviceInfo: deviceInfo)self.client = GrandSlamClient(deviceInfo: deviceInfo, customAnisetteDataProvider: anisetteProvider)}diff --git a/Supersign/GrandSlam/Fingerprint/AnisetteData.swift b/Supersign/GrandSlam/Anisette/AnisetteData.swiftsimilarity index 100%rename from Supersign/GrandSlam/Fingerprint/AnisetteData.swiftrename to Supersign/GrandSlam/Anisette/AnisetteData.swiftdiff --git a/Supersign/GrandSlam/Anisette/AnisetteDataProvider.swift b/Supersign/GrandSlam/Anisette/AnisetteDataProvider.swiftnew file mode 100644index 0000000..ae708da--- /dev/null+++ b/Supersign/GrandSlam/Anisette/AnisetteDataProvider.swift@@ -0,0 +1,13 @@+//+// AnisetteDataProvider.swift+// Supersign+//+// Created by Kabir Oberai on 19/11/19.+// Copyright © 2019 Kabir Oberai. All rights reserved.+//++import Foundation++public protocol AnisetteDataProvider {+ func fetchAnisetteData(completion: @escaping (Result<AnisetteData, Error>) -> Void)+}diff --git a/Supersign/GrandSlam/Anisette/DeviceInfo+Fetching.swift b/Supersign/GrandSlam/Anisette/DeviceInfo+Fetching.swiftnew file mode 100644index 0000000..036e3df--- /dev/null+++ b/Supersign/GrandSlam/Anisette/DeviceInfo+Fetching.swift@@ -0,0 +1,84 @@+//+// DeviceInfo+Fetching.swift+// Supersign+//+// Created by Kabir Oberai on 18/06/20.+// Copyright © 2020 Kabir Oberai. All rights reserved.+//++import Foundation++#if os(macOS)+extension DeviceInfo {++ private static func fetchDeviceID() -> String? {+ var waitTime = timespec(tv_sec: 0, tv_nsec: 0) // wait indefinitely+ let bytes = [UInt8](unsafeUninitializedCapacity: MemoryLayout<uuid_t>.size) { buf, count in+ count = (gethostuuid(buf.baseAddress!, &waitTime) == 0) ? buf.count : 0+ }+ guard !bytes.isEmpty else { return nil }+ return bytes.withUnsafeBufferPointer { buf in+ UUID(uuid: UnsafeRawPointer(buf.baseAddress!).load(as: uuid_t.self)).uuidString+ }+ }++ private static func hardwareProperty(forKey key: String) -> Data? {+ let entry = IORegistryEntryFromPath(kIOMasterPortDefault, "IODeviceTree:/options")+ guard entry != 0 else { return nil }+ defer { IOObjectRelease(entry) }++ return IORegistryEntryCreateCFProperty(+ entry, key as CFString, kCFAllocatorDefault, 0+ )?.takeRetainedValue() as? Data+ }++ private static func fetchROMAddress() -> String? {+ hardwareProperty(forKey: "4D1EDE05-38C7-4a6a-9CC6-4BCCA8B38C14:ROM")?+ .map { String(format: "%02hhx", $0) }+ .joined()+ }++ private static func fetchMLBSerialNumber() -> String? {+ hardwareProperty(forKey: "4D1EDE05-38C7-4a6a-9CC6-4BCCA8B38C14:MLB")?+ .map { String(format: isprint(Int32($0)) != 0 ? "%c" : "%02hhx", $0) }+ .joined()+ }++ private static func fetchSerialNumber() -> String? {+ let service = IOServiceGetMatchingService(kIOMasterPortDefault, IOServiceMatching("IOPlatformExpertDevice"))+ guard service != 0 else { return nil }+ defer { IOObjectRelease(service) }+ return IORegistryEntryCreateCFProperty(+ service, "IOPlatformSerialNumber" as CFString, kCFAllocatorDefault, 0+ )?.takeRetainedValue() as? String+ }++ private static func fetchHardwareModel() -> String? {+ var modelSize = 0+ guard sysctlbyname("hw.model", nil, &modelSize, nil, 0) == 0 else { return nil }+ guard let rawString = malloc(modelSize) else { return nil }+ guard sysctlbyname("hw.model", rawString, &modelSize, nil, 0) == 0 else {+ free(rawString)+ return nil+ }+ return String(bytesNoCopy: rawString, length: modelSize - 1, encoding: .utf8, freeWhenDone: true)+ }++ public static func current() -> DeviceInfo? {+ guard let deviceID = fetchDeviceID(),+ let romAddress = fetchROMAddress(),+ let mlbSerialNumber = fetchMLBSerialNumber(),+ let serialNumber = fetchSerialNumber(),+ let modelID = fetchHardwareModel()+ else { return nil }+ return DeviceInfo(+ deviceID: deviceID,+ romAddress: romAddress,+ mlbSerialNumber: mlbSerialNumber,+ serialNumber: serialNumber,+ modelID: modelID+ )+ }++}+#endifdiff --git a/Supersign/GrandSlam/Anisette/DeviceInfo.swift b/Supersign/GrandSlam/Anisette/DeviceInfo.swiftnew file mode 100644index 0000000..d63b7ae--- /dev/null+++ b/Supersign/GrandSlam/Anisette/DeviceInfo.swift@@ -0,0 +1,92 @@+//+// DeviceInfo.swift+// Supersign+//+// Created by Kabir Oberai on 19/11/19.+// Copyright © 2019 Kabir Oberai. All rights reserved.+//++import Foundation++public struct DeviceInfo: Codable {++ /// `X-Xcode-Version`+ static let xcodeVersionKey = "X-Xcode-Version"+ /// Not included in `dictionary`+ public static let xcodeVersion = "11.2 (11B41)"++ public struct ClientInfo: Codable {+ public static let macOSVersion = "10.14.6"+ public static let macOSBuild = "18G103"++ public static let authKitVersion = "1"+ public static let akdVersion = "1.0"+ public static let cfNetworkVersion = "978.0.7"+ public static let darwinVersion = "18.7.0"++ public let modelID: String // e.g. MacBookPro11,5++ // TODO: Do we need to replace com.apple.akd with com.apple.dt.Xcode? See AltStore+ var clientString: String {+ """+ <\(modelID)> <Mac OS X;\(Self.macOSVersion);\(Self.macOSBuild)> \+ <com.apple.AuthKit/\(Self.authKitVersion) (com.apple.akd/\(Self.akdVersion))>+ """+ }++ var userAgent: String {+ "akd/\(Self.akdVersion) CFNetwork/\(Self.cfNetworkVersion) Darwin/\(Self.darwinVersion)"+ }++ public init(modelID: String) {+ self.modelID = modelID+ }+ }++ /// `X-Mme-Device-Id`+ static let deviceIDKey = "X-Mme-Device-Id"+ public let deviceID: String++ /// `X-Apple-I-ROM`+ static let romAddressKey = "X-Apple-I-ROM"+ public let romAddress: String++ /// `X-Apple-I-MLB`+ static let mlbSerialNumberKey = "X-Apple-I-MLB"+ /// main logic board serial number+ public let mlbSerialNumber: String++ /// `X-Apple-I-SRL-NO`+ static let serialNumberKey = "X-Apple-I-SRL-NO"+ public let serialNumber: String++ public let modelID: String++ /// `X-MMe-Client-Info`+ static let clientInfoKey = "X-MMe-Client-Info"+ public var clientInfo: ClientInfo { .init(modelID: modelID) }++ public init(+ deviceID: String,+ romAddress: String,+ mlbSerialNumber: String,+ serialNumber: String,+ modelID: String+ ) {+ self.deviceID = deviceID+ self.romAddress = romAddress+ self.mlbSerialNumber = mlbSerialNumber+ self.serialNumber = serialNumber+ self.modelID = modelID+ }++ var dictionary: [String: String] {+ [+ Self.deviceIDKey: deviceID,+ Self.romAddressKey: romAddress,+ Self.mlbSerialNumberKey: mlbSerialNumber,+ Self.serialNumberKey: serialNumber+ ]+ }++}diff --git a/Supersign/GrandSlam/Anisette/LocalAnisetteDataProviders.swift b/Supersign/GrandSlam/Anisette/LocalAnisetteDataProviders.swiftnew file mode 100644index 0000000..cabae3c--- /dev/null+++ b/Supersign/GrandSlam/Anisette/LocalAnisetteDataProviders.swift@@ -0,0 +1,250 @@+//+// LocalAnisetteDataProviders.swift+// Supersign+//+// Created by Kabir Oberai on 29/06/20.+// Copyright © 2020 Kabir Oberai. All rights reserved.+//++import Foundation++/// Creates a socket connected to `ip` on `port`.+///+/// - Returns: A connected socket file descriptor, or `nil` if+/// the connection failed. The caller is responsible for closing+/// the returned file descriptor.+private func connect(toIP ip: String, port: UInt16) -> Int32? {+ var addr = sockaddr_in()+ addr.sin_family = .init(AF_INET)+ addr.sin_port = CFSwapInt16HostToBig(port)+ addr.sin_addr.s_addr = inet_addr(ip)++ // we can't do this inside withUnsafePointer due to memory exclusivity rules+ let addrSize = MemoryLayout.size(ofValue: addr)++ let socketFd = socket(AF_INET, SOCK_STREAM, 0)+ guard socketFd != -1 else { return nil }+ guard withUnsafePointer(to: &addr, {+ connect(+ socketFd,+ UnsafeRawPointer($0).assumingMemoryBound(to: sockaddr.self),+ .init(addrSize)+ )+ }) == 0 else { return nil }++ return socketFd+}++public class NetcatAnisetteDataProvider: AnisetteDataProvider {++ private struct RawAnisetteData {+ let machineID: String+ let localUserID: String+ let routingInfo: String+ let oneTimePassword: String+ }++ private class ConnectionInfo {+ let socketFd: Int32+ let machineID: String+ let localUserID: String+ let routingInfo: String+ let firstOTP: String++ init(socketFd: Int32, machineID: String, localUserID: String, routingInfo: String, firstOTP: String) {+ self.socketFd = socketFd+ self.machineID = machineID+ self.localUserID = localUserID+ self.routingInfo = routingInfo+ self.firstOTP = firstOTP+ }++ deinit { close(socketFd) }+ }++ public enum Error: Swift.Error {+ /// The user is probably not running anisettehelperd on the host machine+ case helperUnreachable+ case invalidAnisetteData+ case networkError(errno: Int32)+ }++ public let ip: String+ public let port: UInt16+ public let deviceInfo: DeviceInfo+ private var _connectionInfo: ConnectionInfo?+ private var hasUsedFirstOTP = false++ public init(ip: String, port: UInt16, deviceInfo: DeviceInfo) {+ self.ip = ip+ self.port = port+ self.deviceInfo = deviceInfo+ }++ public convenience init(localPort port: UInt16, deviceInfo: DeviceInfo) {+ self.init(ip: "0.0.0.0", port: port, deviceInfo: deviceInfo)+ }++ private func readAll(fromSocket sock: Int32) throws -> Data {+ let capacity = 1024+ let buf = UnsafeMutablePointer<UInt8>.allocate(capacity: capacity)+ defer { buf.deallocate() }+ var data = Data()+ while true {+ let count = recv(sock, buf, capacity, 0)+ guard count != -1 else {+ throw Error.networkError(errno: errno)+ }+ data.append(buf, count: count)+ if count < capacity {+ break+ }+ }+ return data+ }++ private func connectionInfo() throws -> ConnectionInfo {+ if let connectionInfo = _connectionInfo { return connectionInfo }++ guard let socketFd = connect(toIP: ip, port: port) else { throw Error.helperUnreachable }++ let id = deviceInfo.deviceID+ write(socketFd, id, strlen(id) + 1) // include null+ let clientInfo = deviceInfo.clientInfo.clientString+ write(socketFd, clientInfo, strlen(clientInfo) + 1)++ let initialData = try readAll(fromSocket: socketFd)+ guard let string = String(data: initialData, encoding: .utf8)+ else { throw Error.invalidAnisetteData }++ let components = string.split(separator: "\r\n")+ guard components.count == 4 else { throw Error.invalidAnisetteData }++ let connectionInfo = ConnectionInfo(+ socketFd: socketFd,+ machineID: String(components[0]),+ localUserID: String(components[1]),+ routingInfo: String(components[2]),+ firstOTP: String(components[3])+ )+ _connectionInfo = connectionInfo+ return connectionInfo+ }++ private func rawAnisetteData() throws -> RawAnisetteData {+ let info = try connectionInfo()+ if !hasUsedFirstOTP {+ return RawAnisetteData(+ machineID: info.machineID,+ localUserID: info.localUserID,+ routingInfo: info.routingInfo,+ oneTimePassword: info.firstOTP+ )+ }++ write(info.socketFd, "a\n", 3)+ let response = try readAll(fromSocket: info.socketFd)+ guard let otp = String(data: response, encoding: .utf8)+ else { throw Error.invalidAnisetteData }+ return RawAnisetteData(+ machineID: info.machineID,+ localUserID: info.localUserID,+ routingInfo: info.routingInfo,+ oneTimePassword: otp+ )+ }++ public func fetchAnisetteData(completion: @escaping (Result<AnisetteData, Swift.Error>) -> Void) {+ let time = Date()++ let raw: RawAnisetteData+ let routingInfo: UInt64+ do {+ raw = try rawAnisetteData()+ guard let rinfo = UInt64(raw.routingInfo)+ else { throw Error.invalidAnisetteData }+ routingInfo = rinfo+ } catch {+ return completion(.failure(error))+ }++ let anisette = AnisetteData(+ clientTime: time,+ routingInfo: routingInfo,+ machineID: raw.machineID,+ localUserID: raw.localUserID,+ oneTimePassword: raw.oneTimePassword+ )++ completion(.success(anisette))+ }++}++/// Provides Anisette Data by making a request to a TCP server+public class TCPAnisetteDataProvider: AnisetteDataProvider {++ public enum Error: Swift.Error {+ /// The user is probably not running anisettehelperd on the host machine+ case helperUnreachable+ case invalidAnisetteData+ }++ public let ip: String+ public let port: UInt16++ public init(ip: String, port: UInt16) {+ self.ip = ip+ self.port = port+ }++ public convenience init(localPort port: UInt16) {+ self.init(ip: "0.0.0.0", port: port)+ }++ private func rawAnisetteData() throws -> Data {+ guard let socketFd = connect(toIP: ip, port: port) else { throw Error.helperUnreachable }++ let capacity = 1024+ let buf = UnsafeMutablePointer<UInt8>.allocate(capacity: capacity)+ defer { buf.deallocate() }+ var data = Data()+ while true {+ let count = recv(socketFd, buf, capacity, 0)+ // swiftlint:disable:next empty_count+ guard count != 0 else { break }+ data.append(buf, count: count)+ }++ return data+ }++ public func fetchAnisetteData(completion: @escaping (Result<AnisetteData, Swift.Error>) -> Void) {+ let time = Date()++ let rawDeserialized: Any+ do {+ let raw = try rawAnisetteData()+ rawDeserialized = try PropertyListSerialization.propertyList(from: raw, format: nil)+ } catch {+ return completion(.failure(error))+ }++ guard let data = rawDeserialized as? [String: Any],+ let rinfoString = data[AnisetteData.routingInfoKey] as? String,+ let rinfo = UInt64(rinfoString),+ let machineID = data[AnisetteData.machineIDKey] as? String,+ let localUserID = data[AnisetteData.localUserIDKey] as? String,+ let oneTimePassword = data[AnisetteData.oneTimePasswordKey] as? String+ else { return completion(.failure(Error.invalidAnisetteData)) }++ completion(.success(AnisetteData(+ clientTime: time,+ routingInfo: rinfo,+ machineID: machineID,+ localUserID: localUserID,+ oneTimePassword: oneTimePassword+ )))+ }++}diff --git a/Supersign/GrandSlam/Anisette/Supersette/SupersetteDataProvider.swift b/Supersign/GrandSlam/Anisette/Supersette/SupersetteDataProvider.swiftnew file mode 100644index 0000000..f63d18d--- /dev/null+++ b/Supersign/GrandSlam/Anisette/Supersette/SupersetteDataProvider.swift@@ -0,0 +1,72 @@+//+// SupersetteDataProvider.swift+// Supersign+//+// Created by Kabir Oberai on 14/06/20.+// Copyright © 2020 Kabir Oberai. All rights reserved.+//++import Foundation++public class SupersetteDataProvider: AnisetteDataProvider {++ private static let gateway = URL(string: "https://anisette.supercharge.app:8443/v1/generate")!++ private static let encoder = JSONEncoder()+ private static let decoder = JSONDecoder()++ public enum Error: Swift.Error {+ case networkError+ case invalidAnisetteData+ }++ public let deviceInfo: DeviceInfo++ public init(deviceInfo: DeviceInfo) {+ self.deviceInfo = deviceInfo+ }++ private struct AnisetteRequestBody: Encodable {+ let deviceID: String+ let clientInfo: String+ }++ private struct AnisetteResponse: Decodable {+ let routingInfo: UInt64+ let machineID: String+ let localUserID: String+ let oneTimePassword: String+ }++ public func fetchAnisetteData(completion: @escaping (Result<AnisetteData, Swift.Error>) -> Void) {+ let clientTime = Date()+ var request = URLRequest(url: Self.gateway)+ request.httpMethod = "POST"+ request.addValue("application/json", forHTTPHeaderField: "Content-Type")+ request.addValue("application/json", forHTTPHeaderField: "Accept")+ request.addValue("BF95B548-3C87-4BBD-8B96-534421368416", forHTTPHeaderField: "Superpass")+ do {+ request.httpBody = try Self.encoder.encode(AnisetteRequestBody(+ deviceID: deviceInfo.deviceID,+ clientInfo: deviceInfo.clientInfo.clientString+ ))+ } catch {+ return completion(.failure(error))+ }+ URLSession.shared.dataTask(with: request) { data, _, error in+ completion(Result {+ if let error = error { throw error }+ let data = try data.orThrow(Error.invalidAnisetteData)+ let anisetteResponse = try Self.decoder.decode(AnisetteResponse.self, from: data)+ return AnisetteData(+ clientTime: clientTime,+ routingInfo: anisetteResponse.routingInfo,+ machineID: anisetteResponse.machineID,+ localUserID: anisetteResponse.localUserID,+ oneTimePassword: anisetteResponse.oneTimePassword+ )+ })+ }.resume()+ }++}diff --git a/Supersign/GrandSlam/Crypto/AppTokens.swift b/Supersign/GrandSlam/Crypto/AppTokens.swiftindex b5d66ab..74fa7e9 100644--- a/Supersign/GrandSlam/Crypto/AppTokens.swift+++ b/Supersign/GrandSlam/Crypto/AppTokens.swift@@ -11,30 +11,27 @@ import Foundationenum AppTokens {static func checksum(withSK sk: Data, adsid: String, apps: [String]) -> Data {- sk.withUnsafeBytes { buf in- let bound = buf.bindMemory(to: Int8.self)+ sk.withUnsafeBytes { skBuf inlet ptrArray = apps.map { strdup($0)! }defer { ptrArray.forEach { free($0) } }let immutablePtrArray = ptrArray.map { UnsafePointer($0) }- return immutablePtrArray.withUnsafeBufferPointer { buf in+ return immutablePtrArray.withUnsafeBufferPointer { ptrBuf invar length = 0let bytes = app_tokens_create_checksum(- bound.baseAddress!, bound.count, adsid, buf.baseAddress!, buf.count, &length+ skBuf.baseAddress!, skBuf.count, adsid, ptrBuf.baseAddress!, ptrBuf.count, &length)return Data(bytesNoCopy: bytes, count: length, deallocator: .free)}}}- static func decrypt(gcm: Data, sk: Data) -> Data? {+ static func decrypt(gcm: Data, withSK sk: Data) -> Data? {gcm.withUnsafeBytes { gcmBuf insk.withUnsafeBytes { skBuf in- let gcmBound = gcmBuf.bindMemory(to: Int8.self)- let skBound = skBuf.bindMemory(to: Int8.self)var length = 0return app_tokens_decrypt_gcm(- gcmBound.baseAddress!, gcmBound.count,- skBound.baseAddress!, skBound.count,+ gcmBuf.baseAddress!, gcmBuf.count,+ skBuf.baseAddress!, skBuf.count,&length).map { Data(bytesNoCopy: $0, count: length, deallocator: .free) }}diff --git a/Supersign/GrandSlam/Crypto/SRPClient.swift b/Supersign/GrandSlam/Crypto/SRPClient.swiftindex 4f3cbeb..34c628b 100644--- a/Supersign/GrandSlam/Crypto/SRPClient.swift+++ b/Supersign/GrandSlam/Crypto/SRPClient.swift@@ -20,17 +20,13 @@ class SRPClient {}func add(data: Data) {- data.withUnsafeBytes { buf in- let bound = buf.bindMemory(to: Int8.self)- srp_client_add_data(raw, bound.baseAddress!, bound.count)- }+ data.withUnsafeBytes { srp_client_add_data(raw, $0.baseAddress!, $0.count) }}func decrypt(cbc: Data) -> Data? {cbc.withUnsafeBytes { buf in- let bound = buf.bindMemory(to: Int8.self)var length = 0- return srp_client_decrypt_cbc(raw, bound.baseAddress!, bound.count, &length)+ return srp_client_decrypt_cbc(raw, buf.baseAddress!, buf.count, &length).map { Data(bytesNoCopy: $0, count: length, deallocator: .free) }}}@@ -52,16 +48,14 @@ class SRPClient {) -> Data? {salt.withUnsafeBytes { saltBuf inkey.withUnsafeBytes { keyBuf in- let saltBound = saltBuf.bindMemory(to: Int8.self)- let keyBound = keyBuf.bindMemory(to: Int8.self)var length = 0return srp_client_process_challenge(raw,username, password,- saltBound.baseAddress!, saltBound.count,+ saltBuf.baseAddress!, saltBuf.count,.init(iterations),- keyBound.baseAddress!,- keyBound.count,+ keyBuf.baseAddress!,+ keyBuf.count,isS2K,&length).map { Data(bytesNoCopy: $0, count: length, deallocator: .free) }@@ -70,17 +64,11 @@ class SRPClient {}func verify(hamk: Data) -> Bool {- hamk.withUnsafeBytes { buf in- let bound = buf.bindMemory(to: Int8.self)- return srp_client_verify_session_HAMK(raw, bound.baseAddress!, bound.count)- }+ hamk.withUnsafeBytes { srp_client_verify_session_HAMK(raw, $0.baseAddress!, $0.count) }}func verify(negProto: Data) -> Bool {- negProto.withUnsafeBytes { buf in- let bound = buf.bindMemory(to: Int8.self)- return srp_client_verify_neg_proto(raw, bound.baseAddress!, bound.count)- }+ negProto.withUnsafeBytes { srp_client_verify_neg_proto(raw, $0.baseAddress!, $0.count) }}}diff --git a/Supersign/GrandSlam/GrandSlamClient.swift b/Supersign/GrandSlam/GrandSlamClient.swiftindex b8d37aa..d529400 100644--- a/Supersign/GrandSlam/GrandSlamClient.swift+++ b/Supersign/GrandSlam/GrandSlamClient.swift@@ -22,7 +22,7 @@ class GrandSlamClient {) {self.deviceInfo = deviceInfoself.anisetteDataProvider = customAnisetteDataProvider- ?? ComputedAnisetteDataProvider(deviceInfo: deviceInfo)+ ?? SupersetteDataProvider(deviceInfo: deviceInfo)self.lookupManager = .init(deviceInfo: deviceInfo)}@@ -52,8 +52,8 @@ class GrandSlamClient {}request.configure(request: &urlRequest, deviceInfo: deviceInfo, anisetteData: anisetteData)- URLSession.shared.dataTask(with: urlRequest) { data, response, error in- print(response.map(String.init(describing:)) ?? "NO RESPONSE")+ URLSession.shared.dataTask(with: urlRequest) { data, _, error in+// print(response.map(String.init(describing:)) ?? "NO RESPONSE")if let error = error {return completion(.failure(error))}diff --git a/Supersign/GrandSlam/Operations/GrandSlamFetchAppTokensOperation.swift b/Supersign/GrandSlam/Operations/GrandSlamFetchAppTokensOperation.swiftindex 7052717..80e0b20 100644--- a/Supersign/GrandSlam/Operations/GrandSlamFetchAppTokensOperation.swift+++ b/Supersign/GrandSlam/Operations/GrandSlamFetchAppTokensOperation.swift@@ -61,7 +61,7 @@ class GrandSlamFetchAppTokensOperation {response: GrandSlamAppTokensRequest.Decoder.Value,completion: @escaping (Result<[AppTokenKey: Token], Swift.Error>) -> Void) {- guard let decrypted = AppTokens.decrypt(gcm: response.encryptedToken, sk: self.loginData.sk)+ guard let decrypted = AppTokens.decrypt(gcm: response.encryptedToken, withSK: loginData.sk)else { return completion(.failure(Error.invalidResponse)) }completion(Result {let pairs = try decoderdiff --git a/Supersign/GrandSlam/Operations/GrandSlamTwoFactorAuthenticateOperation.swift b/Supersign/GrandSlam/Operations/GrandSlamTwoFactorAuthenticateOperation.swiftindex ea6401b..b95f8cf 100644--- a/Supersign/GrandSlam/Operations/GrandSlamTwoFactorAuthenticateOperation.swift+++ b/Supersign/GrandSlam/Operations/GrandSlamTwoFactorAuthenticateOperation.swift@@ -9,13 +9,14 @@import Foundationpublic protocol TwoFactorAuthDelegate: class {- func fetchCode(completion: @escaping (String) -> Void)+ func fetchCode(completion: @escaping (String?) -> Void)}class GrandSlamTwoFactorAuthenticateOperation {enum Error: Swift.Error {case incorrectVerificationCode+ case userCancelled}let client: GrandSlamClient@@ -42,7 +43,8 @@ class GrandSlamTwoFactorAuthenticateOperation {}}- private func validate(code: String, completion: @escaping (Result<(), Swift.Error>) -> Void) {+ private func validate(code: String?, completion: @escaping (Result<(), Swift.Error>) -> Void) {+ guard let code = code else { return completion(.failure(Error.userCancelled)) }let request = GrandSlamValidateRequest(loginData: loginData, verificationCode: code)client.send(request) { result inswitch result {diff --git a/Supersign/GrandSlam/Requests/Concrete/GrandSlamTrustedDeviceRequest.swift b/Supersign/GrandSlam/Requests/Concrete/GrandSlamTrustedDeviceRequest.swiftindex 4efc6f4..36121d6 100644--- a/Supersign/GrandSlam/Requests/Concrete/GrandSlamTrustedDeviceRequest.swift+++ b/Supersign/GrandSlam/Requests/Concrete/GrandSlamTrustedDeviceRequest.swift@@ -21,7 +21,7 @@ struct GrandSlamTrustedDeviceRequest: GrandSlamTwoFactorRequest {struct GrandSlamSecondaryAuthRequest: GrandSlamTwoFactorRequest {struct Decoder: GrandSlamDataDecoder {static func decode(data: Data) throws {- print(String(data: data, encoding: .utf8) ?? "NO DATA")+// print(String(data: data, encoding: .utf8) ?? "NO DATA")}}diff --git a/Supersign/GrandSlam/Requests/GrandSlamOperationRequest.swift b/Supersign/GrandSlam/Requests/GrandSlamOperationRequest.swiftindex 96cd0e5..d30b7e7 100644--- a/Supersign/GrandSlam/Requests/GrandSlamOperationRequest.swift+++ b/Supersign/GrandSlam/Requests/GrandSlamOperationRequest.swift@@ -8,9 +8,13 @@import Foundation-struct GrandSlamOperationError: Error {+struct GrandSlamOperationError: Error, LocalizedError {let code: Intlet message: String++ var errorDescription: String? {+ "\(message) (\(code))"+ }}struct GrandSlamOperationResponseStatusWrapper: Decodable {diff --git a/Supersign/Installation/AppInstaller.swift b/Supersign/Installation/AppInstaller.swiftindex c0ef14e..fdb727d 100644--- a/Supersign/Installation/AppInstaller.swift+++ b/Supersign/Installation/AppInstaller.swift@@ -86,26 +86,19 @@ public class AppInstaller {}}- public let ipa: URL- public let bundleID: String+ public let app: URLpublic let udid: String- public let pairingKeys: Data+ public let pairingKeys: PairingKeyspublic init(- ipa: URL,- bundleID: String,+ app: URL,udid: String,- pairingKeys: Data+ pairingKeys: PairingKeys) {- self.ipa = ipa- self.bundleID = bundleID+ self.app = appself.udid = udidself.pairingKeys = pairingKeys}- #warning("We should have some sort of `static` queue/lock")- // because if two connections are attempted simultaneously,- // the heartbeat will fail.-// synchronousprivate func installSync(progress: @escaping (Stage) -> Void@@ -132,14 +125,14 @@ public class AppInstaller {try cancelPoint()- let uploaded = try uploader.upload(ipa: ipa, withBundleID: bundleID) { currentProgress in+ let uploaded = try uploader.upload(app: app) { currentProgress inprogress(.uploading(currentProgress))}defer { uploaded.delete() }try cancelPoint()- try installer.install(uploaded: uploaded, bundleID: bundleID) { currentProgress in+ try installer.install(uploaded: uploaded) { currentProgress inprogress(.installing(currentProgress.details, currentProgress.progress))}}diff --git a/Supersign/Installation/Connection.swift b/Supersign/Installation/Connection.swiftindex 28ef731..0e21cbc 100644--- a/Supersign/Installation/Connection.swift+++ b/Supersign/Installation/Connection.swift@@ -20,7 +20,7 @@ public class Connection {public let client: LockdownClientprivate let heartbeatHandler: HeartbeatHandler- public init(udid: String, pairingKeys: Data, progress: (Double) -> Void) throws {+ public init(udid: String, pairingKeys: PairingKeys, progress: (Double) -> Void) throws {progress(0/4)usbmuxHandler = try USBMuxHandler(udid: udid, pairingKeys: pairingKeys)diff --git a/Supersign/Installation/HeartbeatHandler.swift b/Supersign/Installation/HeartbeatHandler.swiftindex 795a05d..723d1d2 100644--- a/Supersign/Installation/HeartbeatHandler.swift+++ b/Supersign/Installation/HeartbeatHandler.swift@@ -9,6 +9,21 @@import Foundationimport SwiftyMobileDevice+#warning("We should have a shared heartbeat internally")+// because otherwise if two connections are attempted simultaneously,+// the concurrent heartbeats will fail. Basically, let the interface+// continue to look like you have multiple HeartbeatHandlers, but+// internally maintain a refcount to a shared structure that maintains+// a common heartbeat while the refcount > 0.+//+// Or maybe take the abstraction up a layer to `Connection`, or somehow+// put it in USBMuxHandler? Since in fact that probably needs to be+// common too. In fact both of those things seem to basically be what+// the usbmuxd daemon does, so maybe refactor them into a single+// USBMuxDaemonShim or something, which internally has a single connection+// for each device. Alternatively, refactor `Connection` to behave like that?++#if os(iOS)public class HeartbeatHandler {private struct Error: Swift.Error {}@@ -50,10 +65,11 @@ public class HeartbeatHandler {private let heartbeatQueue = DispatchQueue(label: "com.kabiroberai.Supersign.heartbeat-queue")- public private(set) var isStopped = false+ private let stopLock = NSLock()+ private var isStopped = false- public let device: Device- public let client: LockdownClient+ private let device: Device+ private let client: LockdownClientpublic init(device: Device, client: LockdownClient) {self.device = deviceself.client = client@@ -92,10 +108,18 @@ public class HeartbeatHandler {for iteration in 0... {// only retains `self` for this iteration. This way, if the reference to// the handler is dropped, the heartbeat stops- guard let self = self, !self.isStopped else { break }+ guard let self = self else { break }++ do {+ self.stopLock.lock()+ defer { self.stopLock.unlock() }+ guard !self.isStopped else { break }+ }+do {try self.beat(client: heartbeatClient, iteration: iteration)} catch {+ print("Heartbeat failed: \(error)")// dispatching async should prevent stack overflows.// We return to break out of the current loop.return self.heartbeatQueue.asyncAfter(deadline: .now() + Self.restartInterval) {@@ -107,7 +131,15 @@ public class HeartbeatHandler {}public func stop() {+ stopLock.lock()+ defer { stopLock.unlock() }isStopped = true}}+#else+public class HeartbeatHandler {+ public init(device: Device, client: LockdownClient) {}+ public func stop() {}+}+#endifdiff --git a/Supersign/Installation/IPAInstaller.swift b/Supersign/Installation/IPAInstaller.swiftindex 591aac3..a8817ca 100644--- a/Supersign/Installation/IPAInstaller.swift+++ b/Supersign/Installation/IPAInstaller.swift@@ -18,20 +18,21 @@ public class IPAInstaller {public func install(uploaded: IPAUploader.UploadedIPA,- bundleID: String,progress: @escaping (InstallationProxyClient.InstallProgress) -> Void) throws {- let options = InstallationProxyClient.Options(additionalOptions: ["CFBundleIdentifier": bundleID])-- var error: Error?+ var result: Result<(), Error>?let semaphore = DispatchSemaphore(value: 0)- client.install(package: uploaded.location, options: options, progress: progress) { result in- defer { semaphore.signal() }- if case let .failure(e) = result { error = e }- }+ client.install(+ package: uploaded.location,+ progress: progress,+ completion: { res in+ defer { semaphore.signal() }+ result = res+ }+ )semaphore.wait()- if let error = error { throw error }+ try result!.get()}}diff --git a/Supersign/Installation/IPAUploader.swift b/Supersign/Installation/IPAUploader.swiftindex de50822..12c9d6d 100644--- a/Supersign/Installation/IPAUploader.swift+++ b/Supersign/Installation/IPAUploader.swift@@ -11,6 +11,10 @@ import SwiftyMobileDevicepublic final class IPAUploader {+ public enum Error: Swift.Error {+ case unexpectedSymlink(at: URL)+ }+private static let packagePath = URL(fileURLWithPath: "PublicStaging")private static let bufferSize = 1 << 20 // 1 MB@@ -27,7 +31,7 @@ public final class IPAUploader {deinit { delete() }public func delete() {guard !isDeleted else { return }- try? uploader.client.removeItem(at: location)+ try? uploader.client.removeItemAndContents(at: location)}}@@ -36,7 +40,25 @@ public final class IPAUploader {self.client = try connection.startClient()}- private func upload(_ src: URL, to dest: URL, progress: (Double) -> Void) throws {+ private func uploadSymlink(_ src: URL, to dest: URL, progress: (Double) -> Void) throws {+ let symlinkDest = try FileManager.default.destinationOfSymbolicLink(atPath: src.path)+ try client.linkItem(at: URL(fileURLWithPath: symlinkDest), to: dest, type: .symlink)+ }++ private func uploadDir(_ src: URL, to dest: URL, progress: (Double) -> Void) throws {+ try client.createDirectory(at: dest)+ let contents = try src.contents()+ let numFiles = contents.count+ let progressPerFile = 1 / Double(numFiles)+ var baseProgress: Double = 0+ for file in contents {+ let fileDest = dest.appendingPathComponent(file.lastPathComponent)+ try upload(file, to: fileDest) { progress(baseProgress + $0 * progressPerFile) }+ baseProgress += progressPerFile+ }+ }++ private func uploadFile(_ src: URL, to dest: URL, progress: (Double) -> Void) throws {let srcData = try Data(contentsOf: src)let size = srcData.countlet sizeDouble = Double(size)@@ -59,13 +81,31 @@ public final class IPAUploader {}}- public func upload(ipa: URL, withBundleID bundleID: String, progress: (Double) -> Void) throws -> UploadedIPA {+ private func upload(_ src: URL, to dest: URL, allowSymlinks: Bool = true, progress: (Double) -> Void) throws {+ progress(0)+ let resources = try src.resourceValues(forKeys: [.isSymbolicLinkKey, .isDirectoryKey])+ if resources.isSymbolicLink == true {+ guard allowSymlinks else { throw Error.unexpectedSymlink(at: src) }+ try uploadSymlink(src, to: dest, progress: progress)+ } else if resources.isDirectory == true {+ try uploadDir(src, to: dest, progress: progress)+ } else {+ try uploadFile(src, to: dest, progress: progress)+ }+ progress(1)+ }++ public func upload(app: URL, progress: (Double) -> Void) throws -> UploadedIPA {if try !client.fileExists(at: Self.packagePath) {try client.createDirectory(at: Self.packagePath)}- let dest = Self.packagePath.appendingPathComponent(bundleID)- try upload(ipa, to: dest, progress: progress)+ let dest = Self.packagePath.appendingPathComponent("Supercharge-App")+ if try client.fileExists(at: dest) {+ try client.removeItemAndContents(at: dest)+ }++ try upload(app, to: dest, allowSymlinks: false, progress: progress)return UploadedIPA(uploader: self, location: dest)}diff --git a/Supersign/Model/Entitlements/EntitlementTypes.swift b/Supersign/Model/Entitlements/EntitlementTypes.swiftindex 4d93743..d1055bc 100644--- a/Supersign/Model/Entitlements/EntitlementTypes.swift+++ b/Supersign/Model/Entitlements/EntitlementTypes.swift@@ -66,7 +66,10 @@ public struct KeychainAccessGroupsEntitlement: Entitlement, RawRepresentable {public struct AppGroupEntitlement: Entitlement, RawRepresentable {public static let identifier = "com.apple.security.application-groups"- public static let isFree = true+ #warning("Enable app groups on free accounts")+ // but first we need to fix the bug where it only assigns one+ // app group even if the ents say there are multiple+ public static let isFree = falsepublic var rawValue: [DeveloperServicesAppGroup.GroupID]public init(rawValue: [DeveloperServicesAppGroup.GroupID]) { self.rawValue = rawValue }diff --git a/Supersign/Signer/SigningContext.swift b/Supersign/Signer/SigningContext.swiftindex 2f90296..13b16f1 100644--- a/Supersign/Signer/SigningContext.swift+++ b/Supersign/Signer/SigningContext.swift@@ -45,7 +45,7 @@ extension SigningContext {#elseif canImport(UIKit)return UIDevice.current.name#elseif os(macOS)- return Host.current.localizedName ?? "Mac"+ return Host.current().localizedName ?? "Mac"#elsereturn "Supercharge Client"#endifdiff --git a/Supersign/Utilities/SigningInfo.swift b/Supersign/Utilities/SigningInfo.swiftindex f3b4313..e342bf9 100644--- a/Supersign/Utilities/SigningInfo.swift+++ b/Supersign/Utilities/SigningInfo.swift@@ -29,6 +29,20 @@ extension SigningInfoManager {}}+public class MemoryBackedSigningInfoManager: SigningInfoManager {+ private var infos: [String: SigningInfo] = [:]++ public init() {}++ public func info(forTeamID teamID: DeveloperServicesTeam.ID) throws -> SigningInfo? {+ infos[teamID.rawValue]+ }++ public func setInfo(_ info: SigningInfo?, forTeamID teamID: DeveloperServicesTeam.ID) throws {+ infos[teamID.rawValue] = info+ }+}+public struct KeyValueSigningInfoManager: SigningInfoManager {private enum KeyType: String {case certificatediff --git a/SupersignTests/Tests/SupersignDeveloperServicesTests.swift b/SupersignTests/Tests/SupersignDeveloperServicesTests.swiftindex de5ad87..375925f 100644--- a/SupersignTests/Tests/SupersignDeveloperServicesTests.swift+++ b/SupersignTests/Tests/SupersignDeveloperServicesTests.swift@@ -36,11 +36,12 @@ class SupersignDeveloperServicesTests: XCTestCase {udid: Config.current.udid,teamID: team.id,client: client,- signingInfoManager: TestSigningInfoManager()+ signingInfoManager: MemoryBackedSigningInfoManager()))let waiter = ResultWaiter<DeveloperServicesProvisioningOperation.Response>(description: "Failed to provision")- DeveloperServicesProvisioningOperation(context: context, app: source).perform(completion: waiter.completion)+ DeveloperServicesProvisioningOperation(context: context, app: source) { _ in }+ .perform(completion: waiter.completion)let response = try XCTTry(waiter.wait(timeout: 10000))print(response)diff --git a/SupersignTests/Tests/SupersignGrandSlamTests.swift b/SupersignTests/Tests/SupersignGrandSlamTests.swiftindex 01aee35..4517635 100644--- a/SupersignTests/Tests/SupersignGrandSlamTests.swift+++ b/SupersignTests/Tests/SupersignGrandSlamTests.swift@@ -10,7 +10,7 @@ import XCTest@testable import Supersignclass TwoFactorAuthenticator: TwoFactorAuthDelegate {- func fetchCode(completion: @escaping (String) -> Void) {+ func fetchCode(completion: @escaping (String?) -> Void) {print("Code: ", terminator: "")completion(readLine() ?? "")}diff --git a/SupersignTests/Tests/SupersignSigningTests.swift b/SupersignTests/Tests/SupersignSigningTests.swiftindex ed774f6..4d0db38 100644--- a/SupersignTests/Tests/SupersignSigningTests.swift+++ b/SupersignTests/Tests/SupersignSigningTests.swift@@ -50,7 +50,7 @@ class SupersignSigningTests: XCTestCase {udid: Config.current.udid,teamID: team.id,client: client,- signingInfoManager: TestSigningInfoManager(),+ signingInfoManager: MemoryBackedSigningInfoManager(),signerImpl: signerImpl))let signer = Signer(context: context)diff --git a/SupersignTests/Utilities/DeveloperServicesClient+Testing.swift b/SupersignTests/Utilities/DeveloperServicesClient+Testing.swiftindex ff551e3..838a24d 100644--- a/SupersignTests/Utilities/DeveloperServicesClient+Testing.swift+++ b/SupersignTests/Utilities/DeveloperServicesClient+Testing.swift@@ -18,12 +18,28 @@ extension TCPAnisetteDataProvider {}+extension NetcatAnisetteDataProvider {++ static func test() -> NetcatAnisetteDataProvider {+ NetcatAnisetteDataProvider(localPort: 4322, deviceInfo: Config.current.deviceInfo)+ }++}++extension SupersetteDataProvider {++ static func test() -> SupersetteDataProvider {+ SupersetteDataProvider(deviceInfo: Config.current.deviceInfo)+ }++}+extension GrandSlamClient {static func test() -> GrandSlamClient {GrandSlamClient(deviceInfo: Config.current.deviceInfo,- customAnisetteDataProvider: TCPAnisetteDataProvider.test()+ customAnisetteDataProvider: SupersetteDataProvider.test())}@@ -35,7 +51,7 @@ extension DeveloperServicesClient {DeveloperServicesClient(loginToken: Config.current.appleID.token,deviceInfo: Config.current.deviceInfo,- customAnisetteDataProvider: TCPAnisetteDataProvider.test()+ customAnisetteDataProvider: SupersetteDataProvider.test())}