@capgo/capacitor-updater 8.0.1 → 8.2.0

package/ios/{Plugin → Sources/CapacitorUpdaterPlugin}/InternalUtils.swift

@@ -67,6 +67,51 @@ extension GetChannel {
         return dict
     }
 }
+struct ChannelInfo: Codable {
+    let id: String?
+    let name: String?
+    let `public`: Bool?
+    let allow_self_set: Bool?
+}
+struct ListChannelsDec: Decodable {
+    let channels: [ChannelInfo]?
+    let error: String?
+
+    init(from decoder: Decoder) throws {
+        let container = try decoder.singleValueContainer()
+
+        if let channelsArray = try? container.decode([ChannelInfo].self) {
+            // Backend returns direct array
+            self.channels = channelsArray
+            self.error = nil
+        } else {
+            // Handle error response
+            let errorContainer = try decoder.container(keyedBy: CodingKeys.self)
+            self.channels = nil
+            self.error = try? errorContainer.decode(String.self, forKey: .error)
+        }
+    }
+
+    private enum CodingKeys: String, CodingKey {
+        case error
+    }
+}
+public class ListChannels: NSObject {
+    var channels: [[String: Any]] = []
+    var error: String = ""
+}
+extension ListChannels {
+    func toDict() -> [String: Any] {
+        var dict: [String: Any] = [String: Any]()
+        let otherSelf: Mirror = Mirror(reflecting: self)
+        for child: Mirror.Child in otherSelf.children {
+            if let key: String = child.label {
+                dict[key] = child.value
+            }
+        }
+        return dict
+    }
+}
 struct InfoObject: Codable {
     let platform: String?
     let device_id: String?
@@ -83,6 +128,7 @@ struct InfoObject: Codable {
     var action: String?
     var channel: String?
     var defaultChannel: String?
+    var key_id: String?
 }
 
 public struct ManifestEntry: Codable {
@@ -112,8 +158,12 @@ struct AppVersionDec: Decodable {
     let error: String?
     let session_key: String?
     let major: Bool?
+    let breaking: Bool?
     let data: [String: String]?
     let manifest: [ManifestEntry]?
+    let link: String?
+    let comment: String?
+    // The HTTP status code is captured separately in CapgoUpdater; this struct only mirrors JSON.
 }
 
 public class AppVersion: NSObject {
@@ -124,8 +174,12 @@ public class AppVersion: NSObject {
     var error: String?
     var sessionKey: String?
     var major: Bool?
+    var breaking: Bool?
     var data: [String: String]?
     var manifest: [ManifestEntry]?
+    var link: String?
+    var comment: String?
+    var statusCode: Int = 0
 }
 
 extension AppVersion {

package/ios/Sources/CapacitorUpdaterPlugin/Logger.swift

@@ -0,0 +1,310 @@
+import Capacitor
+import Foundation
+import os.log
+import WebKit
+
+public class Logger {
+    public enum LogLevel: Int {
+        case silent = 0
+        case error
+        case warn
+        case info
+        case debug
+
+        public static subscript(_ str: String) -> LogLevel? {
+            var index = 0
+
+            while let item = LogLevel(rawValue: index) {
+                if str == "\(item)" {
+                    return item
+                }
+
+                index += 1
+            }
+
+            return nil
+        }
+
+        public func asOSLogType() -> OSLogType {
+            switch self {
+            case .debug:
+                return OSLogType.debug
+            case .info:
+                return OSLogType.info
+            case .warn:
+                return OSLogType.default
+            case .error:
+                return OSLogType.error
+            case .silent:
+                return OSLogType.info // Compiler wants this, it will never be used
+            }
+        }
+        public func asString() -> String {
+            switch self {
+            case .debug:
+                return "debug"
+            case .info:
+                return "info"
+            case .warn:
+                return "warn"
+            case .error:
+                return "error"
+            case .silent:
+                return "info"
+            }
+        }
+    }
+
+    public struct Options {
+        public var level: LogLevel
+        public var labels: [String: String]
+        public var useSyslog: Bool
+
+        public init(level: LogLevel = LogLevel.info, labels: [String: String] = [:], useSyslog: Bool = false) {
+            self.level = level
+            self.labels = labels
+            self.useSyslog = useSyslog
+        }
+    }
+
+    private var _labels: [LogLevel: String] = [
+        LogLevel.silent: "",
+        LogLevel.error: "🔴",
+        LogLevel.warn: "🟠",
+        LogLevel.info: "🟢",
+        LogLevel.debug: "🔎"
+    ]
+
+    public var labels: [String: String] {
+        get {
+            var result: [String: String] = [:]
+
+            for (level, label) in _labels {
+                result[String(describing: level)] = label
+            }
+
+            return result
+        }
+
+        set {
+            for (level, label) in newValue {
+                if let logLevel = LogLevel[level] {
+                    _labels[logLevel] = label
+                }
+            }
+        }
+    }
+
+    public var level = LogLevel.info
+
+    public var levelName: String {
+        get {
+            String(describing: level)
+        }
+        set {
+            if let newLevel = LogLevel[newValue] {
+                level = newLevel
+            }
+        }
+    }
+
+    private var _tag = ""
+
+    public var tag: String {
+        get {
+            _tag
+        }
+        set {
+            if !newValue.isEmpty {
+                _tag = newValue
+            }
+        }
+    }
+
+    private let kDefaultTimerLabel = "default"
+    private var timers: [String: Date] = [:]
+    public var useSyslog = false
+    public var webView: WKWebView?
+
+    public func setWebView(webView: WKWebView) {
+        self.webView = webView
+    }
+
+    public init(
+        withTag tag: String,
+        config: InstanceConfiguration? = nil,
+        options: Options? = nil
+    ) {
+        self.tag = tag
+        if let config = config {
+            // The logger plugin's name is LoggerBridge, we want to look at the config
+            // named "Logger", so we can't use plugin.getConfigValue().
+            if let configLevel = getConfigValue("level", from: config) as? String,
+               let logLevel = LogLevel[configLevel] {
+                level = logLevel
+            }
+
+            if let configLabels = getConfigValue("labels", from: config) as? [String: String] {
+                labels = configLabels
+            }
+
+            if let configSyslog = getConfigValue("useSyslog", from: config) as? Bool {
+                useSyslog = configSyslog
+            }
+        }
+
+        if let options = options {
+            self.level = options.level
+            self.labels = options.labels
+            self.useSyslog = options.useSyslog
+        }
+    }
+
+    private func getConfigValue(_ configKey: String, from config: InstanceConfiguration) -> Any? {
+        if let config = config.pluginConfigurations as? JSObject {
+            return config[keyPath: KeyPath(stringLiteral: "Logger.\(configKey)")]
+        }
+
+        return nil
+    }
+
+    public func error(_ message: String) {
+        log(atLevel: LogLevel.error, message: message)
+    }
+
+    public func warn(_ message: String) {
+        log(atLevel: LogLevel.warn, message: message)
+    }
+
+    public func info(_ message: String) {
+        log(atLevel: LogLevel.info, message: message)
+    }
+
+    public func log(_ message: String) {
+        log(atLevel: LogLevel.info, message: message)
+    }
+
+    public func debug(_ message: String) {
+        log(atLevel: LogLevel.debug, message: message)
+    }
+
+    public func dir(_ value: Any?) {
+        // Check the log level here to avoid conversion to string
+        if canLog(atLevel: LogLevel.info) {
+            log(atLevel: LogLevel.info, message: String(describing: value))
+        }
+    }
+
+    public func log(atLevel level: LogLevel, message: String) {
+        // This will never fail, but we have to keep swift happy
+        if let label = _labels[level] {
+            log(atLevel: level, label: label, tag: tag, message: message)
+            if let webView = self.webView {
+                DispatchQueue.main.async {
+                    let combined = "\(label) \(self.tag) : \(message)"
+                    let jsArg = self.toJSStringLiteral(combined)
+                    webView.evaluateJavaScript("console.\(level.asString())(\(jsArg))", completionHandler: nil)
+                }
+            }
+        }
+    }
+
+    private func toJSStringLiteral(_ value: String) -> String {
+        // Prefer JSON encoding to produce a valid JS string literal
+        if let data = try? JSONEncoder().encode(value),
+           let encoded = String(data: data, encoding: .utf8) {
+            return encoded
+        }
+
+        // Fallback manual escaping (unlikely to be used)
+        var s = value
+        s = s.replacingOccurrences(of: "\\", with: "\\\\")
+        s = s.replacingOccurrences(of: "\"", with: "\\\"")
+        s = s.replacingOccurrences(of: "'", with: "\\'")
+        s = s.replacingOccurrences(of: "\n", with: "\\n")
+        s = s.replacingOccurrences(of: "\r", with: "\\r")
+        s = s.replacingOccurrences(of: "\u{2028}", with: "\\u2028")
+        s = s.replacingOccurrences(of: "\u{2029}", with: "\\u2029")
+        return "\"\(s)\""
+    }
+
+    public func log(atLevel level: LogLevel, label: String?, tag: String, message: String) {
+        // This will never fail, but we have to keep swift happy
+        if let label = label ?? _labels[level] {
+            print(atLevel: level, label: label, tag: tag, message: message)
+            // eval
+        }
+    }
+
+    private func canLog(atLevel level: LogLevel) -> Bool {
+        self.level.rawValue >= level.rawValue
+    }
+
+    private func print(atLevel level: LogLevel, label: String, tag: String, message: String) {
+        guard canLog(atLevel: level) else {
+            return
+        }
+
+        var msg = message
+
+        if !label.isEmpty {
+            // If the label is ASCII, put it after the tag, otherwise before.
+            if label[label.startIndex].isASCII {
+                msg = "[\(tag)] \(label): \(message)"
+            } else {
+                msg = "\(label) [\(tag)]: \(message)"
+            }
+        } else {
+            msg = "[\(tag)]: \(message)"
+        }
+
+        if useSyslog {
+            os_log("%{public}@", type: level.asOSLogType(), msg)
+        } else {
+            Swift.print(msg)
+        }
+    }
+
+    public func time(_ label: String?) {
+        timers[label ?? ""] = Date()
+    }
+
+    public func timeLog(_ label: String?) {
+        if let timer = timers[label ?? ""] {
+            info(formatTimeInterval(timer.timeIntervalSinceNow))
+        } else {
+            warn("timer \(label ?? kDefaultTimerLabel) does not exist")
+        }
+    }
+
+    public func timeEnd(_ label: String?) {
+        timeLog(label)
+        timers.removeValue(forKey: label ?? kDefaultTimerLabel)
+    }
+
+    private func formatTimeInterval(_ interval: TimeInterval) -> String {
+        let int = Int(interval)
+        let millis = Int(((1 + interval.remainder(dividingBy: 1)) * 1000).rounded())
+        let seconds = int % 60
+        let minutes = (int / 60) % 60
+        let hours = (int / 3600)
+
+        if seconds < 1 {
+            return "\(millis)ms"
+        }
+
+        if minutes < 1 {
+            return "\(seconds).\(String(format: "%0.3d", millis))s"
+        }
+
+        if hours < 1 {
+            return "\(minutes):\(String(format: "%0.2d", seconds)).\(String(format: "%0.3d", millis)) (min:sec.ms)"
+        }
+
+        return "\(hours):\(String(format: "%0.2d", minutes)):\(String(format: "%0.2d", seconds)) (hr:min:sec)"
+    }
+
+    public func trace() {
+        info(String(format: "%@", Thread.callStackSymbols))
+    }
+}

package/ios/Sources/CapacitorUpdaterPlugin/RSA.swift

@@ -0,0 +1,274 @@
+import BigInt
+import Foundation
+import CommonCrypto
+import CryptoKit
+
+///
+/// Constants
+///
+private enum RSAConstants {
+    static let rsaKeySizeInBits: NSNumber = 2048
+    static let rsaAlgorithm: SecKeyAlgorithm = .rsaEncryptionOAEPSHA256
+}
+
+// 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 RSA public key.
+///
+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)
+    }
+
+    ///
+    /// 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 {
+            return nil
+        }
+
+        guard bytes[index] == 0x02 else {
+            return nil
+        }
+        index += 1
+
+        // Get exponent length
+        if index >= bytes.count {
+            return nil
+        }
+
+        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 {
+            return nil
+        }
+
+        let exponentData = Data(bytes[index..<(index + exponentLength)])
+        return ManualRSAPublicKey(modulus: modulusData, exponent: exponentData)
+    }
+
+    // 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)
+        }
+        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 {
+            return nil
+        }
+
+        // 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)
+        }
+    }
+}