@capgo/capacitor-updater 8.51.8 → 8.51.10

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

@@ -146,7 +146,7 @@ public class CapacitorUpdaterPlugin extends Plugin {
     static final int APPLICATION_EXIT_REASON_USER_REQUESTED = 10;
     static final int APPLICATION_EXIT_REASON_DEPENDENCY_DIED = 12;
 
-    private final String pluginVersion = "8.51.8";
+    private final String pluginVersion = "8.51.10";
     private static final String DELAY_CONDITION_PREFERENCES = "";
 
     private SharedPreferences.Editor editor;

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

@@ -449,7 +449,7 @@ public class CapgoUpdater {
                 continue;
             }
             try {
-                copyFile(file, cacheFile);
+                copyFileAtomically(file, cacheFile);
             } catch (IOException e) {
                 logger.debug("Delta cache copy failed: " + file.getPath());
             }
@@ -475,7 +475,7 @@ public class CapgoUpdater {
 
     private void copyFile(final File source, final File dest) throws IOException {
         try (final FileInputStream input = new FileInputStream(source); final FileOutputStream output = new FileOutputStream(dest)) {
-            final byte[] buffer = new byte[1024 * 1024];
+            final byte[] buffer = new byte[CryptoCipher.copyBufferBytes()];
             int length;
             while ((length = input.read(buffer)) != -1) {
                 output.write(buffer, 0, length);
@@ -515,28 +515,74 @@ public class CapgoUpdater {
             return false;
         }
 
-        final File builtinFile = new File(this.activity.getFilesDir(), "public/" + fileName);
-        if (verifyChecksum(builtinFile, fileHash)) {
+        if (DownloadService.builtinAssetMatches(this.activity.getAssets(), fileName, fileHash)) {
             return true;
         }
 
+        try {
+            final File builtinFile = DownloadService.resolveManifestBuiltinFile(new File(this.activity.getFilesDir(), "public"), fileName);
+            if (verifyChecksum(builtinFile, fileHash)) {
+                return true;
+            }
+        } catch (IOException ignored) {
+            // Invalid path; fall through to cache lookup.
+        }
+
         final boolean isBrotli = fileName.endsWith(".br");
         final String fileNameWithoutPath = new File(fileName).getName();
         final String cacheBaseName = isBrotli ? fileNameWithoutPath.substring(0, fileNameWithoutPath.length() - 3) : fileNameWithoutPath;
-        final File cacheFolder = new File(this.activity.getCacheDir(), "capgo_downloads");
-        final File cacheFile = new File(cacheFolder, fileHash + "_" + cacheBaseName);
-        if (verifyChecksum(cacheFile, fileHash)) {
-            return true;
-        }
+        if (isSafeCacheHash(fileHash)) {
+            final File cacheFolder = new File(this.activity.getCacheDir(), "capgo_downloads");
+            final File cacheFile = new File(cacheFolder, fileHash + "_" + cacheBaseName);
+            // Cache files are named `{hash}_{filename}` and were checksum-verified
+            // when written. Re-hashing every hit re-reads the whole bundle and
+            // OOMs/janks low-RAM devices during getMissing / delta apply.
+            if (isReusableCacheFile(cacheFile, fileHash)) {
+                return true;
+            }
 
-        if (isBrotli) {
-            final File legacyCacheFile = new File(cacheFolder, fileHash + "_" + fileNameWithoutPath);
-            return verifyChecksum(legacyCacheFile, fileHash);
+            if (isBrotli) {
+                final File legacyCacheFile = new File(cacheFolder, fileHash + "_" + fileNameWithoutPath);
+                return isReusableCacheFile(legacyCacheFile, fileHash);
+            }
         }
 
         return false;
     }
 
+    static final String EMPTY_SHA256 = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855";
+
+    static boolean isSafeCacheHash(final String hash) {
+        if (hash == null) {
+            return false;
+        }
+        final int len = hash.length();
+        if (len != 64 && len != 8) {
+            return false;
+        }
+        for (int i = 0; i < len; i++) {
+            final char c = hash.charAt(i);
+            if (!((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'))) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    // SHA-256 hash-named cache files were verified when written. Existence is
+    // enough for non-empty files; empty files are reused only for the empty SHA-256.
+    // CRC32 (8 hex) is too collision-prone to trust without a re-read.
+    static boolean isReusableCacheFile(final File file, final String expectedHash) {
+        if (file == null || !file.isFile() || !isSafeCacheHash(expectedHash) || expectedHash.length() != 64) {
+            return false;
+        }
+        final long length = file.length();
+        if (length > 0) {
+            return true;
+        }
+        return length == 0 && EMPTY_SHA256.equalsIgnoreCase(expectedHash);
+    }
+
     public JSONArray getMissingBundleFiles(final JSONArray manifest, final String sessionKey) throws JSONException {
         final JSONArray missing = new JSONArray();
         for (int i = 0; i < manifest.length(); i++) {
@@ -1171,19 +1217,22 @@ public class CapgoUpdater {
             throw new IOException("Failed to create parent directory: " + parent.getAbsolutePath());
         }
 
-        final File tempFile = new File(parent, dest.getName() + ".capgo_tmp");
-        try (final FileInputStream input = new FileInputStream(source); final FileOutputStream output = new FileOutputStream(tempFile)) {
-            final byte[] buffer = new byte[1024 * 1024];
-            int length;
-            while ((length = input.read(buffer)) != -1) {
-                output.write(buffer, 0, length);
+        final File tempFile = File.createTempFile("capgo-", ".tmp", parent);
+        try {
+            try (
+                final FileInputStream input = new FileInputStream(source);
+                final FileOutputStream output = new FileOutputStream(tempFile)
+            ) {
+                final byte[] buffer = new byte[CryptoCipher.copyBufferBytes()];
+                int length;
+                while ((length = input.read(buffer)) != -1) {
+                    output.write(buffer, 0, length);
+                }
             }
-        }
-
-        if (!tempFile.renameTo(dest)) {
-            if (!dest.delete() || !tempFile.renameTo(dest)) {
+            CryptoCipher.replaceFile(tempFile, dest);
+        } finally {
+            if (tempFile.exists()) {
                 tempFile.delete();
-                throw new IOException("Failed to replace file: " + dest.getAbsolutePath());
             }
         }
     }

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

@@ -12,12 +12,13 @@ package ee.forgr.capacitor_updater;
  * references: http://stackoverflow.com/questions/12471999/rsa-encryption-decryption-in-android
  */
 import android.util.Base64;
-import java.io.BufferedInputStream;
-import java.io.DataInputStream;
+import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
+import java.io.FileReader;
 import java.io.IOException;
+import java.io.InputStream;
 import java.security.GeneralSecurityException;
 import java.security.InvalidAlgorithmParameterException;
 import java.security.InvalidKeyException;
@@ -157,26 +158,52 @@ public class CryptoCipher {
             byte[] decryptedSessionKey = CryptoCipher.decryptRSA(sessionKey, pKey);
 
             SecretKey sKey = CryptoCipher.byteToSessionKey(decryptedSessionKey);
-            byte[] content = new byte[(int) file.length()];
-
-            try (
-                final FileInputStream fis = new FileInputStream(file);
-                final BufferedInputStream bis = new BufferedInputStream(fis);
-                final DataInputStream dis = new DataInputStream(bis)
-            ) {
-                dis.readFully(content);
-                dis.close();
-                byte[] decrypted = CryptoCipher.decryptAES(content, sKey, iv);
-                // write the decrypted string to the file
-                try (final FileOutputStream fos = new FileOutputStream(file.getAbsolutePath())) {
-                    fos.write(decrypted);
-                }
-            }
+            decryptAesFile(file, sKey, iv);
         } catch (GeneralSecurityException e) {
             logger.info("decryptFile fail");
-            e.printStackTrace();
-            throw new IOException("GeneralSecurityException");
+            throw new IOException("GeneralSecurityException", e);
+        }
+    }
+
+    static void decryptAesFile(File file, SecretKey key, byte[] iv) throws IOException, GeneralSecurityException {
+        if (file.length() == 0) {
+            throw new IOException("Empty encrypted data");
+        }
+        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
+        cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(key.getEncoded(), "AES"), new IvParameterSpec(iv));
+        File tempFile = File.createTempFile("capgo-aes-", ".tmp", file.getParentFile());
+        try {
+            byte[] inBuf = new byte[ioBufferBytes()];
+            // Reuse one output buffer. cipher.update(in) allocates a new byte[] per chunk
+            // and 64 workers * 5MB was why AES barely won on heap in local benches.
+            byte[] outBuf = new byte[inBuf.length + 16];
+            try (FileInputStream fis = new FileInputStream(file); FileOutputStream fos = new FileOutputStream(tempFile)) {
+                int n;
+                while ((n = fis.read(inBuf)) != -1) {
+                    int outLen = cipher.update(inBuf, 0, n, outBuf, 0);
+                    if (outLen > 0) {
+                        fos.write(outBuf, 0, outLen);
+                    }
+                }
+                int last = cipher.doFinal(outBuf, 0);
+                if (last > 0) {
+                    fos.write(outBuf, 0, last);
+                }
+            }
+            replaceFile(tempFile, file);
+            tempFile = null;
+        } finally {
+            if (tempFile != null && tempFile.exists()) {
+                tempFile.delete();
+            }
+        }
+    }
+
+    static void replaceFile(File from, File to) throws IOException {
+        if (from.renameTo(to)) {
+            return;
         }
+        throw new IOException("Failed to replace file: " + to.getAbsolutePath());
     }
 
     private static byte[] hexStringToByteArray(String s) {
@@ -303,8 +330,87 @@ public class CryptoCipher {
         }
     }
 
+    private static final long TWO_GIB = 2L * 1024 * 1024 * 1024;
+    private static final long THREE_GIB = 3L * 1024 * 1024 * 1024;
+    private static final long FOUR_GIB = 4L * 1024 * 1024 * 1024;
+    private static final long EIGHT_GIB = 8L * 1024 * 1024 * 1024;
+    private static final int FLAGSHIP_IO_BUFFER_BYTES = 5 * 1024 * 1024;
+    private static volatile long cachedPhysicalRamBytes = -1;
+
+    // Checksum and copy share one ladder. 64-wide peak RAM = 64 * buffer.
+    // <2GB: 64KB. <3GB: 256KB. <4GB: 512KB. <8GB: 1MB. Else 5MB (flagship / unknown).
+    static int ioBufferBytes(long physicalRamBytes) {
+        if (physicalRamBytes <= 0) {
+            return FLAGSHIP_IO_BUFFER_BYTES;
+        }
+        if (physicalRamBytes < TWO_GIB) {
+            return 64 * 1024;
+        }
+        if (physicalRamBytes < THREE_GIB) {
+            return 256 * 1024;
+        }
+        if (physicalRamBytes < FOUR_GIB) {
+            return 512 * 1024;
+        }
+        if (physicalRamBytes < EIGHT_GIB) {
+            return 1024 * 1024;
+        }
+        return FLAGSHIP_IO_BUFFER_BYTES;
+    }
+
+    static int checksumBufferBytes(long physicalRamBytes) {
+        return ioBufferBytes(physicalRamBytes);
+    }
+
+    static int copyBufferBytes(long physicalRamBytes) {
+        return ioBufferBytes(physicalRamBytes);
+    }
+
+    static int ioBufferBytes() {
+        return ioBufferBytes(physicalRamBytes());
+    }
+
+    static int checksumBufferBytes() {
+        return ioBufferBytes(physicalRamBytes());
+    }
+
+    static int copyBufferBytes() {
+        return ioBufferBytes(physicalRamBytes());
+    }
+
+    static long physicalRamBytes() {
+        long cached = cachedPhysicalRamBytes;
+        if (cached >= 0) {
+            return cached;
+        }
+        long parsed = 0;
+        try (BufferedReader reader = new BufferedReader(new FileReader("/proc/meminfo"))) {
+            String line = reader.readLine();
+            if (line != null && line.startsWith("MemTotal:")) {
+                String[] parts = line.split("\\s+");
+                if (parts.length >= 2) {
+                    parsed = Long.parseLong(parts[1]) * 1024L;
+                }
+            }
+        } catch (Exception ignored) {
+            parsed = 0;
+        }
+        cachedPhysicalRamBytes = parsed;
+        return parsed;
+    }
+
     public static String calcChecksum(File file) {
-        final int BUFFER_SIZE = 1024 * 1024 * 5; // 5 MB buffer size
+        try (FileInputStream fis = new FileInputStream(file)) {
+            return calcChecksum(fis);
+        } catch (IOException e) {
+            logger.error("Cannot calculate checksum");
+            logger.debug("Path: " + file.getPath() + ", Error: " + e.getMessage());
+            return "";
+        }
+    }
+
+    public static String calcChecksum(InputStream inputStream) {
+        final int BUFFER_SIZE = checksumBufferBytes();
         MessageDigest digest;
         try {
             digest = MessageDigest.getInstance("SHA-256");
@@ -313,10 +419,10 @@ public class CryptoCipher {
             return "";
         }
 
-        try (FileInputStream fis = new FileInputStream(file)) {
+        try {
             byte[] buffer = new byte[BUFFER_SIZE];
             int length;
-            while ((length = fis.read(buffer)) != -1) {
+            while ((length = inputStream.read(buffer)) != -1) {
                 digest.update(buffer, 0, length);
             }
             byte[] hash = digest.digest();
@@ -329,7 +435,7 @@ public class CryptoCipher {
             return hexString.toString();
         } catch (IOException e) {
             logger.error("Cannot calculate checksum");
-            logger.debug("Path: " + file.getPath() + ", Error: " + e.getMessage());
+            logger.debug("Error: " + e.getMessage());
             return "";
         }
     }