@capgo/capacitor-updater 8.51.25 → 8.52.0

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

@@ -15,7 +15,6 @@ import java.io.*;
 import java.io.FileInputStream;
 import java.net.HttpURLConnection;
 import java.net.MalformedURLException;
-import java.net.URL;
 import java.nio.channels.FileChannel;
 import java.security.MessageDigest;
 import java.util.ArrayList;
@@ -35,7 +34,9 @@ import java.util.function.BooleanSupplier;
 import java.util.function.LongConsumer;
 import okhttp3.Call;
 import okhttp3.Callback;
+import okhttp3.CookieJar;
 import okhttp3.Dispatcher;
+import okhttp3.HttpUrl;
 import okhttp3.Interceptor;
 import okhttp3.MediaType;
 import okhttp3.OkHttpClient;
@@ -50,6 +51,14 @@ import org.json.JSONObject;
 
 public class DownloadService extends Worker {
 
+    /** A refused HTTPS to HTTP redirect. Permanent for the given URL, so downloads must not retry it. */
+    static final class BlockedRedirectException extends IOException {
+
+        BlockedRedirectException() {
+            super("Blocked HTTPS to HTTP redirect; set allowHttpsToHttpRedirect to true to allow it");
+        }
+    }
+
     static final class DownloadRetryException extends RuntimeException {
 
         DownloadRetryException(String message) {
@@ -126,6 +135,8 @@ public class DownloadService extends Worker {
     // Match CapgoUpdater.timeout / responseTimeout default (20s). OkHttp's 10s
     // defaults were unused by the plugin config and aborted slow manifest GETs.
     private static volatile int httpTimeoutMs = 20_000;
+    // Off by default: a redirect must never downgrade updater traffic from HTTPS to plain HTTP.
+    private static volatile boolean allowHttpsToHttpRedirect = false;
     private static String currentAppId = "unknown";
     private static String currentPluginVersion = "unknown";
     private static String currentVersionOs = "unknown";
@@ -138,6 +149,9 @@ public class DownloadService extends Worker {
         sharedClient = new OkHttpClient.Builder()
             .dispatcher(dispatcher)
             .protocols(Arrays.asList(Protocol.HTTP_2, Protocol.HTTP_1_1))
+            // Never share cookies with Capgo endpoints: the app's java.net.CookieHandler default is
+            // Capacitor's WebView cookie manager, and it must not see (or be fed by) plugin traffic.
+            .cookieJar(CookieJar.NO_COOKIES)
             .connectTimeout(httpTimeoutMs, TimeUnit.MILLISECONDS)
             .readTimeout(httpTimeoutMs, TimeUnit.MILLISECONDS)
             .writeTimeout(httpTimeoutMs, TimeUnit.MILLISECONDS)
@@ -147,9 +161,33 @@ public class DownloadService extends Worker {
                 Request requestWithUserAgent = originalRequest.newBuilder().header("User-Agent", userAgent).build();
                 return chain.proceed(requestWithUserAgent);
             })
+            .addNetworkInterceptor((chain) -> {
+                Response response = chain.proceed(chain.request());
+                if (!allowHttpsToHttpRedirect && isHttpsToHttpRedirect(response)) {
+                    response.close();
+                    throw new BlockedRedirectException();
+                }
+                return response;
+            })
             .build();
     }
 
+    static void setAllowHttpsToHttpRedirect(boolean allow) {
+        allowHttpsToHttpRedirect = allow;
+    }
+
+    static boolean isHttpsToHttpRedirect(Response response) {
+        if (!response.isRedirect() || !response.request().isHttps()) {
+            return false;
+        }
+        String location = response.header("Location");
+        if (location == null) {
+            return false;
+        }
+        HttpUrl target = response.request().url().resolve(location);
+        return target != null && !target.isHttps();
+    }
+
     static int httpTimeoutMs() {
         return httpTimeoutMs;
     }
@@ -768,20 +806,16 @@ public class DownloadService extends Worker {
             throw new RuntimeException("insufficient_disk_space");
         }
 
-        HttpURLConnection httpConn = null;
+        Response response = null;
         InputStream inputStream = null;
         BufferedReader reader = null;
         BufferedWriter writer = null;
 
         try {
-            URL u = new URL(url);
-            httpConn = (HttpURLConnection) u.openConnection();
-
-            // Zip can stall longer than a JSON API call; keep a floor so
-            // responseTimeout cannot shrink large-bundle downloads.
-            int zipTimeoutMs = Math.max(httpTimeoutMs, 60_000);
-            httpConn.setConnectTimeout(zipTimeoutMs);
-            httpConn.setReadTimeout(zipTimeoutMs);
+            HttpUrl zipUrl = url != null ? HttpUrl.parse(url) : null;
+            if (zipUrl == null) {
+                throw new MalformedURLException("Expected an http or https URL");
+            }
 
             // Reading progress file (if exist)
             long downloadedBytes = 0;
@@ -810,15 +844,16 @@ public class DownloadService extends Worker {
                 throw new DownloadRetryException("download_stopped");
             }
 
-            if (downloadedBytes > 0) {
-                httpConn.setRequestProperty("Range", "bytes=" + downloadedBytes + "-");
-            }
-
-            int responseCode = httpConn.getResponseCode();
+            response = executeZipRequest(zipUrl, downloadedBytes);
+            int responseCode = response.code();
 
             if (responseCode == HttpURLConnection.HTTP_OK || responseCode == HttpURLConnection.HTTP_PARTIAL) {
-                ZipWritePlan writePlan = planZipResumeWrite(responseCode, downloadedBytes, httpConn.getHeaderField("Content-Range"));
-                long responseBodyLength = httpConn.getContentLength();
+                ResponseBody responseBody = response.body();
+                if (responseBody == null) {
+                    throw new IOException("Response body is null");
+                }
+                ZipWritePlan writePlan = planZipResumeWrite(responseCode, downloadedBytes, response.header("Content-Range"));
+                long responseBodyLength = responseBody.contentLength();
                 long contentLength = shouldAppendHttpBody(writePlan.statusCode, writePlan.writeOffset)
                     ? (responseBodyLength >= 0 ? responseBodyLength + writePlan.writeOffset : -1)
                     : responseBodyLength;
@@ -829,7 +864,7 @@ public class DownloadService extends Worker {
                 }
 
                 try {
-                    inputStream = httpConn.getInputStream();
+                    inputStream = responseBody.byteStream();
 
                     if (writePlan.writeOffset == 0 && downloadedBytes == 0) {
                         writer = new BufferedWriter(new FileWriter(infoFile));
@@ -840,7 +875,7 @@ public class DownloadService extends Worker {
 
                     final int[] lastNotifiedPercent = { 0 };
                     final long totalContentLength = contentLength;
-                    String contentRangeHeader = httpConn.getHeaderField("Content-Range");
+                    String contentRangeHeader = response.header("Content-Range");
                     writeHttpBody(tempFile, inputStream, writePlan.statusCode, writePlan.writeOffset, this::isStopped, (written) -> {
                         int percent = calcTotalPercent(written, totalContentLength);
                         if (percent >= lastNotifiedPercent[0] + 10) {
@@ -908,6 +943,9 @@ public class DownloadService extends Worker {
         } catch (MalformedURLException e) {
             logger.error("Invalid download URL: " + e.getMessage());
             throw new RuntimeException("invalid_url: " + e.getMessage());
+        } catch (BlockedRedirectException e) {
+            logger.error("Download error: " + e.getMessage());
+            throw new RuntimeException("blocked_redirect: " + e.getMessage());
         } catch (IOException e) {
             logger.error("Download error: " + e.getMessage());
             throw new DownloadRetryException(e.getMessage(), e);
@@ -916,14 +954,35 @@ public class DownloadService extends Worker {
             throw new RuntimeException(e.getMessage());
         } finally {
             // Ensure connection is closed
-            if (httpConn != null) {
+            if (response != null) {
                 try {
-                    httpConn.disconnect();
+                    response.close();
                 } catch (Exception ignored) {}
             }
         }
     }
 
+    /**
+     * Zip bundle request on the shared client (no cookies, same User-Agent), resuming from
+     * {@code downloadedBytes} with a Range header. The caller closes the response.
+     */
+    static Response executeZipRequest(HttpUrl url, long downloadedBytes) throws IOException {
+        // Zip can stall longer than a JSON API call; keep a floor so
+        // responseTimeout cannot shrink large-bundle downloads.
+        int zipTimeoutMs = Math.max(httpTimeoutMs, 60_000);
+        OkHttpClient zipClient = sharedClient
+            .newBuilder()
+            .connectTimeout(zipTimeoutMs, TimeUnit.MILLISECONDS)
+            .readTimeout(zipTimeoutMs, TimeUnit.MILLISECONDS)
+            .writeTimeout(zipTimeoutMs, TimeUnit.MILLISECONDS)
+            .build();
+        Request.Builder builder = new Request.Builder().url(url);
+        if (downloadedBytes > 0) {
+            builder.header("Range", "bytes=" + downloadedBytes + "-");
+        }
+        return zipClient.newCall(builder.build()).execute();
+    }
+
     static boolean isRetryableHttpStatus(int responseCode) {
         return responseCode >= 500 || responseCode == 408 || responseCode == 429;
     }

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

@@ -0,0 +1,306 @@
+/*
+ * 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/.
+ *
+ * Parsing and comparison logic ported from version-compare 1.5.0
+ * (https://github.com/G00fY2/version-compare), Copyright G00fY2,
+ * licensed under the Apache License, Version 2.0
+ * (https://www.apache.org/licenses/LICENSE-2.0).
+ */
+
+package ee.forgr.capacitor_updater;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+
+/**
+ * Lenient version parser and comparator.
+ *
+ * <p>Behavior-compatible port of {@code io.github.g00fy2:versioncompare:1.5.0} (Apache-2.0), kept in-repo so the
+ * plugin does not ship an extra third-party dependency. Parsing never throws for non-null input that starts with a
+ * digit; unparsable input (null or not starting with a digit) yields an empty version equal to {@code 0}.
+ *
+ * <p>Pre-release suffix ordering: {@code snapshot < pre-alpha < alpha < beta < rc < stable}, with an optional number
+ * right after the qualifier ({@code 1.0.0-rc2 > 1.0.0-rc1}).
+ */
+public class Version implements Comparable<Version> {
+
+    enum ReleaseType {
+        SNAPSHOT,
+        PRE_ALPHA,
+        ALPHA,
+        BETA,
+        RC,
+        STABLE
+    }
+
+    private static final String SNAPSHOT_STRING = "snapshot";
+    private static final String PRE_STRING = "pre";
+    private static final String ALPHA_STRING = "alpha";
+    private static final String BETA_STRING = "beta";
+    private static final String RC_STRING = "rc";
+
+    @Nullable
+    private final String originalString;
+
+    private final List<Long> subversionNumbers = new ArrayList<>();
+    private final List<Long> trimmedSubversionNumbers = new ArrayList<>();
+    private final String suffix;
+    private final ReleaseType releaseType;
+    private final long preReleaseVersion;
+
+    public Version(@Nullable String versionString) {
+        originalString = versionString;
+        if (originalString != null && startsNumeric(originalString)) {
+            String[] versionTokens = originalString.replaceAll("\\s", "").split("\\.");
+            boolean suffixFound = false;
+            StringBuilder suffixSb = null;
+
+            for (String versionToken : versionTokens) {
+                if (suffixFound) {
+                    suffixSb.append(".");
+                    suffixSb.append(versionToken);
+                } else if (isNumeric(versionToken)) {
+                    subversionNumbers.add(safeParseLong(versionToken));
+                } else {
+                    for (int i = 0; i < versionToken.length(); i++) {
+                        if (!Character.isDigit(versionToken.charAt(i))) {
+                            suffixSb = new StringBuilder();
+                            if (i > 0) {
+                                subversionNumbers.add(safeParseLong(versionToken.substring(0, i)));
+                                suffixSb.append(versionToken.substring(i));
+                            } else {
+                                suffixSb.append(versionToken);
+                            }
+                            suffixFound = true;
+                            break;
+                        }
+                    }
+                }
+            }
+            suffix = (suffixSb != null) ? suffixSb.toString() : "";
+            trimmedSubversionNumbers.addAll(subversionNumbers);
+            while (!trimmedSubversionNumbers.isEmpty() && trimmedSubversionNumbers.get(trimmedSubversionNumbers.size() - 1) == 0L) {
+                trimmedSubversionNumbers.remove(trimmedSubversionNumbers.size() - 1);
+            }
+        } else {
+            suffix = "";
+        }
+        releaseType = qualifierToReleaseType(suffix);
+        preReleaseVersion = preReleaseVersion(suffix, releaseType);
+    }
+
+    public long getMajor() {
+        return trimmedSubversionNumbers.size() > 0 ? trimmedSubversionNumbers.get(0) : 0L;
+    }
+
+    public long getMinor() {
+        return trimmedSubversionNumbers.size() > 1 ? trimmedSubversionNumbers.get(1) : 0L;
+    }
+
+    public long getPatch() {
+        return trimmedSubversionNumbers.size() > 2 ? trimmedSubversionNumbers.get(2) : 0L;
+    }
+
+    @NonNull
+    public List<Long> getSubversionNumbers() {
+        return subversionNumbers;
+    }
+
+    @NonNull
+    public String getSuffix() {
+        return suffix;
+    }
+
+    @Nullable
+    public String getOriginalString() {
+        return originalString;
+    }
+
+    public boolean isHigherThan(String otherVersion) {
+        return isHigherThan(new Version(otherVersion));
+    }
+
+    public boolean isHigherThan(Version otherVersion) {
+        return compareTo(otherVersion) > 0;
+    }
+
+    public boolean isLowerThan(String otherVersion) {
+        return isLowerThan(new Version(otherVersion));
+    }
+
+    public boolean isLowerThan(Version otherVersion) {
+        return compareTo(otherVersion) < 0;
+    }
+
+    public boolean isEqual(String otherVersion) {
+        return isEqual(new Version(otherVersion));
+    }
+
+    public boolean isEqual(Version otherVersion) {
+        return compareTo(otherVersion) == 0;
+    }
+
+    public boolean isAtLeast(String otherVersion) {
+        return isAtLeast(new Version(otherVersion));
+    }
+
+    public boolean isAtLeast(Version otherVersion) {
+        return compareTo(otherVersion) >= 0;
+    }
+
+    public boolean isAtLeast(String otherVersion, boolean ignoreSuffix) {
+        return isAtLeast(new Version(otherVersion), ignoreSuffix);
+    }
+
+    public boolean isAtLeast(Version otherVersion, boolean ignoreSuffix) {
+        return compareTo(otherVersion, ignoreSuffix) >= 0;
+    }
+
+    @Override
+    public final int compareTo(@NonNull Version version) {
+        return compareTo(version, false);
+    }
+
+    private int compareTo(@NonNull Version version, boolean ignoreSuffix) {
+        int versionNumberResult = compareSubversionNumbers(trimmedSubversionNumbers, version.trimmedSubversionNumbers);
+        if (versionNumberResult != 0 || ignoreSuffix) {
+            return versionNumberResult;
+        }
+        int releaseTypeResult = releaseType.compareTo(version.releaseType);
+        if (releaseTypeResult != 0) {
+            return releaseTypeResult;
+        }
+        return Long.compare(preReleaseVersion, version.preReleaseVersion);
+    }
+
+    @Override
+    public final boolean equals(Object o) {
+        return o instanceof Version && isEqual((Version) o);
+    }
+
+    @Override
+    public final int hashCode() {
+        int result = trimmedSubversionNumbers.hashCode();
+        result = 31 * result + releaseType.hashCode();
+        result = 31 * result + (int) (preReleaseVersion ^ (preReleaseVersion >>> 32));
+        return result;
+    }
+
+    @NonNull
+    @Override
+    public String toString() {
+        return String.valueOf(originalString);
+    }
+
+    // helpers
+
+    private static int compareSubversionNumbers(@NonNull final List<Long> versionNumbersA, @NonNull final List<Long> versionNumbersB) {
+        final int numbersSizeA = versionNumbersA.size();
+        final int numbersSizeB = versionNumbersB.size();
+        final int maxSize = Math.max(numbersSizeA, numbersSizeB);
+
+        for (int i = 0; i < maxSize; i++) {
+            final long a = i < numbersSizeA ? versionNumbersA.get(i) : 0L;
+            final long b = i < numbersSizeB ? versionNumbersB.get(i) : 0L;
+            if (a > b) {
+                return 1;
+            } else if (a < b) {
+                return -1;
+            }
+        }
+        return 0;
+    }
+
+    static ReleaseType qualifierToReleaseType(@NonNull String suffix) {
+        if (suffix.length() > 0) {
+            suffix = suffix.toLowerCase(Locale.ROOT);
+            if (suffix.contains(RC_STRING)) return ReleaseType.RC;
+            if (suffix.contains(BETA_STRING)) return ReleaseType.BETA;
+            if (suffix.contains(ALPHA_STRING)) {
+                if (suffix.substring(0, suffix.indexOf(ALPHA_STRING)).contains(PRE_STRING)) {
+                    return ReleaseType.PRE_ALPHA;
+                }
+                return ReleaseType.ALPHA;
+            }
+            if (suffix.contains(SNAPSHOT_STRING)) return ReleaseType.SNAPSHOT;
+        }
+        return ReleaseType.STABLE;
+    }
+
+    private static long preReleaseVersion(@NonNull final String suffix, final ReleaseType releaseType) {
+        if (releaseType == ReleaseType.STABLE || releaseType == ReleaseType.SNAPSHOT) return 0;
+
+        final int startIndex = indexOfQualifier(suffix, releaseType);
+        if (startIndex < suffix.length()) {
+            final int maxStartIndex = Math.min(startIndex + 2, suffix.length());
+            if (containsNumeric(suffix.substring(startIndex, maxStartIndex))) {
+                final StringBuilder versionNumber = new StringBuilder();
+                for (int i = startIndex; i < suffix.length(); i++) {
+                    final char c = suffix.charAt(i);
+                    if (Character.isDigit(c)) {
+                        versionNumber.append(c);
+                    } else if (i != startIndex) {
+                        break;
+                    }
+                }
+                return safeParseLong(versionNumber.toString());
+            }
+        }
+        return 0;
+    }
+
+    private static int indexOfQualifier(@NonNull String suffix, final ReleaseType releaseType) {
+        suffix = suffix.toLowerCase(Locale.ROOT);
+        switch (releaseType) {
+            case RC:
+                return suffix.indexOf(RC_STRING) + RC_STRING.length();
+            case BETA:
+                return suffix.indexOf(BETA_STRING) + BETA_STRING.length();
+            case ALPHA:
+            case PRE_ALPHA:
+                return suffix.indexOf(ALPHA_STRING) + ALPHA_STRING.length();
+            default:
+                return 0;
+        }
+    }
+
+    private static boolean startsNumeric(@NonNull String str) {
+        str = str.trim();
+        return str.length() > 0 && Character.isDigit(str.charAt(0));
+    }
+
+    private static long safeParseLong(@NonNull String numbers) {
+        if (numbers.length() > 19) {
+            numbers = numbers.substring(0, 19);
+        }
+        return Long.parseLong(numbers);
+    }
+
+    private static boolean isNumeric(@NonNull final CharSequence cs) {
+        final int sz = cs.length();
+        if (sz > 0) {
+            for (int i = 0; i < sz; i++) {
+                if (!Character.isDigit(cs.charAt(i))) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+
+    private static boolean containsNumeric(@NonNull final CharSequence cs) {
+        final int sz = cs.length();
+        for (int i = 0; i < sz; i++) {
+            if (Character.isDigit(cs.charAt(i))) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

package/dist/docs.json

@@ -4947,6 +4947,22 @@
           "complexTypes": [],
           "type": "boolean | undefined"
         },
+        {
+          "name": "allowHttpsToHttpRedirect",
+          "tags": [
+            {
+              "text": "false",
+              "name": "default"
+            },
+            {
+              "text": "8.52.0",
+              "name": "since"
+            }
+          ],
+          "docs": "Allow the plugin to follow redirects from HTTPS to plain HTTP for its own network requests\n(update checks, stats, channel calls, and bundle/manifest downloads).\n\nBlocked by default so a redirect can never downgrade updater traffic to an unencrypted connection.\nOnly enable this if your self-hosted update server or CDN must redirect to an HTTP URL.\nDirect HTTP URLs (for example `localApi` during development) are not affected.\n\nOnly available for Android and iOS.",
+          "complexTypes": [],
+          "type": "boolean | undefined"
+        },
         {
           "name": "allowModifyAppId",
           "tags": [

package/dist/esm/definitions.d.ts

@@ -264,6 +264,20 @@ declare module '@capacitor/cli' {
              * @since  5.4.0
              */
             allowModifyUrl?: boolean;
+            /**
+             * Allow the plugin to follow redirects from HTTPS to plain HTTP for its own network requests
+             * (update checks, stats, channel calls, and bundle/manifest downloads).
+             *
+             * Blocked by default so a redirect can never downgrade updater traffic to an unencrypted connection.
+             * Only enable this if your self-hosted update server or CDN must redirect to an HTTP URL.
+             * Direct HTTP URLs (for example `localApi` during development) are not affected.
+             *
+             * Only available for Android and iOS.
+             *
+             * @default false
+             * @since  8.52.0
+             */
+            allowHttpsToHttpRedirect?: boolean;
             /**
              * Allow the plugin to modify the appId dynamically from the JavaScript side.
              *