@capgo/cordova-updater 8.1.1

package/src/ios/Logger.swift

@@ -0,0 +1,283 @@
+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,
+        options: Options? = nil
+    ) {
+        self.tag = tag
+        if let options = options {
+            self.level = options.level
+            self.labels = options.labels
+            self.useSyslog = options.useSyslog
+        }
+    }
+
+    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 escaped = value
+        escaped = escaped.replacingOccurrences(of: "\\", with: "\\\\")
+        escaped = escaped.replacingOccurrences(of: "\"", with: "\\\"")
+        escaped = escaped.replacingOccurrences(of: "'", with: "\\'")
+        escaped = escaped.replacingOccurrences(of: "\n", with: "\\n")
+        escaped = escaped.replacingOccurrences(of: "\r", with: "\\r")
+        escaped = escaped.replacingOccurrences(of: "\u{2028}", with: "\\u2028")
+        escaped = escaped.replacingOccurrences(of: "\u{2029}", with: "\\u2029")
+        return "\"\(escaped)\""
+    }
+
+    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/src/ios/RSA.swift

@@ -0,0 +1,96 @@
+/*
+ * 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
+import Security
+import os.log
+
+/// 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 key: SecKey
+    private static let keyLock = NSLock()
+    private static let log = OSLog(subsystem: "app.capgo.cordova.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)?
+
+    public static func load(rsaPublicKey: String) -> RSAPublicKey? {
+        guard let der = pemToDer(rsaPublicKey) else {
+            os_log("RSA key import failed: invalid PEM/base64", log: Self.log, type: .error)
+            return nil
+        }
+
+        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
+        }
+        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)
+    }
+
+    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
+        }
+        return Self.unpadSignature(recovered, blockSize: blockSize)
+    }
+
+    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
+        }
+        guard separator >= 10, separator < bytes.count - 1, bytes[separator] == 0 else {
+            return nil
+        }
+        return Data(bytes[(separator + 1)...])
+    }
+
+    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/src/ios/ShakeMenu.swift

@@ -0,0 +1,52 @@
+/*
+ * 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 UIKit
+
+/// Cordova shake menu stub. Full preview/channel shake UI is planned for a follow-up release.
+final class ShakeMenu {
+    private let logger: Logger
+
+    init(plugin: CordovaUpdaterPlugin, viewController: UIViewController?, logger: Logger, gesture: String) {
+        self.logger = logger
+        logger.debug("ShakeMenu: gesture \(gesture) registered (Cordova stub)")
+    }
+
+    func usesGesture(_ gesture: String) -> Bool {
+        false
+    }
+
+    func stop() {
+        // no-op
+    }
+}
+
+extension CordovaUpdaterPlugin {
+    func syncShakeMenuGestureRecognizer() {
+        // Cordova stub: gesture UI not implemented yet
+    }
+
+    func removeShakeMenuGestureRecognizer() {
+        // no-op
+    }
+}
+
+extension UIApplication {
+    class func topViewController(_ base: UIViewController? = UIApplication.shared.connectedScenes
+        .compactMap { ($0 as? UIWindowScene)?.keyWindow }
+        .first?.rootViewController) -> UIViewController? {
+        if let nav = base as? UINavigationController {
+            return topViewController(nav.visibleViewController)
+        }
+        if let tab = base as? UITabBarController, let selected = tab.selectedViewController {
+            return topViewController(selected)
+        }
+        if let presented = base?.presentedViewController {
+            return topViewController(presented)
+        }
+        return base
+    }
+}

package/src/ios/UpdaterSchemeHandler.swift

@@ -0,0 +1,81 @@
+import Foundation
+import WebKit
+
+public class UpdaterSchemeHandler: NSObject {
+    private let activeBundleDirLock = NSLock()
+    private var _activeBundleDir: URL?
+
+    private let activeTasksQueue = DispatchQueue(label: "app.capgo.cordova.updater.schemeHandler")
+    private var activeTasks = Set<URLSchemeTaskWrapper>()
+
+    public var activeBundleDir: URL? {
+        get {
+            activeBundleDirLock.lock()
+            defer { activeBundleDirLock.unlock() }
+            return _activeBundleDir
+        }
+        set {
+            activeBundleDirLock.lock()
+            _activeBundleDir = newValue
+            activeBundleDirLock.unlock()
+        }
+    }
+
+    public func handle(task: WKURLSchemeTask) -> Bool {
+        guard let baseDir = activeBundleDir, let requestURL = task.request.url else {
+            return false
+        }
+        var relativePath = requestURL.path
+        if relativePath.hasPrefix("/") { relativePath = String(relativePath.dropFirst()) }
+        if relativePath.isEmpty || relativePath.hasSuffix("/") { relativePath += "index.html" }
+        let fileURL = baseDir.appendingPathComponent(relativePath).standardizedFileURL
+        let canonicalBase = baseDir.standardizedFileURL.path
+        guard fileURL.path == canonicalBase || fileURL.path.hasPrefix(canonicalBase + "/") else { return false }
+        var isDirectory: ObjCBool = false
+        guard FileManager.default.fileExists(atPath: fileURL.path, isDirectory: &isDirectory), !isDirectory.boolValue else { return false }
+        let wrapper = URLSchemeTaskWrapper(task: task)
+        activeTasksQueue.sync { _ = activeTasks.insert(wrapper) }
+        DispatchQueue.global(qos: .userInitiated).async { [weak self] in
+            self?.serve(task: task, wrapper: wrapper, fileURL: fileURL, requestURL: requestURL)
+        }
+        return true
+    }
+
+    public func stop(task: WKURLSchemeTask) {
+        activeTasksQueue.sync { activeTasks = activeTasks.filter { $0.task !== task } }
+    }
+
+    private func serve(task: WKURLSchemeTask, wrapper: URLSchemeTaskWrapper, fileURL: URL, requestURL: URL) {
+        guard let data = try? Data(contentsOf: fileURL) else {
+            if activeTasksQueue.sync(execute: { activeTasks.contains(wrapper) }) { task.didFailWithError(NSError(domain: "CapgoCordovaUpdater", code: 1)) }
+            activeTasksQueue.sync { _ = activeTasks.remove(wrapper) }
+            return
+        }
+        let headers = ["Content-Type": mimeType(for: fileURL), "Cache-Control": "no-cache", "Content-Length": String(data.count)]
+        guard let response = HTTPURLResponse(url: requestURL, statusCode: 200, httpVersion: "HTTP/1.1", headerFields: headers) else { return }
+        if activeTasksQueue.sync(execute: { activeTasks.contains(wrapper) }) {
+            task.didReceive(response)
+            task.didReceive(data)
+            task.didFinish()
+        }
+        activeTasksQueue.sync { _ = activeTasks.remove(wrapper) }
+    }
+
+    private func mimeType(for url: URL) -> String {
+        switch url.pathExtension.lowercased() {
+        case "js", "mjs": return "application/javascript"
+        case "html", "htm": return "text/html"
+        case "css": return "text/css"
+        case "json": return "application/json"
+        case "wasm": return "application/wasm"
+        default: return "application/octet-stream"
+        }
+    }
+}
+
+private final class URLSchemeTaskWrapper: Hashable {
+    let task: WKURLSchemeTask
+    init(task: WKURLSchemeTask) { self.task = task }
+    static func == (lhs: URLSchemeTaskWrapper, rhs: URLSchemeTaskWrapper) -> Bool { lhs.task === rhs.task }
+    func hash(into hasher: inout Hasher) { hasher.combine(ObjectIdentifier(task as AnyObject)) }
+}

package/src/ios/UserDefaultsExtension.swift

@@ -0,0 +1,46 @@
+/*
+ * 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
+
+protocol ObjectSavable {
+    func setObj<Object>(_ object: Object, forKey: String) throws where Object: Encodable
+    func getObj<Object>(forKey: String, castTo type: Object.Type) throws -> Object where Object: Decodable
+}
+
+enum ObjectSavableError: String, LocalizedError {
+    case unableToEncode = "Unable to encode object into data"
+    case noValue = "No data object found for the given key"
+    case unableToDecode = "Unable to decode object into given type"
+    case checksum = "Checksum failed"
+
+    var errorDescription: String? {
+        rawValue
+    }
+}
+
+extension UserDefaults: ObjectSavable {
+    func setObj<Object>(_ object: Object, forKey: String) throws where Object: Encodable {
+        let encoder: JSONEncoder = JSONEncoder()
+        do {
+            let data: Data = try encoder.encode(object)
+            set(data, forKey: forKey)
+        } catch {
+            throw ObjectSavableError.unableToEncode
+        }
+    }
+
+    func getObj<Object>(forKey: String, castTo type: Object.Type) throws -> Object where Object: Decodable {
+        guard let data: Data = data(forKey: forKey) else { throw ObjectSavableError.noValue }
+        let decoder: JSONDecoder = JSONDecoder()
+        do {
+            let object: Object = try decoder.decode(type, from: data)
+            return object
+        } catch {
+            throw ObjectSavableError.unableToDecode
+        }
+    }
+}