XCode project for app, moved app project to folder

SideStoreApp/Sources/SideStoreAppKit/Operations/Patch App/PatchAppOperation.swift

@@ -0,0 +1,225 @@
+//
+//  PatchAppOperation.swift
+//  AltStore
+//
+//  Created by Riley Testut on 10/13/21.
+//  Copyright © 2021 Riley Testut. All rights reserved.
+//
+
+import AppleArchive
+import Combine
+import System
+import UIKit
+import SidePatcher
+
+import AltSign
+import SideStoreCore
+import RoxasUIKit
+
+@available(iOS 14, *)
+protocol PatchAppContext {
+    var bundleIdentifier: String { get }
+    var temporaryDirectory: URL { get }
+
+    var resignedApp: ALTApplication? { get }
+    var error: Error? { get }
+}
+
+enum PatchAppError: LocalizedError {
+    case unsupportedOperatingSystemVersion(OperatingSystemVersion)
+
+    var errorDescription: String? {
+        switch self {
+        case let .unsupportedOperatingSystemVersion(osVersion):
+            var osVersionString = "\(osVersion.majorVersion).\(osVersion.minorVersion)"
+            if osVersion.patchVersion != 0 {
+                osVersionString += ".\(osVersion.patchVersion)"
+            }
+
+            let errorDescription = String(format: NSLocalizedString("The OTA download URL for iOS %@ could not be determined.", comment: ""), osVersionString)
+            return errorDescription
+        }
+    }
+}
+
+private struct OTAUpdate {
+    var url: URL
+    var archivePath: String
+}
+
+@available(iOS 14, *)
+public final class PatchAppOperation: ResultOperation<Void> {
+    let context: PatchAppContext
+
+    var progressHandler: ((Progress, String) -> Void)?
+
+    private let appPatcher = SideAppPatcher()
+    private lazy var patchDirectory: URL = self.context.temporaryDirectory.appendingPathComponent("Patch", isDirectory: true)
+
+    private var cancellable: AnyCancellable?
+
+    init(context: PatchAppContext) {
+        self.context = context
+
+        super.init()
+
+        progress.totalUnitCount = 100
+    }
+
+	public override func main() {
+        super.main()
+
+        if let error = context.error {
+            finish(.failure(error))
+            return
+        }
+
+        guard let resignedApp = context.resignedApp else { return finish(.failure(OperationError.invalidParameters)) }
+
+        progressHandler?(progress, NSLocalizedString("Downloading iOS firmware...", comment: ""))
+
+        cancellable = fetchOTAUpdate()
+            .flatMap { self.downloadArchive(from: $0) }
+            .flatMap { self.extractSpotlightFromArchive(at: $0) }
+            .flatMap { self.patch(resignedApp, withBinaryAt: $0) }
+            .tryMap { try FileManager.default.zipAppBundle(at: $0) }
+            .tryMap { fileURL in
+                let app = AnyApp(name: resignedApp.name, bundleIdentifier: self.context.bundleIdentifier, url: resignedApp.fileURL)
+
+                let destinationURL = InstalledApp.refreshedIPAURL(for: app)
+                try FileManager.default.copyItem(at: fileURL, to: destinationURL, shouldReplace: true)
+            }
+            .receive(on: RunLoop.main)
+            .sink { completion in
+                switch completion {
+                case let .failure(error): self.finish(.failure(error))
+                case .finished: self.finish(.success(()))
+                }
+            } receiveValue: { _ in }
+    }
+
+	public override func cancel() {
+        super.cancel()
+
+        cancellable?.cancel()
+        cancellable = nil
+    }
+}
+
+private let ALTFragmentZipCallback: @convention(c) (UInt32) -> Void = { percentageComplete in
+    guard let progress = Progress.current() else { return }
+
+    if percentageComplete == 100, progress.completedUnitCount == 0 {
+        // Ignore first percentageComplete, which is always 100.
+        return
+    }
+
+    progress.completedUnitCount = Int64(percentageComplete)
+}
+
+@available(iOS 14, *)
+private extension PatchAppOperation {
+    func fetchOTAUpdate() -> AnyPublisher<OTAUpdate, Error> {
+        Just(()).tryMap {
+            let osVersion = ProcessInfo.processInfo.operatingSystemVersion
+            switch (osVersion.majorVersion, osVersion.minorVersion) {
+            case (14, 3):
+                return OTAUpdate(url: URL(string: "https://updates.cdn-apple.com/2020WinterFCS/patches/001-87330/99E29969-F6B6-422A-B946-70DE2E2D73BE/com_apple_MobileAsset_SoftwareUpdate/67f9e42f5e57a20e0a87eaf81b69dd2a61311d3f.zip")!,
+                                 archivePath: "AssetData/payloadv2/payload.042")
+
+            case (14, 4):
+                return OTAUpdate(url: URL(string: "https://updates.cdn-apple.com/2021WinterFCS/patches/001-98606/43AF99A1-F286-43B1-A101-F9F856EA395A/com_apple_MobileAsset_SoftwareUpdate/c4985c32c344beb7b49c61919b4e39d1fd336c90.zip")!,
+                                 archivePath: "AssetData/payloadv2/payload.042")
+
+            case (14, 5):
+                return OTAUpdate(url: URL(string: "https://updates.cdn-apple.com/2021SpringFCS/patches/061-84483/AB525139-066E-46F8-8E85-DCE802C03BA8/com_apple_MobileAsset_SoftwareUpdate/788573ae93113881db04269acedeecabbaa643e3.zip")!,
+                                 archivePath: "AssetData/payloadv2/payload.043")
+
+            default: throw PatchAppError.unsupportedOperatingSystemVersion(osVersion)
+            }
+        }
+        .eraseToAnyPublisher()
+    }
+
+    func downloadArchive(from update: OTAUpdate) -> AnyPublisher<URL, Error> {
+        Just(()).tryMap {
+            #if targetEnvironment(simulator)
+                throw PatchAppError.unsupportedOperatingSystemVersion(ProcessInfo.processInfo.operatingSystemVersion)
+            #else
+
+                try FileManager.default.createDirectory(at: self.patchDirectory, withIntermediateDirectories: true, attributes: nil)
+
+                let archiveURL = self.patchDirectory.appendingPathComponent("ota.archive")
+                try archiveURL.withUnsafeFileSystemRepresentation { archivePath in
+                    guard let fz = fragmentzip_open((update.url.absoluteString as NSString).utf8String!) else {
+                        throw URLError(.cannotConnectToHost, userInfo: [NSLocalizedDescriptionKey: NSLocalizedString("The connection failed because a connection cannot be made to the host.", comment: ""),
+                                                                        NSURLErrorKey: update.url])
+                    }
+                    defer { fragmentzip_close(fz) }
+
+                    self.progress.becomeCurrent(withPendingUnitCount: 100)
+                    defer { self.progress.resignCurrent() }
+
+                    guard fragmentzip_download_file(fz, update.archivePath, archivePath!, ALTFragmentZipCallback) == 0 else {
+                        throw URLError(.networkConnectionLost, userInfo: [NSLocalizedDescriptionKey: NSLocalizedString("The connection failed because the network connection was lost.", comment: ""),
+                                                                          NSURLErrorKey: update.url])
+                    }
+                }
+
+                print("Downloaded OTA archive.")
+                return archiveURL
+
+            #endif
+        }
+        .mapError { ($0 as NSError).withLocalizedFailure(NSLocalizedString("Could not download OTA archive.", comment: "")) }
+        .eraseToAnyPublisher()
+    }
+
+    func extractSpotlightFromArchive(at archiveURL: URL) -> AnyPublisher<URL, Error> {
+        Just(()).tryMap {
+            #if targetEnvironment(simulator)
+                throw PatchAppError.unsupportedOperatingSystemVersion(ProcessInfo.processInfo.operatingSystemVersion)
+            #else
+
+                let spotlightPath = "Applications/Spotlight.app/Spotlight"
+                let spotlightFileURL = self.patchDirectory.appendingPathComponent(spotlightPath)
+
+                guard let readFileStream = ArchiveByteStream.fileStream(path: FilePath(archiveURL.path), mode: .readOnly, options: [], permissions: FilePermissions(rawValue: 0o644)),
+                      let decompressStream = ArchiveByteStream.decompressionStream(readingFrom: readFileStream),
+                      let decodeStream = ArchiveStream.decodeStream(readingFrom: decompressStream),
+                      let readStream = ArchiveStream.extractStream(extractingTo: FilePath(self.patchDirectory.path))
+                else { throw CocoaError(.fileReadCorruptFile, userInfo: [NSURLErrorKey: archiveURL]) }
+
+                _ = try ArchiveStream.process(readingFrom: decodeStream, writingTo: readStream) { _, filePath, _ in
+                    guard filePath == FilePath(spotlightPath) else { return .skip }
+                    return .ok
+                }
+
+                print("Extracted Spotlight from OTA archive.")
+                return spotlightFileURL
+
+            #endif
+        }
+        .mapError { ($0 as NSError).withLocalizedFailure(NSLocalizedString("Could not extract Spotlight from OTA archive.", comment: "")) }
+        .eraseToAnyPublisher()
+    }
+
+    func patch(_ app: ALTApplication, withBinaryAt patchFileURL: URL) -> AnyPublisher<URL, Error> {
+        Just(()).tryMap {
+            // executableURL may be nil, so use infoDictionary instead to determine executable name.
+            // guard let appName = app.bundle.executableURL?.lastPathComponent else { throw OperationError.invalidApp }
+            guard let appName = app.bundle.infoDictionary?[kCFBundleExecutableKey as String] as? String else { throw OperationError.invalidApp }
+
+            let temporaryAppURL = self.patchDirectory.appendingPathComponent("Patched.app", isDirectory: true)
+            try FileManager.default.copyItem(at: app.fileURL, to: temporaryAppURL)
+
+            let appBinaryURL = temporaryAppURL.appendingPathComponent(appName, isDirectory: false)
+            try self.appPatcher.patchAppBinary(at: appBinaryURL, withBinaryAt: patchFileURL)
+
+            print("Patched \(app.name).")
+            return temporaryAppURL
+        }
+        .mapError { ($0 as NSError).withLocalizedFailure(String(format: NSLocalizedString("Could not patch %@ placeholder.", comment: ""), app.name)) }
+        .eraseToAnyPublisher()
+    }
+}