@capgo/capacitor-updater 8.51.21 → 8.51.23

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

@@ -363,6 +363,38 @@ public class DownloadService extends Worker {
         return seenTargets.add(targetFile.getCanonicalPath());
     }
 
+    private static final class ManifestDownloadTask {
+
+        final String fileName;
+        final String finalFileHash;
+        final String downloadUrl;
+        final boolean isBrotli;
+        final File targetFile;
+        final File builtinFile;
+        final File cacheFile;
+        final File legacyCacheFile;
+
+        ManifestDownloadTask(
+            final String fileName,
+            final String finalFileHash,
+            final String downloadUrl,
+            final boolean isBrotli,
+            final File targetFile,
+            final File builtinFile,
+            final File cacheFile,
+            final File legacyCacheFile
+        ) {
+            this.fileName = fileName;
+            this.finalFileHash = finalFileHash;
+            this.downloadUrl = downloadUrl;
+            this.isBrotli = isBrotli;
+            this.targetFile = targetFile;
+            this.builtinFile = builtinFile;
+            this.cacheFile = cacheFile;
+            this.legacyCacheFile = legacyCacheFile;
+        }
+    }
+
     static boolean tryCopyBuiltinAsset(final AssetManager assets, final String fileName, final File dest, final String expectedHash) {
         if (assets == null || fileName == null || dest == null) {
             return false;
@@ -424,7 +456,7 @@ public class DownloadService extends Worker {
                     return createFailureResult("Manifest is null");
                 }
             } else {
-                handleSingleFileDownload(url, id, documentsDir, dest, version, sessionKey, checksum);
+                handleSingleFileDownload(url, id, documentsDir, dest, version, sessionKey, checksum, publicKey);
                 return createSuccessResult(dest, version, sessionKey, checksum, false);
             }
         } catch (DownloadRetryException e) {
@@ -515,6 +547,12 @@ public class DownloadService extends Worker {
         try {
             logger.debug("handleManifestDownload");
 
+            if (publicKey != null && !publicKey.isEmpty() && !CryptoCipher.isValidSessionKey(sessionKey)) {
+                logger.error("Public key present but no valid session key provided");
+                sendStatsAsync("session_key_required", version);
+                throw new IOException("Session key required when public key is present");
+            }
+
             // Send stats for manifest download start
             sendStatsAsync("download_manifest_start", version);
 
@@ -535,9 +573,7 @@ public class DownloadService extends Worker {
             int totalFiles = manifest.length();
             final AtomicLong completedFiles = new AtomicLong(0);
             final AtomicBoolean hasError = new AtomicBoolean(false);
-
-            ExecutorService executor = Executors.newFixedThreadPool(Math.min(MANIFEST_MAX_CONCURRENT_FILES, Math.max(1, totalFiles)));
-            List<Future<?>> futures = new ArrayList<>();
+            final List<ManifestDownloadTask> tasks = new ArrayList<>();
             final Set<String> seenTargets = new HashSet<>();
 
             for (int i = 0; i < totalFiles; i++) {
@@ -552,7 +588,13 @@ public class DownloadService extends Worker {
                     continue;
                 }
 
-                if (publicKey != null && !publicKey.isEmpty() && sessionKey != null && !sessionKey.isEmpty()) {
+                if (publicKey != null && !publicKey.isEmpty()) {
+                    if (!CryptoCipher.isValidSessionKey(sessionKey)) {
+                        logger.error("Public key present but no valid session key provided");
+                        sendStatsAsync("session_key_required", version);
+                        hasError.set(true);
+                        continue;
+                    }
                     try {
                         fileHash = CryptoCipher.decryptChecksum(fileHash, publicKey);
                     } catch (Exception e) {
@@ -592,35 +634,56 @@ public class DownloadService extends Worker {
                 final File legacyCacheFile =
                     isBrotli && cacheFile != null ? new File(cacheFolder, finalFileHash + "_" + new File(fileName).getName()) : null;
 
-                // Ensure parent directories of the target file exist
-                if (!Objects.requireNonNull(targetFile.getParentFile()).exists() && !targetFile.getParentFile().mkdirs()) {
-                    logger.error("Failed to create parent directory for: " + targetFile.getAbsolutePath());
-                    hasError.set(true);
-                    continue;
+                tasks.add(
+                    new ManifestDownloadTask(
+                        fileName,
+                        finalFileHash,
+                        downloadUrl,
+                        isBrotli,
+                        targetFile,
+                        builtinFile,
+                        cacheFile,
+                        legacyCacheFile
+                    )
+                );
+            }
+
+            if (hasError.get()) {
+                throw new IOException("Manifest contains invalid or duplicate file paths");
+            }
+
+            for (final ManifestDownloadTask task : tasks) {
+                if (!Objects.requireNonNull(task.targetFile.getParentFile()).exists() && !task.targetFile.getParentFile().mkdirs()) {
+                    logger.error("Failed to create parent directory for: " + task.targetFile.getAbsolutePath());
+                    throw new IOException("Failed to create parent directory for: " + task.targetFile.getAbsolutePath());
                 }
+            }
 
-                final boolean finalIsBrotli = isBrotli;
+            ExecutorService executor = Executors.newFixedThreadPool(Math.min(MANIFEST_MAX_CONCURRENT_FILES, Math.max(1, totalFiles)));
+            List<Future<?>> futures = new ArrayList<>();
+
+            for (final ManifestDownloadTask task : tasks) {
                 Future<?> future = executor.submit(() -> {
                     try {
-                        if (tryCopyBuiltinAsset(assets, fileName, targetFile, finalFileHash)) {
-                            logger.debug("using builtin asset " + fileName);
-                        } else if (tryCopyBuiltinFile(builtinFile, targetFile, finalFileHash)) {
-                            logger.debug("using builtin file " + fileName);
+                        if (tryCopyBuiltinAsset(assets, task.fileName, task.targetFile, task.finalFileHash)) {
+                            logger.debug("using builtin asset " + task.fileName);
+                        } else if (tryCopyBuiltinFile(task.builtinFile, task.targetFile, task.finalFileHash)) {
+                            logger.debug("using builtin file " + task.fileName);
                         } else if (
-                            tryCopyFromCache(cacheFile, targetFile, finalFileHash) ||
-                            (legacyCacheFile != null && tryCopyFromCache(legacyCacheFile, targetFile, finalFileHash))
+                            tryCopyFromCache(task.cacheFile, task.targetFile, task.finalFileHash) ||
+                            (task.legacyCacheFile != null && tryCopyFromCache(task.legacyCacheFile, task.targetFile, task.finalFileHash))
                         ) {
-                            logger.debug("already cached " + fileName);
+                            logger.debug("already cached " + task.fileName);
                         } else {
                             downloadAndVerify(
-                                downloadUrl,
-                                targetFile,
-                                cacheFile,
-                                finalFileHash,
+                                task.downloadUrl,
+                                task.targetFile,
+                                task.cacheFile,
+                                task.finalFileHash,
                                 sessionKey,
                                 publicKey,
-                                finalIsBrotli,
-                                fileName
+                                task.isBrotli,
+                                task.fileName
                             );
                         }
 
@@ -628,8 +691,8 @@ public class DownloadService extends Worker {
                         int percent = calcTotalPercent(completed, totalFiles);
                         setProgress(percent);
                     } catch (Exception e) {
-                        logger.error("Error processing file: " + fileName + " " + e.getMessage());
-                        sendStatsAsync("download_manifest_file_fail", version + ":" + fileName);
+                        logger.error("Error processing file: " + task.fileName + " " + e.getMessage());
+                        sendStatsAsync("download_manifest_file_fail", version + ":" + task.fileName);
                         hasError.set(true);
                     }
                 });
@@ -676,8 +739,20 @@ public class DownloadService extends Worker {
         String dest,
         String version,
         String sessionKey,
-        String checksum
+        String checksum,
+        String publicKey
     ) {
+        if (publicKey != null && !publicKey.isEmpty() && !CryptoCipher.isValidSessionKey(sessionKey)) {
+            logger.error("Public key present but no valid session key provided");
+            sendStatsAsync("session_key_required", version);
+            throw new RuntimeException("Session key required when public key is present");
+        }
+        if (checksum == null || checksum.isEmpty()) {
+            logger.error("No checksum provided");
+            sendStatsAsync("checksum_required", version);
+            throw new RuntimeException("Checksum required");
+        }
+
         // Send stats for zip download start
         sendStatsAsync("download_zip_start", version);
 
@@ -1059,7 +1134,7 @@ public class DownloadService extends Worker {
                 }
             }
 
-            boolean needDecrypt = publicKey != null && !publicKey.isEmpty() && sessionKey != null && !sessionKey.isEmpty();
+            boolean needDecrypt = publicKey != null && !publicKey.isEmpty() && CryptoCipher.isValidSessionKey(sessionKey);
             File source = partial;
             if (needDecrypt) {
                 workFile = new File(cacheFolder, "work_" + UUID.randomUUID() + "_" + targetFile.getName() + ".tmp");

package/ios/Sources/CapacitorUpdaterPlugin/CapacitorUpdaterPlugin.swift

@@ -96,7 +96,7 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
     deinit {
         implementation.shutdown()
     }
-    private let pluginVersion: String = "8.51.21"
+    private let pluginVersion: String = "8.51.23"
     private let launchStartedAtMs = Int64(Date().timeIntervalSince1970 * 1000)
     static let updateUrlDefault = "https://plugin.capgo.app/updates"
     static let statsUrlDefault = "https://plugin.capgo.app/stats"
@@ -582,8 +582,10 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
         var dest: URL
         if BundleInfo.ID_BUILTIN == id {
             dest = Bundle.main.resourceURL!.appendingPathComponent("public")
+        } else if let bundleDir = try? self.implementation.getBundleDirectory(id: id) {
+            dest = bundleDir
         } else {
-            dest = self.implementation.getBundleDirectory(id: id)
+            dest = Bundle.main.resourceURL!.appendingPathComponent("public")
         }
 
         if !FileManager.default.fileExists(atPath: dest.path) {
@@ -1609,7 +1611,19 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
             throw makePreviewError("Invalid download URL")
         }
 
+        if !self.implementation.publicKey.isEmpty && !CryptoCipher.isValidSessionKey(sessionKey) {
+            self.logger.error("Public key present but no valid session key provided")
+            self.implementation.sendStats(action: "session_key_required", versionName: version)
+            throw makePreviewError("Session key required when public key is present")
+        }
+
         var checksum = rawChecksum
+        if manifestEntries == nil && checksum.isEmpty {
+            self.logger.error("No checksum provided")
+            self.implementation.sendStats(action: "checksum_required", versionName: version)
+            throw makePreviewError("Checksum required")
+        }
+
         let next: BundleInfo
         if let manifestEntries = manifestEntries {
             next = try self.implementation.downloadManifest(manifest: manifestEntries, version: version, sessionKey: sessionKey)
@@ -1617,29 +1631,20 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
             next = try self.implementation.download(url: url, version: version, sessionKey: sessionKey)
         }
 
-        if self.implementation.publicKey != "" && checksum == "" {
-            self.logger.error("Public key present but no checksum provided")
-            self.implementation.sendStats(action: "checksum_required", versionName: next.getVersionName())
-            let id = next.getId()
-            let resDel = self.implementation.delete(id: id)
-            if !resDel {
-                self.logger.error("Delete failed, id \(id) doesn't exist")
-            }
-            throw ObjectSavableError.checksum
-        }
-
-        checksum = try CryptoCipher.decryptChecksum(checksum: checksum, publicKey: self.implementation.publicKey)
-        CryptoCipher.logChecksumInfo(label: "Bundle checksum", hexChecksum: next.getChecksum())
-        CryptoCipher.logChecksumInfo(label: "Expected checksum", hexChecksum: checksum)
-        if (checksum != "" || self.implementation.publicKey != "") && next.getChecksum() != checksum {
-            self.logger.error("Error checksum \(next.getChecksum()) \(checksum)")
-            self.implementation.sendStats(action: "checksum_fail", versionName: next.getVersionName())
-            let id = next.getId()
-            let resDel = self.implementation.delete(id: id)
-            if !resDel {
-                self.logger.error("Delete failed, id \(id) doesn't exist")
+        if manifestEntries == nil {
+            checksum = try CryptoCipher.decryptChecksum(checksum: checksum, publicKey: self.implementation.publicKey)
+            CryptoCipher.logChecksumInfo(label: "Bundle checksum", hexChecksum: next.getChecksum())
+            CryptoCipher.logChecksumInfo(label: "Expected checksum", hexChecksum: checksum)
+            if next.getChecksum() != checksum {
+                self.logger.error("Error checksum \(next.getChecksum()) \(checksum)")
+                self.implementation.sendStats(action: "checksum_fail", versionName: next.getVersionName())
+                let id = next.getId()
+                let resDel = self.implementation.delete(id: id)
+                if !resDel {
+                    self.logger.error("Delete failed, id \(id) doesn't exist")
+                }
+                throw ObjectSavableError.checksum
             }
-            throw ObjectSavableError.checksum
         }
 
         self.logger.info("Good checksum \(next.getChecksum()) \(checksum)")
@@ -1691,8 +1696,10 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
         let id = self.implementation.getCurrentBundleId()
         if BundleInfo.ID_BUILTIN == id {
             return Bundle.main.resourceURL!.appendingPathComponent("public")
+        } else if let bundleDir = try? self.implementation.getBundleDirectory(id: id) {
+            return bundleDir
         } else {
-            return self.implementation.getBundleDirectory(id: id)
+            return Bundle.main.resourceURL!.appendingPathComponent("public")
         }
     }
 
@@ -3496,13 +3503,10 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
     }
 
     private func performHideSplashscreen() {
-        self.cancelSplashscreenTimeout()
         self.removeSplashscreenLoader()
         self.splashscreenInvocationToken += 1
-        self.invokeSplashscreenMethod(
-            methodName: "hide",
-            callbackId: "autoHideSplashscreen",
-            options: self.splashscreenOptions(methodName: "hide"),
+        self.invokeSplashscreenAction(
+            .hide,
             retriesRemaining: self.splashscreenMaxRetries,
             requestToken: self.splashscreenInvocationToken
         )
@@ -3522,10 +3526,8 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
         self.cancelSplashscreenTimeout()
         self.autoSplashscreenTimedOut = false
         self.splashscreenInvocationToken += 1
-        self.invokeSplashscreenMethod(
-            methodName: "show",
-            callbackId: "autoShowSplashscreen",
-            options: self.splashscreenOptions(methodName: "show"),
+        self.invokeSplashscreenAction(
+            .show,
             retriesRemaining: self.splashscreenMaxRetries,
             requestToken: self.splashscreenInvocationToken
         )
@@ -3535,7 +3537,7 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
     }
 
     private func splashscreenOptions(methodName: String) -> [String: Any] {
-        methodName == "show" ? ["autoHide": false] : [:]
+        methodName == "show" ? ["autoHide": false, "fadeInDuration": 0] : [:]
     }
 
     private func splashscreenCompletedMessage(methodName: String) -> String {
@@ -3554,20 +3556,59 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
         self.splashscreenInvocationToken += 1
     }
 
-    private func makeSplashscreenCall(callbackId: String, options: [String: Any], methodName: String) -> CAPPluginCall {
-        CAPPluginCall(callbackId: callbackId, methodName: methodName, options: options, success: { [weak self] (_, _) in
-            guard let self = self else { return }
-            self.logger.info(self.splashscreenCompletedMessage(methodName: methodName))
-        }, error: { [weak self] (_) in
-            guard let self = self else { return }
-            self.logger.error("Failed to auto-\(methodName) splashscreen")
-        })
+    private enum SplashscreenAction {
+        case show
+        case hide
+
+        var methodName: String {
+            switch self {
+            case .show:
+                return "show"
+            case .hide:
+                return "hide"
+            }
+        }
+
+        var unavailableMessageVerb: String {
+            switch self {
+            case .show:
+                return "showing"
+            case .hide:
+                return "hiding"
+            }
+        }
     }
 
-    private func invokeSplashscreenMethod(
-        methodName: String,
-        callbackId: String,
-        options: [String: Any],
+    private func splashscreenOptionsJSON(methodName: String) -> String {
+        let options = self.splashscreenOptions(methodName: methodName)
+        guard !options.isEmpty,
+              let data = try? JSONSerialization.data(withJSONObject: options),
+              let json = String(data: data, encoding: .utf8) else {
+            return "{}"
+        }
+        return json
+    }
+
+    private func splashscreenPluginExposesMethod(_ methodName: String, on plugin: CAPPlugin) -> Bool {
+        guard let bridgedPlugin = plugin as? CAPBridgedPlugin else {
+            return false
+        }
+        return bridgedPlugin.pluginMethods.contains { $0.name == methodName }
+    }
+
+    private func splashscreenBridgeScript(for action: SplashscreenAction) -> String {
+        let optionsJSON = self.splashscreenOptionsJSON(methodName: action.methodName)
+        return """
+        var cap = window.Capacitor;
+        if (!cap || typeof cap.nativePromise !== 'function') {
+          throw new Error('Capacitor bridge not ready');
+        }
+        return await cap.nativePromise('\(self.splashscreenPluginName)', '\(action.methodName)', \(optionsJSON));
+        """
+    }
+
+    private func invokeSplashscreenAction(
+        _ action: SplashscreenAction,
         retriesRemaining: Int,
         requestToken: Int
     ) {
@@ -3576,22 +3617,18 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
         }
 
         guard let bridge = self.bridge else {
-            self.retrySplashscreenMethod(
-                methodName: methodName,
-                callbackId: callbackId,
-                options: options,
+            self.retrySplashscreenAction(
+                action,
                 retriesRemaining: retriesRemaining,
                 requestToken: requestToken,
-                message: "Bridge not available for \(methodName == "show" ? "showing" : "hiding") splashscreen with autoSplashscreen"
+                message: "Bridge not available for \(action.unavailableMessageVerb) splashscreen with autoSplashscreen"
             )
             return
         }
 
         guard let splashScreenPlugin = bridge.plugin(withName: self.splashscreenPluginName) else {
-            self.retrySplashscreenMethod(
-                methodName: methodName,
-                callbackId: callbackId,
-                options: options,
+            self.retrySplashscreenAction(
+                action,
                 retriesRemaining: retriesRemaining,
                 requestToken: requestToken,
                 message: "autoSplashscreen: SplashScreen plugin not found. Install @capacitor/splash-screen plugin."
@@ -3599,37 +3636,86 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
             return
         }
 
-        let selector = NSSelectorFromString("\(methodName):")
-        guard splashScreenPlugin.responds(to: selector) else {
-            self.retrySplashscreenMethod(
-                methodName: methodName,
-                callbackId: callbackId,
-                options: options,
+        guard self.splashscreenPluginExposesMethod(action.methodName, on: splashScreenPlugin) else {
+            self.retrySplashscreenAction(
+                action,
+                retriesRemaining: retriesRemaining,
+                requestToken: requestToken,
+                message: "autoSplashscreen: SplashScreen plugin does not expose \(action.methodName)(). Make sure @capacitor/splash-screen plugin is properly installed."
+            )
+            return
+        }
+
+        guard let webView = bridge.webView else {
+            self.retrySplashscreenAction(
+                action,
                 retriesRemaining: retriesRemaining,
                 requestToken: requestToken,
-                message: "autoSplashscreen: SplashScreen plugin does not respond to \(methodName): method. Make sure @capacitor/splash-screen plugin is properly installed."
+                message: "WebView not available for \(action.unavailableMessageVerb) splashscreen with autoSplashscreen"
             )
             return
         }
 
-        let call = self.makeSplashscreenCall(callbackId: callbackId, options: options, methodName: methodName)
-        _ = splashScreenPlugin.perform(selector, with: call)
-        self.logger.info("Called SplashScreen \(methodName) method")
+        let script = self.splashscreenBridgeScript(for: action)
+        let runInvocation = { [weak self] in
+            guard let self = self, requestToken == self.splashscreenInvocationToken else {
+                return
+            }
+            webView.callAsyncJavaScript(
+                script,
+                arguments: [:],
+                in: nil,
+                in: .page
+            ) { [weak self] (result: Result<Any, Error>) in
+                guard let self = self, requestToken == self.splashscreenInvocationToken else {
+                    return
+                }
+                if case .failure(let error) = result {
+                    self.retrySplashscreenAction(
+                        action,
+                        retriesRemaining: retriesRemaining,
+                        requestToken: requestToken,
+                        message: "Failed to invoke SplashScreen \(action.methodName) via Capacitor bridge: \(error.localizedDescription)"
+                    )
+                    return
+                }
+                if action == .hide {
+                    self.cancelSplashscreenTimeout()
+                }
+                self.logger.info("Called SplashScreen \(action.methodName) method")
+                self.logger.info(self.splashscreenCompletedMessage(methodName: action.methodName))
+            }
+        }
+
+        if Thread.isMainThread {
+            runInvocation()
+        } else {
+            DispatchQueue.main.async(execute: runInvocation)
+        }
     }
 
-    private func retrySplashscreenMethod(
-        methodName: String,
-        callbackId: String,
-        options: [String: Any],
+    private func retrySplashscreenAction(
+        _ action: SplashscreenAction,
         retriesRemaining: Int,
         requestToken: Int,
         message: String
     ) {
         guard retriesRemaining > 0 else {
-            if methodName == "show" {
+            if action == .show {
                 self.logger.warn(message)
-            } else {
-                self.logger.error(message)
+                return
+            }
+
+            self.logger.error("\(message). Scheduling another hide retry.")
+            DispatchQueue.main.asyncAfter(deadline: .now() + .milliseconds(self.splashscreenRetryDelayMilliseconds)) { [weak self] in
+                guard let self = self, requestToken == self.splashscreenInvocationToken else {
+                    return
+                }
+                self.invokeSplashscreenAction(
+                    action,
+                    retriesRemaining: self.splashscreenMaxRetries,
+                    requestToken: requestToken
+                )
             }
             return
         }
@@ -3639,10 +3725,8 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
             guard let self = self, requestToken == self.splashscreenInvocationToken else {
                 return
             }
-            self.invokeSplashscreenMethod(
-                methodName: methodName,
-                callbackId: callbackId,
-                options: options,
+            self.invokeSplashscreenAction(
+                action,
                 retriesRemaining: retriesRemaining - 1,
                 requestToken: requestToken
             )
@@ -4095,6 +4179,22 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
         self.updateUrl = updateUrl
     }
 
+    func downloadBundleForTesting(
+        urlString: String,
+        version: String,
+        sessionKey: String,
+        checksum: String,
+        manifestEntries: [ManifestEntry]?
+    ) throws -> BundleInfo {
+        try downloadBundle(
+            urlString: urlString,
+            version: version,
+            sessionKey: sessionKey,
+            checksum: checksum,
+            manifestEntries: manifestEntries
+        )
+    }
+
     func setAutoUpdateModeForTesting(_ autoUpdateMode: String) {
         self.autoUpdateMode = Self.normalizedAutoUpdateMode(autoUpdateMode)
         self.autoUpdate = Self.isAutoUpdateModeEnabled(self.autoUpdateMode)
@@ -4430,6 +4530,17 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
             if latestVersionName != "" && current.getVersionName() != latestVersionName {
                 do {
                     self.logger.info("New bundle: \(latestVersionName) found. Current is: \(current.getVersionName()). \(messageUpdate)")
+                    if !self.implementation.publicKey.isEmpty && !CryptoCipher.isValidSessionKey(sessionKey) {
+                        self.logger.error("Public key present but no valid session key provided")
+                        self.implementation.sendStats(action: "session_key_required", versionName: latestVersionName)
+                        self.endBackGroundTaskWithNotif(
+                            msg: "Session key required when public key is present",
+                            latestVersionName: latestVersionName,
+                            current: current,
+                            plannedDirectUpdate: plannedDirectUpdate
+                        )
+                        return
+                    }
                     var nextImpl = self.implementation.getBundleInfoByVersionName(version: latestVersionName)
                     let needsDownload = nextImpl.map(Self.shouldRetryDownloadForExistingBundle) ?? true
                     if needsDownload {
@@ -4447,6 +4558,17 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
                         if res.manifest != nil {
                             nextImpl = try self.implementation.downloadManifest(manifest: res.manifest!, version: latestVersionName, sessionKey: sessionKey, link: res.link, comment: res.comment)
                         } else {
+                            if res.checksum.isEmpty {
+                                self.logger.error("No checksum provided")
+                                self.implementation.sendStats(action: "checksum_required", versionName: latestVersionName)
+                                self.endBackGroundTaskWithNotif(
+                                    msg: "Checksum required",
+                                    latestVersionName: latestVersionName,
+                                    current: current,
+                                    plannedDirectUpdate: plannedDirectUpdate
+                                )
+                                return
+                            }
                             nextImpl = try self.implementation.download(url: downloadUrl, version: latestVersionName, sessionKey: sessionKey, link: res.link, comment: res.comment)
                         }
                     }
@@ -4475,24 +4597,26 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
                         self.endBackGroundTask()
                         return
                     }
-                    res.checksum = try CryptoCipher.decryptChecksum(checksum: res.checksum, publicKey: self.implementation.publicKey)
-                    CryptoCipher.logChecksumInfo(label: "Bundle checksum", hexChecksum: next.getChecksum())
-                    CryptoCipher.logChecksumInfo(label: "Expected checksum", hexChecksum: res.checksum)
-                    if res.checksum != "" && next.getChecksum() != res.checksum && res.manifest == nil {
-                        self.logger.error("Error checksum \(next.getChecksum()) \(res.checksum)")
-                        self.implementation.sendStats(action: "checksum_fail", versionName: next.getVersionName())
-                        let id = next.getId()
-                        let resDel = self.implementation.delete(id: id)
-                        if !resDel {
-                            self.logger.error("Delete failed, id \(id) doesn't exist")
+                    if res.manifest == nil {
+                        res.checksum = try CryptoCipher.decryptChecksum(checksum: res.checksum, publicKey: self.implementation.publicKey)
+                        CryptoCipher.logChecksumInfo(label: "Bundle checksum", hexChecksum: next.getChecksum())
+                        CryptoCipher.logChecksumInfo(label: "Expected checksum", hexChecksum: res.checksum)
+                        if next.getChecksum() != res.checksum {
+                            self.logger.error("Error checksum \(next.getChecksum()) \(res.checksum)")
+                            self.implementation.sendStats(action: "checksum_fail", versionName: next.getVersionName())
+                            let id = next.getId()
+                            let resDel = self.implementation.delete(id: id)
+                            if !resDel {
+                                self.logger.error("Delete failed, id \(id) doesn't exist")
+                            }
+                            self.endBackGroundTaskWithNotif(
+                                msg: "Error checksum",
+                                latestVersionName: latestVersionName,
+                                current: current,
+                                plannedDirectUpdate: plannedDirectUpdate
+                            )
+                            return
                         }
-                        self.endBackGroundTaskWithNotif(
-                            msg: "Error checksum",
-                            latestVersionName: latestVersionName,
-                            current: current,
-                            plannedDirectUpdate: plannedDirectUpdate
-                        )
-                        return
                     }
                     if self.shouldBlockAutoUpdateForPreviewSession() {
                         self.clearDownloadInProgressState()