@capgo/capacitor-updater 7.50.2 → 7.51.16

package/ios/Sources/CapacitorUpdaterPlugin/CryptoCipher.swift

@@ -141,8 +141,24 @@ public struct CryptoCipher {
         }
     }
 
+    /// 256 KiB: one size for checksum, copy, and decode.
+    /// 64 workers * 256 KiB = 16 MiB for one buffer; AES/Brotli hold two (~32 MiB).
+    static let ioBufferBytesValue = 256 * 1024
+
+    static func ioBufferBytes() -> Int {
+        return ioBufferBytesValue
+    }
+
+    static func checksumBufferBytes() -> Int {
+        return ioBufferBytesValue
+    }
+
+    static func copyBufferBytes() -> Int {
+        return ioBufferBytesValue
+    }
+
     public static func calcChecksum(filePath: URL) -> String {
-        let bufferSize = 1024 * 1024 * 5 // 5 MB
+        let bufferSize = checksumBufferBytes()
         var sha256 = SHA256()
 
         do {
@@ -182,8 +198,7 @@ public struct CryptoCipher {
                 }
             }) {}
 
-            let digest = sha256.finalize()
-            return digest.compactMap { String(format: "%02x", $0) }.joined()
+            return hexString(from: sha256)
         } catch {
             logger.error("Cannot calculate checksum")
             logger.debug("Path: \(filePath.path), Error: \(error)")
@@ -191,6 +206,32 @@ public struct CryptoCipher {
         }
     }
 
+    final class RunningChecksum {
+        private var sha256 = SHA256()
+
+        func update(_ data: Data) {
+            guard !data.isEmpty else {
+                return
+            }
+            sha256.update(data: data)
+        }
+
+        func hex() -> String {
+            CryptoCipher.hexString(from: sha256)
+        }
+    }
+
+    static func hexString(from sha256: SHA256) -> String {
+        var copy = sha256
+        return copy.finalize().compactMap { String(format: "%02x", $0) }.joined()
+    }
+
+    static func shortPathKey(_ fileName: String) -> String {
+        var sha256 = SHA256()
+        sha256.update(data: Data(fileName.utf8))
+        return String(hexString(from: sha256).prefix(16))
+    }
+
     public static func decryptFile(filePath: URL, publicKey: String, sessionKey: String, version: String) throws {
         if publicKey.isEmpty || sessionKey.isEmpty || sessionKey.components(separatedBy: ":").count != 2 {
             logger.info("Encryption not set, no public key or session, ignored")
@@ -243,42 +284,19 @@ public struct CryptoCipher {
 
             let aesPrivateKey = AES128Key(iv: ivData, aes128Key: sessionKeyDataDecrypted, logger: logger)
 
-            let encryptedData: Data
-            do {
-                encryptedData = try Data(contentsOf: filePath)
-            } catch {
-                logger.error("Failed to read encrypted data")
-                logger.debug("Error: \(error)")
-                throw NSError(domain: "Failed to read encrypted data", code: 3, userInfo: nil)
-            }
-
-            if encryptedData.isEmpty {
+            let encryptedSize = (try FileManager.default.attributesOfItem(atPath: filePath.path)[.size] as? NSNumber)?.uint64Value ?? 0
+            if encryptedSize == 0 {
                 logger.error("Encrypted file data is empty")
                 throw NSError(domain: "Empty encrypted data", code: 6, userInfo: nil)
             }
 
-            guard let decryptedData = aesPrivateKey.decrypt(data: encryptedData) else {
-                logger.error("Failed to decrypt data")
-                throw NSError(domain: "Failed to decrypt data", code: 4, userInfo: nil)
-            }
-
-            if decryptedData.isEmpty {
+            try aesPrivateKey.decrypt(from: filePath, to: filePath)
+            let decryptedSize = (try FileManager.default.attributesOfItem(atPath: filePath.path)[.size] as? NSNumber)?.uint64Value ?? 0
+            if decryptedSize == 0 {
                 logger.error("Decrypted data is empty")
                 throw NSError(domain: "Empty decrypted data", code: 7, userInfo: nil)
             }
 
-            do {
-                try decryptedData.write(to: filePath, options: .atomic)
-                if !FileManager.default.fileExists(atPath: filePath.path) {
-                    logger.error("File was not created after write")
-                    throw NSError(domain: "File write failed", code: 8, userInfo: nil)
-                }
-            } catch {
-                logger.error("Error writing decrypted file")
-                logger.debug("Error: \(error)")
-                throw error
-            }
-
         } catch {
             logger.error("File decryption failed")
             throw CustomError.cannotDecode

package/ios/Sources/CapacitorUpdaterPlugin/RSA.swift

@@ -1,274 +1,96 @@
-import BigInt
-import Foundation
-import CommonCrypto
-import CryptoKit
-
-///
-/// Constants
-///
-private enum RSAConstants {
-    static let rsaKeySizeInBits: NSNumber = 2048
-    static let rsaAlgorithm: SecKeyAlgorithm = .rsaEncryptionOAEPSHA256
-}
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
 
-// We do all this stuff because ios is shit and open source libraries allow to do decryption with public key
-// So we have to do it manually, while in nodejs or Java it's ok and done at language level.
+import Foundation
+import Security
+import os.log
 
-///
-/// The RSA public key.
-///
+/// Capgo v2 uses Node's privateEncrypt with PKCS#1 v1.5 type-1 padding for
+/// checksums and session keys. Recover the signed payload using Apple's RSA
+/// implementation instead of custom modular exponentiation.
 public struct RSAPublicKey {
-    private let manualKey: ManualRSAPublicKey
-
-    fileprivate init(manualKey: ManualRSAPublicKey) {
-        self.manualKey = manualKey
-    }
-
-    ///
-    /// Takes the data and uses the public key to decrypt it.
-    /// Returns the decrypted data.
-    ///
-    public func decrypt(data: Data) -> Data? {
-        return manualKey.decrypt(data)
-    }
+    private let key: SecKey
+    private static let keyLock = NSLock()
+    private static let log = OSLog(subsystem: "ee.forgr.capacitor_updater", category: "RSA")
+    // One public key only: bounded storage, invalid/rotated keys never fall back
+    // to a cached key with different material. SecKey is immutable after import.
+    private static var cachedKey: (der: Data, key: SecKey)?
 
-    ///
-    /// Allows you to load an RSA public key (i.e. one downloaded from the net).
-    ///
     public static func load(rsaPublicKey: String) -> RSAPublicKey? {
-        // Clean up the key string
-        var pubKey: String = rsaPublicKey
-        pubKey = pubKey.replacingOccurrences(of: "-----BEGIN RSA PUBLIC KEY-----", with: "")
-        pubKey = pubKey.replacingOccurrences(of: "-----END RSA PUBLIC KEY-----", with: "")
-        pubKey = pubKey.replacingOccurrences(of: "-----BEGIN PUBLIC KEY-----", with: "")
-        pubKey = pubKey.replacingOccurrences(of: "-----END PUBLIC KEY-----", with: "")
-        pubKey = pubKey.replacingOccurrences(of: "\\n+", with: "", options: .regularExpression)
-        pubKey = pubKey.replacingOccurrences(of: "\n", with: "")
-        pubKey = pubKey.trimmingCharacters(in: .whitespacesAndNewlines)
-
-        do {
-            guard let rsaPublicKeyData: Data = Data(base64Encoded: String(pubKey)) else {
-                throw CustomError.cannotDecode
-            }
-
-            // Try parsing as PKCS#1
-            if let manualKey = ManualRSAPublicKey.fromPKCS1(rsaPublicKeyData) {
-                return RSAPublicKey(manualKey: manualKey)
-            }
-
-            // Most common public exponent is 65537 (0x010001)
-            let commonExponent = Data([0x01, 0x00, 0x01]) // 65537 in big-endian
-
-            // Assume the entire key data is the modulus
-            let lastResortKey = ManualRSAPublicKey(modulus: rsaPublicKeyData, exponent: commonExponent)
-            return RSAPublicKey(manualKey: lastResortKey)
-        } catch {
-            return nil
-        }
-    }
-}
-
-// Manual RSA Public Key Implementation using the BigInt library
-struct ManualRSAPublicKey {
-    let modulus: BigInt
-    let exponent: BigInt
-
-    init(modulus: Data, exponent: Data) {
-        // Create positive BigInts from Data
-        let modulusBytes = [UInt8](modulus)
-        var modulusValue = BigUInt(0)
-        for byte in modulusBytes {
-            modulusValue = (modulusValue << 8) | BigUInt(byte)
-        }
-        self.modulus = BigInt(modulusValue)
-        let exponentBytes = [UInt8](exponent)
-        var exponentValue = BigUInt(0)
-        for byte in exponentBytes {
-            exponentValue = (exponentValue << 8) | BigUInt(byte)
-        }
-        self.exponent = BigInt(exponentValue)
-    }
-
-    // Parse PKCS#1 format public key
-    static func fromPKCS1(_ publicKeyData: Data) -> ManualRSAPublicKey? {
-        // Parse ASN.1 DER encoded RSA public key
-        // Format: RSAPublicKey ::= SEQUENCE { modulus INTEGER, publicExponent INTEGER }
-
-        guard publicKeyData.count > 0 else {
-            return nil
-        }
-
-        let bytes = [UInt8](publicKeyData)
-
-        // Check for sequence tag (0x30)
-        guard bytes[0] == 0x30 else {
-            // Try direct modulus/exponent approach as fallback
-            if publicKeyData.count >= 3 {
-                // Assume this is a raw RSA public key with modulus + exponent
-                // Most common: modulus is 256 bytes (2048 bits), exponent is 3 bytes (0x010001 = 65537)
-                let modulusSize = publicKeyData.count - 3
-                if modulusSize > 0 {
-                    let modulusData = publicKeyData.prefix(modulusSize)
-                    let exponentData = publicKeyData.suffix(3)
-                    return ManualRSAPublicKey(modulus: modulusData, exponent: exponentData)
-                }
-            }
-
-            return nil
-        }
-
-        var index = 1
-
-        // Skip length
-        if bytes[index] & 0x80 != 0 {
-            let lenBytes = Int(bytes[index] & 0x7F)
-            if (index + 1 + lenBytes) >= bytes.count {
-                return nil
-            }
-            index += 1 + lenBytes
-        } else {
-            index += 1
-        }
-
-        // Check for INTEGER tag for modulus (0x02)
-        if index >= bytes.count {
-            return nil
-        }
-
-        guard bytes[index] == 0x02 else {
-            return nil
-        }
-        index += 1
-
-        // Get modulus length
-        if index >= bytes.count {
-            return nil
-        }
-
-        var modulusLength = 0
-        if bytes[index] & 0x80 != 0 {
-            let lenBytes = Int(bytes[index] & 0x7F)
-            if (index + 1 + lenBytes) >= bytes.count {
-                return nil
-            }
-            index += 1
-            for i in 0..<lenBytes {
-                modulusLength = (modulusLength << 8) | Int(bytes[index + i])
-            }
-            index += lenBytes
-        } else {
-            modulusLength = Int(bytes[index])
-            index += 1
-        }
-
-        // Skip any leading zero in modulus (for unsigned integer)
-        if index < bytes.count && bytes[index] == 0x00 {
-            index += 1
-            modulusLength -= 1
-        }
-
-        // Extract modulus
-        if (index + modulusLength) > bytes.count {
-            return nil
-        }
-
-        let modulusData = Data(bytes[index..<(index + modulusLength)])
-        index += modulusLength
-
-        // Check for INTEGER tag for exponent
-        if index >= bytes.count {
+        guard let der = pemToDer(rsaPublicKey) else {
+            os_log("RSA key import failed: invalid PEM/base64", log: Self.log, type: .error)
             return nil
         }
 
-        guard bytes[index] == 0x02 else {
+        keyLock.lock()
+        defer { keyLock.unlock() }
+        if let cached = cachedKey, cached.der == der {
+            return RSAPublicKey(key: cached.key)
+        }
+
+        let attributes: [CFString: Any] = [
+            kSecAttrKeyType: kSecAttrKeyTypeRSA,
+            kSecAttrKeyClass: kSecAttrKeyClassPublic
+        ]
+        var error: Unmanaged<CFError>?
+        guard let key = SecKeyCreateWithData(der as CFData, attributes as CFDictionary, &error) else {
+            os_log(
+                "RSA key import failed: %{public}@",
+                log: Self.log,
+                type: .error,
+                String(describing: error?.takeRetainedValue())
+            )
             return nil
         }
-        index += 1
-
-        // Get exponent length
-        if index >= bytes.count {
+        guard CapgoRawRsa.supportsCapgoRecovery(key: key) else {
+            os_log(
+                "RSA key import failed: unsupported key (Capgo requires RSA-2048 with raw encryption)",
+                log: Self.log,
+                type: .error
+            )
             return nil
         }
+        cachedKey = (der, key)
+        return RSAPublicKey(key: key)
+    }
 
-        var exponentLength = 0
-        if bytes[index] & 0x80 != 0 {
-            let lenBytes = Int(bytes[index] & 0x7F)
-            if (index + 1 + lenBytes) >= bytes.count {
-                return nil
-            }
-            index += 1
-            for i in 0..<lenBytes {
-                exponentLength = (exponentLength << 8) | Int(bytes[index + i])
-            }
-            index += lenBytes
-        } else {
-            exponentLength = Int(bytes[index])
-            index += 1
-        }
-
-        // Extract exponent
-        if (index + exponentLength) > bytes.count {
+    public func decrypt(data: Data) -> Data? {
+        let blockSize = SecKeyGetBlockSize(key)
+        guard data.count == blockSize else { return nil }
+        // Raw public-key encryption is the same c^e mod n operation as Node's
+        // publicDecrypt. Do NOT use encryption PKCS#1 padding here: the recovered
+        // block already contains signature (type-1) padding, checked below.
+        guard let recovered = CapgoRawRsa.recoverSignatureBlock(key: key, data: data) else {
             return nil
         }
-
-        let exponentData = Data(bytes[index..<(index + exponentLength)])
-        return ManualRSAPublicKey(modulus: modulusData, exponent: exponentData)
+        return Self.unpadSignature(recovered, blockSize: blockSize)
     }
 
-    // Decrypt data using raw RSA operation (c^d mod n)
-    func decrypt(_ encryptedData: Data) -> Data? {
-        // Create positive BigInt from encrypted data
-        let encryptedBytes = [UInt8](encryptedData)
-        var encryptedValue = BigUInt(0)
-        for byte in encryptedBytes {
-            encryptedValue = (encryptedValue << 8) | BigUInt(byte)
+    static func unpadSignature(_ block: Data, blockSize: Int = 256) -> Data? {
+        let bytes = [UInt8](block)
+        // RFC 8017: 00 01, at least eight FF bytes, 00, then the payload.
+        guard bytes.count == blockSize, bytes[0] == 0, bytes[1] == 1 else { return nil }
+        var separator = 2
+        while separator < bytes.count && bytes[separator] == 0xff {
+            separator += 1
         }
-        let encrypted = BigInt(encryptedValue)
-
-        // In Node.js:
-        // privateEncrypt uses the private key (d) to encrypt
-        // publicDecrypt uses the public key (e) to decrypt
-        // The operation we want is: ciphertext^e mod n
-
-        // RSA operation: c^e mod n
-        let decrypted = encrypted.manualPower(exponent, modulus: modulus)
-
-        // Convert to bytes with proper padding
-        guard let bigUIntValue = decrypted.magnitude as? BigUInt else {
+        guard separator >= 10, separator < bytes.count - 1, bytes[separator] == 0 else {
             return nil
         }
+        return Data(bytes[(separator + 1)...])
+    }
 
-        // Convert BigUInt to bytes with padding
-        var resultBytes = [UInt8]()
-        var tempValue = bigUIntValue
-        while tempValue > 0 {
-            let byte = UInt8(tempValue & 0xFF)
-            resultBytes.insert(byte, at: 0)  // Prepend to get big-endian
-            tempValue >>= 8
-        }
-
-        // Ensure we have at least 256 bytes (2048 bits) with leading zeros
-        let paddedBytes = [UInt8](repeating: 0, count: max(0, 256 - resultBytes.count)) + resultBytes
-
-        // For PKCS1 padding from Node.js privateEncrypt, the format is:
-        // 0x00 || 0x01 || PS || 0x00 || actual data
-        // where PS is a string of 0xFF bytes
-
-        // Check for privateEncrypt padding format (0x00 || 0x01 || PS || 0x00)
-        var startIndex = 0
-        if paddedBytes.count > 2 && paddedBytes[0] == 0x00 && paddedBytes[1] == 0x01 {
-            for i in 2..<paddedBytes.count {
-                if paddedBytes[i] == 0x00 {
-                    startIndex = i + 1
-                    break
-                }
-            }
-        }
-        if startIndex < paddedBytes.count {
-            let result = Data(paddedBytes[startIndex...])
-            return result
-        } else {
-            return Data(paddedBytes)
-        }
+    private static func pemToDer(_ pem: String) -> Data? {
+        let encoded = pem
+            .replacingOccurrences(of: "-----BEGIN RSA PUBLIC KEY-----", with: "")
+            .replacingOccurrences(of: "-----END RSA PUBLIC KEY-----", with: "")
+            .replacingOccurrences(of: "-----BEGIN PUBLIC KEY-----", with: "")
+            .replacingOccurrences(of: "-----END PUBLIC KEY-----", with: "")
+            .replacingOccurrences(of: "\\n", with: "")
+            .components(separatedBy: .whitespacesAndNewlines).joined()
+        return Data(base64Encoded: encoded)
     }
 }

package/ios/Sources/CapacitorUpdaterPlugin/ShakeMenu.swift

@@ -92,18 +92,26 @@ final class ThreeFingerPinchGestureRecognizer: UIGestureRecognizer {
 }
 
 extension UIApplication {
-    // swiftlint:disable:next line_length
-    public class func topViewController(_ base: UIViewController? = UIApplication.shared.windows.first?.rootViewController) -> UIViewController? {
-        if let nav = base as? UINavigationController {
+    public class func topViewController(_ base: UIViewController? = nil) -> UIViewController? {
+        let resolvedBase = base ?? keyWindowRootViewController
+        if let nav = resolvedBase as? UINavigationController {
             return topViewController(nav.visibleViewController)
         }
-        if let tab = base as? UITabBarController, let selected = tab.selectedViewController {
+        if let tab = resolvedBase as? UITabBarController, let selected = tab.selectedViewController {
             return topViewController(selected)
         }
-        if let presented = base?.presentedViewController {
+        if let presented = resolvedBase?.presentedViewController {
             return topViewController(presented)
         }
-        return base
+        return resolvedBase
+    }
+
+    private static var keyWindowRootViewController: UIViewController? {
+        let scenes = shared.connectedScenes.compactMap { $0 as? UIWindowScene }
+        let foregroundScenes = scenes.filter { $0.activationState == .foregroundActive }
+        let candidates = foregroundScenes.isEmpty ? scenes : foregroundScenes
+        let window = candidates.flatMap(\.windows).first(where: \.isKeyWindow) ?? candidates.first?.windows.first
+        return window?.rootViewController
     }
 }
 
@@ -184,6 +192,10 @@ extension CapacitorUpdaterPlugin: UIGestureRecognizerDelegate {
 }
 
 extension UIWindow {
+    private var menuHostViewController: UIViewController? {
+        UIApplication.topViewController(rootViewController)
+    }
+
     override open func motionEnded(_ motion: UIEvent.EventSubtype, with event: UIEvent?) {
         if motion == .motionShake {
             guard let bridgeViewController = rootViewController as? CAPBridgeViewController,
@@ -230,7 +242,7 @@ extension UIWindow {
     @discardableResult
     private func showDefaultMenu(plugin: CapacitorUpdaterPlugin, bridge: CAPBridgeProtocol) -> Bool {
         // Prevent multiple alerts from showing
-        guard let topVC = UIApplication.topViewController() else {
+        guard let topVC = self.menuHostViewController else {
             return false
         }
         if topVC.isKind(of: UIAlertController.self) {
@@ -365,7 +377,7 @@ extension UIWindow {
         })
 
         DispatchQueue.main.async {
-            if let topVC = UIApplication.topViewController() {
+            if let topVC = self.menuHostViewController {
                 topVC.present(alertShake, animated: true)
             }
         }
@@ -388,7 +400,7 @@ extension UIWindow {
     }
 
     private func showPreviewSelector(plugin: CapacitorUpdaterPlugin) {
-        guard let topVC = UIApplication.topViewController() else {
+        guard let topVC = self.menuHostViewController else {
             return
         }
         if topVC.isKind(of: UIAlertController.self) {
@@ -456,7 +468,7 @@ extension UIWindow {
         alert.addAction(UIAlertAction(title: "Cancel", style: .cancel))
 
         DispatchQueue.main.async {
-            if let topVC = UIApplication.topViewController() {
+            if let topVC = self.menuHostViewController {
                 topVC.present(alert, animated: true)
             }
         }
@@ -479,7 +491,7 @@ extension UIWindow {
         }
 
         DispatchQueue.main.async {
-            if let topVC = UIApplication.topViewController() {
+            if let topVC = self.menuHostViewController {
                 topVC.present(alert, animated: true)
             }
         }
@@ -498,7 +510,7 @@ extension UIWindow {
     @discardableResult
     private func showChannelSelector(plugin: CapacitorUpdaterPlugin, bridge: CAPBridgeProtocol) -> Bool {
         // Prevent multiple alerts from showing
-        guard let topVC = UIApplication.topViewController() else {
+        guard let topVC = self.menuHostViewController else {
             return false
         }
         if topVC.isKind(of: UIAlertController.self) {
@@ -582,7 +594,7 @@ extension UIWindow {
         }
 
         DispatchQueue.main.async {
-            if let topVC = UIApplication.topViewController() {
+            if let topVC = self.menuHostViewController {
                 topVC.present(alert, animated: true)
             }
         }
@@ -627,7 +639,7 @@ extension UIWindow {
         alert.addAction(UIAlertAction(title: "Cancel", style: .cancel))
 
         DispatchQueue.main.async {
-            if let topVC = UIApplication.topViewController() {
+            if let topVC = self.menuHostViewController {
                 topVC.present(alert, animated: true)
             }
         }
@@ -649,7 +661,7 @@ extension UIWindow {
         ])
 
         DispatchQueue.main.async {
-            if let topVC = UIApplication.topViewController() {
+            if let topVC = self.menuHostViewController {
                 topVC.present(progressAlert, animated: true) {
                     DispatchQueue.global(qos: .userInitiated).async {
                         // Set the channel - respect plugin's allowSetDefaultChannel config
@@ -668,6 +680,14 @@ extension UIWindow {
                             }
                             return
                         }
+                        guard plugin.persistDefaultChannelStateFromDefaults() else {
+                            DispatchQueue.main.async {
+                                progressAlert.dismiss(animated: true) {
+                                    self.showError(message: "Channel set to \(name), but local persistence failed.", plugin: plugin)
+                                }
+                            }
+                            return
+                        }
 
                         // Update progress message
                         DispatchQueue.main.async {
@@ -718,8 +738,12 @@ extension UIWindow {
                             return
                         }
 
-                        // Check if there's an actual update available
-                        if latestKind == "up_to_date" || latest.url.isEmpty {
+                        // Check if there's an actual update available. A manifest-only
+                        // response legitimately has no URL (the files come from the
+                        // manifest, not a zip), so only report "already on latest" when
+                        // the URL is empty AND there is no manifest to download from.
+                        let hasManifest = !(latest.manifest?.isEmpty ?? true)
+                        if latestKind == "up_to_date" || (latest.url.isEmpty && !hasManifest) {
                             DispatchQueue.main.async {
                                 progressAlert.dismiss(animated: true) {
                                     self.showSuccess(message: "Channel set to \(name). Already on latest version.", plugin: plugin)
@@ -794,7 +818,7 @@ extension UIWindow {
         alert.addAction(UIAlertAction(title: "OK", style: .default))
 
         DispatchQueue.main.async {
-            if let topVC = UIApplication.topViewController() {
+            if let topVC = self.menuHostViewController {
                 topVC.present(alert, animated: true)
             }
         }
@@ -806,7 +830,7 @@ extension UIWindow {
         alert.addAction(UIAlertAction(title: "OK", style: .default))
 
         DispatchQueue.main.async {
-            if let topVC = UIApplication.topViewController() {
+            if let topVC = self.menuHostViewController {
                 topVC.present(alert, animated: true)
             }
         }
@@ -832,7 +856,7 @@ extension UIWindow {
         })
 
         DispatchQueue.main.async {
-            if let topVC = UIApplication.topViewController() {
+            if let topVC = self.menuHostViewController {
                 topVC.present(alert, animated: true)
             }
         }