@capgo/capacitor-updater 7.13.16 → 7.13.18

package/CapgoCapacitorUpdater.podspec

@@ -16,6 +16,7 @@ Pod::Spec.new do |s|
   s.dependency 'SSZipArchive', '2.4.3'
   s.dependency 'Alamofire', '5.10.2'
   s.dependency 'Version', '0.8.0'
+  # We cannot update to latest because it not published anymore in cocoa https://github.com/attaswift/BigInt/issues/94
   s.dependency 'BigInt', '5.2.0'
   s.swift_version = '5.1'
 end

package/android/src/main/java/ee/forgr/capacitor_updater/CapacitorUpdaterPlugin.java

@@ -58,7 +58,7 @@ public class CapacitorUpdaterPlugin extends Plugin {
     private static final String statsUrlDefault = "https://plugin.capgo.app/stats";
     private static final String channelUrlDefault = "https://plugin.capgo.app/channel_self";
 
-    private final String PLUGIN_VERSION = "7.13.16";
+    private final String PLUGIN_VERSION = "7.13.18";
     private static final String DELAY_CONDITION_PREFERENCES = "";
 
     private SharedPreferences.Editor editor;

package/ios/Sources/CapacitorUpdaterPlugin/AES.swift

@@ -0,0 +1,69 @@
+import BigInt
+import Foundation
+import CommonCrypto
+import CryptoKit
+
+///
+/// Constants
+///
+private enum AESConstants {
+    static let aesAlgorithm: CCAlgorithm = CCAlgorithm(kCCAlgorithmAES)
+    static let aesOptions: CCOptions = CCOptions(kCCOptionPKCS7Padding)
+}
+
+// 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.
+
+///
+/// The AES key. Contains both the initialization vector and secret key.
+///
+public struct AES128Key {
+    /// Initialization vector
+    private let iv: Data
+    private let logger: Logger
+    private let aes128Key: Data
+    #if DEBUG
+    public var __debug_iv: Data { iv }
+    public var __debug_aes128Key: Data { aes128Key }
+    #endif
+    init(iv: Data, aes128Key: Data, logger: Logger) {
+        self.iv = iv
+        self.aes128Key = aes128Key
+        self.logger = logger
+    }
+    ///
+    /// Takes the data and uses the private key to decrypt it. Will call `CCCrypt` in CommonCrypto
+    /// and provide it `ivData` for the initialization vector. Will use cipher block chaining (CBC) as
+    /// the mode of operation.
+    ///
+    /// Returns the decrypted data.
+    ///
+    public func decrypt(data: Data) -> Data? {
+        let encryptedData: UnsafePointer<UInt8> = (data as NSData).bytes.bindMemory(to: UInt8.self, capacity: data.count)
+        let encryptedDataLength: Int = data.count
+
+        if let result: NSMutableData = NSMutableData(length: encryptedDataLength) {
+            let keyData: UnsafePointer<UInt8> = (self.aes128Key as NSData).bytes.bindMemory(to: UInt8.self, capacity: self.aes128Key.count)
+            let keyLength: size_t = size_t(self.aes128Key.count)
+            let ivData: UnsafePointer<UInt8> = (iv as NSData).bytes.bindMemory(to: UInt8.self, capacity: self.iv.count)
+
+            let decryptedData: UnsafeMutablePointer<UInt8> = UnsafeMutablePointer<UInt8>(result.mutableBytes.assumingMemoryBound(to: UInt8.self))
+            let decryptedDataLength: size_t = size_t(result.length)
+
+            var decryptedLength: size_t = 0
+
+            let status: CCCryptorStatus = CCCrypt(CCOperation(kCCDecrypt), AESConstants.aesAlgorithm, AESConstants.aesOptions, keyData, keyLength, ivData, encryptedData, encryptedDataLength, decryptedData, decryptedDataLength, &decryptedLength)
+
+            if Int32(status) == Int32(kCCSuccess) {
+                result.length = Int(decryptedLength)
+                return result as Data
+            } else {
+                logger.error("AES decryption failed with status: \(status)")
+                return nil
+            }
+        } else {
+            logger.error("Failed to allocate memory for AES decryption")
+            return nil
+        }
+    }
+}

package/ios/Sources/CapacitorUpdaterPlugin/BigInt.swift

@@ -0,0 +1,55 @@
+import BigInt
+
+// Extension to serialize BigInt to bytes array
+extension BigInt {
+    func serializeToBytes() -> [UInt8] {
+        let byteCount = (self.bitWidth + 7) / 8
+        var bytes = [UInt8](repeating: 0, count: byteCount)
+
+        var value = self
+        for i in 0..<byteCount {
+            bytes[byteCount - i - 1] = UInt8(truncatingIfNeeded: value & 0xFF)
+            value >>= 8
+        }
+
+        return bytes
+    }
+}
+
+// Add this custom power function to ensure safer handling of power operations
+
+// Manual exponentiation using the square-and-multiply algorithm
+// which is more efficient and avoids using the built-in functions that might handle BigInt differently
+extension BigInt {
+    func manualPower(_ exponent: BigInt, modulus: BigInt) -> BigInt {
+        // Quick checks
+        if modulus == 0 {
+            return 0
+        }
+
+        if exponent == 0 {
+            return 1
+        }
+
+        guard let base = self.magnitude as? BigUInt,
+              let exp = exponent.magnitude as? BigUInt,
+              let mod = modulus.magnitude as? BigUInt else {
+            return 0
+        }
+
+        // Square and multiply algorithm for modular exponentiation
+        var result = BigUInt(1)
+        var x = base % mod
+        var e = exp
+
+        while e > 0 {
+            if e & 1 == 1 {
+                result = (result * x) % mod
+            }
+            x = (x * x) % mod
+            e >>= 1
+        }
+
+        return BigInt(result)
+    }
+}

package/ios/Sources/CapacitorUpdaterPlugin/BundleInfo.swift

@@ -0,0 +1,113 @@
+/*
+ * 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/.
+ */
+
+import Foundation
+
+@objc public class BundleInfo: NSObject, Decodable, Encodable {
+    public static let ID_BUILTIN: String = "builtin"
+    public static let VERSION_UNKNOWN: String = "unknown"
+    public static let DOWNLOADED_BUILTIN: String = "1970-01-01T00:00:00.000Z"
+
+    private let downloaded: String
+    private let id: String
+    private let version: String
+    private let checksum: String
+    private let status: BundleStatus
+
+    convenience init(id: String, version: String, status: BundleStatus, downloaded: Date, checksum: String) {
+        self.init(id: id, version: version, status: status, downloaded: downloaded.iso8601withFractionalSeconds, checksum: checksum)
+    }
+
+    init(id: String, version: String, status: BundleStatus, downloaded: String = BundleInfo.DOWNLOADED_BUILTIN, checksum: String) {
+        self.downloaded = downloaded.trim()
+        self.id = id
+        self.version = version
+        self.checksum = checksum
+        self.status = status
+    }
+
+    enum CodingKeys: String, CodingKey {
+        case downloaded, id, version, status, checksum
+    }
+
+    public func isBuiltin() -> Bool {
+        return BundleInfo.ID_BUILTIN == self.id
+    }
+
+    public func isUnknown() -> Bool {
+        return BundleInfo.VERSION_UNKNOWN == self.id
+    }
+
+    public func isErrorStatus() -> Bool {
+        return BundleStatus.ERROR == self.status
+    }
+
+    public func isDeleted() -> Bool {
+        return BundleStatus.DELETED == self.status
+    }
+
+    public func isDownloaded() -> Bool {
+        return !self.isBuiltin() && self.downloaded != "" && self.downloaded != BundleInfo.DOWNLOADED_BUILTIN && !self.isDeleted()
+    }
+
+    public func getDownloaded() -> String {
+        return self.isBuiltin() ? BundleInfo.DOWNLOADED_BUILTIN : self.downloaded
+    }
+
+    public func getChecksum() -> String {
+        return self.isBuiltin() ? "" : self.checksum
+    }
+
+    public func setChecksum(checksum: String) -> BundleInfo {
+        return BundleInfo(id: self.id, version: self.version, status: self.status, downloaded: self.downloaded, checksum: checksum)
+    }
+
+    public func setDownloaded(downloaded: Date) -> BundleInfo {
+        return BundleInfo(id: self.id, version: self.version, status: self.status, downloaded: downloaded, checksum: self.checksum)
+    }
+
+    public func getId() -> String {
+        return self.isBuiltin() ? BundleInfo.ID_BUILTIN : self.id
+    }
+
+    public func setId(id: String) -> BundleInfo {
+        return BundleInfo(id: id, version: self.version, status: self.status, downloaded: self.downloaded, checksum: self.checksum)
+    }
+
+    public func getVersionName() -> String {
+        return self.version.isEmpty ? BundleInfo.ID_BUILTIN : self.version
+    }
+
+    public func setVersionName(version: String) -> BundleInfo {
+        return BundleInfo(id: self.id, version: version, status: self.status, downloaded: self.downloaded, checksum: self.checksum)
+    }
+
+    public func getStatus() -> String {
+        return self.isBuiltin() ? BundleStatus.SUCCESS.localizedString : self.status.localizedString
+    }
+
+    public func setStatus(status: String) -> BundleInfo {
+        return BundleInfo(id: self.id, version: self.version, status: BundleStatus(localizedString: status)!, downloaded: self.downloaded, checksum: self.checksum)
+    }
+
+    public func toJSON() -> [String: String] {
+        return [
+            "id": self.getId(),
+            "version": self.getVersionName(),
+            "downloaded": self.getDownloaded(),
+            "checksum": self.getChecksum(),
+            "status": self.getStatus()
+        ]
+    }
+
+    public static func == (lhs: BundleInfo, rhs: BundleInfo) -> Bool {
+        return lhs.getVersionName() == rhs.getVersionName()
+    }
+
+    public func toString() -> String {
+        return "{ \"id\": \"\(self.getId())\", \"version\": \"\(self.getVersionName())\", \"downloaded\": \"\(self.getDownloaded())\", \"checksum\": \"\(self.getChecksum())\", \"status\": \"\(self.getStatus())\"}"
+    }
+}

package/ios/Sources/CapacitorUpdaterPlugin/BundleStatus.swift

@@ -0,0 +1,48 @@
+/*
+ * 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/.
+ */
+
+import Foundation
+
+struct LocalizedString: ExpressibleByStringLiteral, Equatable {
+
+    let v: String
+
+    init(key: String) {
+        self.v = NSLocalizedString(key, comment: "")
+    }
+    init(localized: String) {
+        self.v = localized
+    }
+    init(stringLiteral value: String) {
+        self.init(key: value)
+    }
+    init(extendedGraphemeClusterLiteral value: String) {
+        self.init(key: value)
+    }
+    init(unicodeScalarLiteral value: String) {
+        self.init(key: value)
+    }
+}
+
+func ==(lhs: LocalizedString, rhs: LocalizedString) -> Bool {
+    return lhs.v == rhs.v
+}
+
+enum BundleStatus: LocalizedString, Decodable, Encodable {
+    case SUCCESS = "success"
+    case ERROR = "error"
+    case PENDING  = "pending"
+    case DELETED  = "deleted"
+    case DOWNLOADING  = "downloading"
+
+    var localizedString: String {
+        return self.rawValue.v
+    }
+
+    init?(localizedString: String) {
+        self.init(rawValue: LocalizedString(localized: localizedString))
+    }
+}