@capgo/capacitor-updater 5.50.1 → 5.51.15

package/ios/Sources/CapacitorUpdaterPlugin/AES.swift

@@ -1,6 +1,7 @@
 import Foundation
 import CommonCrypto
 import CryptoKit
+import Darwin
 
 ///
 /// Constants
@@ -83,4 +84,127 @@ public struct AES128Key {
             return nil
         }
     }
+
+    /// AES-CBC file-to-file. Never holds the whole ciphertext in RAM.
+    func decrypt(from source: URL, to destination: URL) throws {
+        var cryptor: CCCryptorRef?
+        let createStatus: CCCryptorStatus = aes128Key.withUnsafeBytes { keyBytes in
+            initVector.withUnsafeBytes { ivBytes in
+                guard let keyPtr = keyBytes.baseAddress, let ivPtr = ivBytes.baseAddress else {
+                    return CCCryptorStatus(kCCParamError)
+                }
+                return CCCryptorCreate(
+                    CCOperation(kCCDecrypt),
+                    AESConstants.aesAlgorithm,
+                    AESConstants.aesOptions,
+                    keyPtr,
+                    keyBytes.count,
+                    ivPtr,
+                    &cryptor
+                )
+            }
+        }
+        guard createStatus == kCCSuccess, let cryptor else {
+            logger.error("Failed to create AES cryptor")
+            throw NSError(domain: "AESDecryptError", code: Int(createStatus), userInfo: nil)
+        }
+        defer {
+            CCCryptorRelease(cryptor)
+        }
+
+        guard let input = InputStream(url: source) else {
+            throw NSError(domain: "AESDecryptError", code: 1, userInfo: [NSLocalizedDescriptionKey: "Failed to open AES source"])
+        }
+        input.open()
+        defer {
+            input.close()
+        }
+
+        let tempURL = destination.deletingLastPathComponent().appendingPathComponent("capgo-aes-\(UUID().uuidString).tmp")
+        let fileManager = FileManager.default
+        fileManager.createFile(atPath: tempURL.path, contents: nil)
+        let output = try FileHandle(forWritingTo: tempURL)
+        defer {
+            try? output.close()
+            try? fileManager.removeItem(at: tempURL)
+        }
+
+        let bufferSize = CryptoCipher.ioBufferBytes()
+        let outBufSize = bufferSize + kCCBlockSizeAES128
+        var inBuf = [UInt8](repeating: 0, count: bufferSize)
+        var outBuf = [UInt8](repeating: 0, count: outBufSize)
+        let outFd = output.fileDescriptor
+
+        while true {
+            let n = inBuf.withUnsafeMutableBufferPointer { ptr in
+                input.read(ptr.baseAddress!, maxLength: ptr.count)
+            }
+            if n == 0 {
+                break
+            }
+            if n < 0 {
+                throw input.streamError ?? NSError(domain: "AESDecryptError", code: 2, userInfo: [NSLocalizedDescriptionKey: "AES stream read failed"])
+            }
+            var moved: size_t = 0
+            let status: CCCryptorStatus = inBuf.withUnsafeBufferPointer { inRaw in
+                outBuf.withUnsafeMutableBytes { outRaw in
+                    CCCryptorUpdate(
+                        cryptor,
+                        inRaw.baseAddress,
+                        n,
+                        outRaw.baseAddress,
+                        outBufSize,
+                        &moved
+                    )
+                }
+            }
+            guard status == kCCSuccess else {
+                logger.error("AES stream update failed")
+                throw NSError(domain: "AESDecryptError", code: Int(status), userInfo: nil)
+            }
+            if moved > 0 {
+                try Self.writeAll(fd: outFd, buffer: &outBuf, count: moved)
+            }
+        }
+
+        var moved: size_t = 0
+        let finalStatus: CCCryptorStatus = outBuf.withUnsafeMutableBytes { outRaw in
+            CCCryptorFinal(cryptor, outRaw.baseAddress, outBufSize, &moved)
+        }
+        guard finalStatus == kCCSuccess else {
+            logger.error("AES stream finalize failed")
+            throw NSError(domain: "AESDecryptError", code: Int(finalStatus), userInfo: nil)
+        }
+        if moved > 0 {
+            try Self.writeAll(fd: outFd, buffer: &outBuf, count: moved)
+        }
+        try output.close()
+
+        let decryptedSize = (try fileManager.attributesOfItem(atPath: tempURL.path)[.size] as? NSNumber)?.uint64Value ?? 0
+        if decryptedSize == 0 {
+            throw NSError(domain: "Empty decrypted data", code: 7, userInfo: nil)
+        }
+
+        do {
+            _ = try fileManager.replaceItemAt(destination, withItemAt: tempURL)
+        } catch {
+            if fileManager.fileExists(atPath: destination.path) {
+                throw error
+            }
+            try fileManager.moveItem(at: tempURL, to: destination)
+        }
+    }
+
+    private static func writeAll(fd: Int32, buffer: inout [UInt8], count: Int) throws {
+        var offset = 0
+        while offset < count {
+            let written = buffer.withUnsafeBufferPointer { ptr -> Int in
+                Darwin.write(fd, ptr.baseAddress!.advanced(by: offset), count - offset)
+            }
+            if written <= 0 {
+                throw NSError(domain: NSPOSIXErrorDomain, code: Int(errno), userInfo: [NSLocalizedDescriptionKey: "AES stream write failed"])
+            }
+            offset += written
+        }
+    }
 }

package/ios/Sources/CapacitorUpdaterPlugin/BundleInfo.swift

@@ -65,9 +65,17 @@ import Foundation
         return BundleStatus.DELETED == self.status
     }
 
+    public func isDeleting() -> Bool {
+        return BundleStatus.DELETING == self.status
+    }
+
+    public func isDownloading() -> Bool {
+        return BundleStatus.DOWNLOADING == self.status
+    }
+
     public func isDownloaded() -> Bool {
         return !self.isBuiltin() && self.downloaded != "" &&
-            self.downloaded != BundleInfo.DOWNLOADED_BUILTIN && !self.isDeleted()
+            self.downloaded != BundleInfo.DOWNLOADED_BUILTIN && !self.isDeleted() && !self.isDeleting()
     }
 
     public func getDownloaded() -> String {

package/ios/Sources/CapacitorUpdaterPlugin/BundleStatus.swift

@@ -36,6 +36,7 @@ enum BundleStatus: LocalizedString, CaseIterable, Decodable, Encodable {
     case ERROR = "error"
     case PENDING  = "pending"
     case DELETED  = "deleted"
+    case DELETING = "deleting"
     case DOWNLOADING  = "downloading"
 
     var storedValue: String {
@@ -48,6 +49,8 @@ enum BundleStatus: LocalizedString, CaseIterable, Decodable, Encodable {
             return "pending"
         case .DELETED:
             return "deleted"
+        case .DELETING:
+            return "deleting"
         case .DOWNLOADING:
             return "downloading"
         }