@hot-updater/react-native 1.0.0-rc.4 → 1.0.0-rc.40

package/android/src/main/java/com/hotupdater/TarBrDecompressionStrategy.kt

@@ -1,117 +0,0 @@
-package com.hotupdater
-
-import android.util.Log
-import com.hotupdater.vendor.brotli.dec.BrotliInputStream
-import java.io.BufferedInputStream
-import java.io.File
-import java.io.FileInputStream
-import java.io.FileOutputStream
-
-/**
- * Strategy for handling TAR+Brotli compressed files
- * Uses native Brotli decoder and custom TAR parser
- */
-class TarBrDecompressionStrategy : DecompressionStrategy {
-    companion object {
-        private const val TAG = "TarBrStrategy"
-        private const val MIN_FILE_SIZE = 10L
-    }
-
-    override fun isValid(filePath: String): Boolean {
-        val file = File(filePath)
-
-        if (!file.exists() || file.length() < MIN_FILE_SIZE) {
-            Log.d(TAG, "Invalid file: doesn't exist or too small (${file.length()} bytes)")
-            return false
-        }
-
-        return try {
-            FileInputStream(file).use { fileInputStream ->
-                BufferedInputStream(fileInputStream).use { bufferedInputStream ->
-                    BrotliInputStream(bufferedInputStream).use { brotliInputStream ->
-                        TarArchiveInputStream(brotliInputStream).use { tarInputStream ->
-                            val firstEntry = tarInputStream.getNextEntry()
-                            val isValid = firstEntry != null
-
-                            if (!isValid) {
-                                Log.d(TAG, "Invalid file: tar archive has no entries")
-                            }
-
-                            isValid
-                        }
-                    }
-                }
-            }
-        } catch (e: Exception) {
-            Log.d(TAG, "Invalid file: Brotli/TAR validation failed - ${e.message}")
-            false
-        }
-    }
-
-    override fun decompress(
-        filePath: String,
-        destinationPath: String,
-        progressCallback: (Double) -> Unit,
-    ): Boolean =
-        try {
-            val destinationDir = File(destinationPath)
-            if (!destinationDir.exists()) {
-                destinationDir.mkdirs()
-            }
-
-            val sourceFile = File(filePath)
-            val totalSize = sourceFile.length()
-            var processedBytes = 0L
-
-            Log.d(TAG, "Extracting tar.br file: $filePath")
-
-            FileInputStream(filePath).use { fileInputStream ->
-                BufferedInputStream(fileInputStream).use { bufferedInputStream ->
-                    BrotliInputStream(bufferedInputStream).use { brotliInputStream ->
-                        TarArchiveInputStream(brotliInputStream).use { tarInputStream ->
-                            var entry = tarInputStream.getNextEntry()
-
-                            while (entry != null) {
-                                val file = RelativePathResolver.resolveInside(destinationDir, entry.name)
-
-                                if (file == null) {
-                                    Log.w(TAG, "Skipping potentially malicious tar entry: ${entry.name}")
-                                    entry = tarInputStream.getNextEntry()
-                                    continue
-                                }
-
-                                if (entry.isDirectory) {
-                                    file.mkdirs()
-                                } else {
-                                    file.parentFile?.mkdirs()
-
-                                    FileOutputStream(file).use { output ->
-                                        val buffer = ByteArray(8 * 1024)
-                                        var bytesRead: Int
-
-                                        while (tarInputStream.read(buffer).also { bytesRead = it } != -1) {
-                                            output.write(buffer, 0, bytesRead)
-                                            processedBytes += bytesRead
-                                        }
-                                    }
-                                }
-
-                                val progress = processedBytes.toDouble() / (totalSize * 2.0)
-                                progressCallback.invoke(progress.coerceIn(0.0, 1.0))
-
-                                entry = tarInputStream.getNextEntry()
-                            }
-                        }
-                    }
-                }
-            }
-
-            Log.d(TAG, "Successfully extracted tar.br file")
-            progressCallback.invoke(1.0)
-            true
-        } catch (e: Exception) {
-            Log.d(TAG, "Failed to extract tar.br file: ${e.message}")
-            e.printStackTrace()
-            false
-        }
-}

package/android/src/main/java/com/hotupdater/TarGzDecompressionStrategy.kt

@@ -1,117 +0,0 @@
-package com.hotupdater
-
-import android.util.Log
-import java.io.BufferedInputStream
-import java.io.File
-import java.io.FileInputStream
-import java.io.FileOutputStream
-import java.util.zip.GZIPInputStream
-
-/**
- * Strategy for handling TAR+GZIP compressed files
- * Uses native GZIP decoder and custom TAR parser
- */
-class TarGzDecompressionStrategy : DecompressionStrategy {
-    companion object {
-        private const val TAG = "TarGzStrategy"
-        private const val MIN_FILE_SIZE = 10L
-    }
-
-    override fun isValid(filePath: String): Boolean {
-        val file = File(filePath)
-
-        if (!file.exists() || file.length() < MIN_FILE_SIZE) {
-            Log.d(TAG, "Invalid file: doesn't exist or too small (${file.length()} bytes)")
-            return false
-        }
-
-        try {
-            FileInputStream(file).use { fis ->
-                val header = ByteArray(2)
-                if (fis.read(header) != 2) {
-                    Log.d(TAG, "Invalid file: cannot read header")
-                    return false
-                }
-
-                // Check GZIP magic bytes (0x1F 0x8B)
-                val isGzip = header[0] == 0x1F.toByte() && header[1] == 0x8B.toByte()
-                if (!isGzip) {
-                    Log.d(
-                        TAG,
-                        "Invalid file: wrong magic bytes (expected 0x1F 0x8B, got 0x${header[0].toString(16)} 0x${header[1].toString(16)})",
-                    )
-                }
-                return isGzip
-            }
-        } catch (e: Exception) {
-            Log.d(TAG, "Invalid file: error reading header: ${e.message}")
-            return false
-        }
-    }
-
-    override fun decompress(
-        filePath: String,
-        destinationPath: String,
-        progressCallback: (Double) -> Unit,
-    ): Boolean =
-        try {
-            val destinationDir = File(destinationPath)
-            if (!destinationDir.exists()) {
-                destinationDir.mkdirs()
-            }
-
-            val sourceFile = File(filePath)
-            val totalSize = sourceFile.length()
-            var processedBytes = 0L
-
-            Log.d(TAG, "Extracting tar.gz file: $filePath")
-
-            FileInputStream(filePath).use { fileInputStream ->
-                BufferedInputStream(fileInputStream).use { bufferedInputStream ->
-                    GZIPInputStream(bufferedInputStream).use { gzipInputStream ->
-                        TarArchiveInputStream(gzipInputStream).use { tarInputStream ->
-                            var entry = tarInputStream.getNextEntry()
-
-                            while (entry != null) {
-                                val file = RelativePathResolver.resolveInside(destinationDir, entry.name)
-
-                                if (file == null) {
-                                    Log.w(TAG, "Skipping potentially malicious tar entry: ${entry.name}")
-                                    entry = tarInputStream.getNextEntry()
-                                    continue
-                                }
-
-                                if (entry.isDirectory) {
-                                    file.mkdirs()
-                                } else {
-                                    file.parentFile?.mkdirs()
-
-                                    FileOutputStream(file).use { output ->
-                                        val buffer = ByteArray(8 * 1024)
-                                        var bytesRead: Int
-
-                                        while (tarInputStream.read(buffer).also { bytesRead = it } != -1) {
-                                            output.write(buffer, 0, bytesRead)
-                                            processedBytes += bytesRead
-                                        }
-                                    }
-                                }
-
-                                val progress = processedBytes.toDouble() / (totalSize * 2.0)
-                                progressCallback.invoke(progress.coerceIn(0.0, 1.0))
-
-                                entry = tarInputStream.getNextEntry()
-                            }
-                        }
-                    }
-                }
-            }
-
-            Log.d(TAG, "Successfully extracted tar.gz file")
-            progressCallback.invoke(1.0)
-            true
-        } catch (e: Exception) {
-            Log.e(TAG, "Error extracting tar.gz file: ${e.message}", e)
-            false
-        }
-}

package/android/src/main/java/com/hotupdater/ZipDecompressionStrategy.kt

@@ -1,192 +0,0 @@
-package com.hotupdater
-
-import android.util.Log
-import java.io.BufferedInputStream
-import java.io.File
-import java.io.FileInputStream
-import java.io.FileOutputStream
-import java.io.IOException
-import java.util.zip.CRC32
-import java.util.zip.ZipEntry
-import java.util.zip.ZipException
-import java.util.zip.ZipFile
-import java.util.zip.ZipInputStream
-
-/**
- * Strategy for handling ZIP compressed files
- */
-class ZipDecompressionStrategy : DecompressionStrategy {
-    companion object {
-        private const val TAG = "ZipStrategy"
-        private const val MIN_ZIP_SIZE = 22L
-    }
-
-    override fun isValid(filePath: String): Boolean {
-        val file = File(filePath)
-
-        if (!file.exists() || file.length() < MIN_ZIP_SIZE) {
-            Log.d(TAG, "Invalid ZIP: file doesn't exist or too small (${file.length()} bytes)")
-            return false
-        }
-
-        try {
-            FileInputStream(file).use { fis ->
-                val header = ByteArray(4)
-                if (fis.read(header) != 4) {
-                    Log.d(TAG, "Invalid ZIP: cannot read header")
-                    return false
-                }
-
-                // ZIP magic bytes: 0x50 0x4B 0x03 0x04 ("PK\u0003\u0004")
-                val expectedMagic = byteArrayOf(0x50.toByte(), 0x4B.toByte(), 0x03.toByte(), 0x04.toByte())
-
-                if (!header.contentEquals(expectedMagic)) {
-                    val headerHex = header.joinToString(" ") { "0x%02X".format(it) }
-                    Log.d(TAG, "Invalid ZIP: wrong magic bytes (expected 0x50 0x4B 0x03 0x04, got $headerHex)")
-                    return false
-                }
-            }
-        } catch (e: Exception) {
-            Log.d(TAG, "Invalid ZIP: error reading file: ${e.message}")
-            return false
-        }
-
-        try {
-            ZipFile(file).use { zipFile ->
-                val entries = zipFile.entries()
-                if (!entries.hasMoreElements()) {
-                    Log.d(TAG, "Invalid ZIP: no entries found")
-                    return false
-                }
-
-                val firstEntry = entries.nextElement()
-                zipFile.getInputStream(firstEntry).use { stream ->
-                    val buffer = ByteArray(1024)
-                    stream.read(buffer)
-                }
-            }
-            return true
-        } catch (e: ZipException) {
-            Log.d(TAG, "Invalid ZIP: ZIP structure error: ${e.message}")
-            return false
-        } catch (e: Exception) {
-            Log.d(TAG, "Invalid ZIP: validation error: ${e.message}")
-            return false
-        }
-    }
-
-    override fun decompress(
-        filePath: String,
-        destinationPath: String,
-        progressCallback: (Double) -> Unit,
-    ): Boolean {
-        return try {
-            val destinationDir = File(destinationPath)
-            if (!destinationDir.exists()) {
-                destinationDir.mkdirs()
-            }
-
-            // Calculate total bytes to extract for accurate progress reporting
-            val totalBytes =
-                try {
-                    ZipFile(File(filePath)).use { zipFile ->
-                        zipFile
-                            .entries()
-                            .asSequence()
-                            .filter { !it.isDirectory }
-                            .sumOf { it.size }
-                    }
-                } catch (e: Exception) {
-                    Log.d(TAG, "Failed to calculate total bytes: ${e.message}")
-                    0L
-                }
-
-            if (totalBytes == 0L) {
-                Log.d(TAG, "No content found in ZIP")
-                return false
-            }
-
-            Log.d(TAG, "Extracting $totalBytes bytes from ZIP")
-
-            var extractedFileCount = 0
-            var extractedBytes = 0L
-            var lastReportedProgress = 0.0
-
-            FileInputStream(filePath).use { fileInputStream ->
-                BufferedInputStream(fileInputStream).use { bufferedInputStream ->
-                    ZipInputStream(bufferedInputStream).use { zipInputStream ->
-                        var entry: ZipEntry? = zipInputStream.nextEntry
-                        while (entry != null) {
-                            val file =
-                                try {
-                                    RelativePathResolver.resolveInside(destinationDir, entry.name)
-                                } catch (e: IOException) {
-                                    Log.w(TAG, "Failed to resolve canonical path for zip entry: ${entry.name}", e)
-                                    null
-                                }
-
-                            if (file == null) {
-                                Log.w(TAG, "Skipping potentially malicious zip entry: ${entry.name}")
-                                entry = zipInputStream.nextEntry
-                                continue
-                            }
-
-                            if (entry.isDirectory) {
-                                file.mkdirs()
-                            } else {
-                                file.parentFile?.mkdirs()
-
-                                val crc = CRC32()
-                                FileOutputStream(file).use { output ->
-                                    val buffer = ByteArray(8 * 1024)
-                                    var bytesRead: Int
-
-                                    while (zipInputStream.read(buffer).also { bytesRead = it } != -1) {
-                                        output.write(buffer, 0, bytesRead)
-                                        crc.update(buffer, 0, bytesRead)
-
-                                        // Track bytes written for byte-based progress
-                                        extractedBytes += bytesRead
-
-                                        // Report progress more frequently (every 1%)
-                                        val currentProgress = extractedBytes.toDouble() / totalBytes
-                                        if (currentProgress - lastReportedProgress >= 0.01) {
-                                            progressCallback.invoke(currentProgress)
-                                            lastReportedProgress = currentProgress
-                                        }
-                                    }
-                                }
-
-                                if (entry.crc != -1L && crc.value != entry.crc) {
-                                    Log.w(TAG, "CRC mismatch for ${entry.name}: expected ${entry.crc}, got ${crc.value}")
-                                    file.delete()
-                                    return false
-                                }
-
-                                extractedFileCount++
-                            }
-
-                            zipInputStream.closeEntry()
-                            entry = zipInputStream.nextEntry
-                        }
-                    }
-                }
-            }
-
-            if (extractedFileCount == 0) {
-                Log.d(TAG, "No files extracted from ZIP")
-                return false
-            }
-
-            Log.d(TAG, "Successfully extracted $extractedFileCount files ($extractedBytes bytes)")
-            progressCallback.invoke(1.0)
-            true
-        } catch (e: ZipException) {
-            Log.d(TAG, "ZIP extraction failed: ${e.message}")
-            false
-        } catch (e: Exception) {
-            Log.d(TAG, "Failed to unzip file: ${e.message}")
-            false
-        }
-    }
-}

package/android/src/test/java/com/hotupdater/BsdiffPatchTest.kt

@@ -1,46 +0,0 @@
-package com.hotupdater
-
-import org.junit.Assert.assertArrayEquals
-import org.junit.Assert.assertFalse
-import org.junit.Assert.assertThrows
-import org.junit.Assert.assertTrue
-import org.junit.Rule
-import org.junit.Test
-import org.junit.rules.TemporaryFolder
-import java.util.Base64
-
-class BsdiffPatchTest {
-    @get:Rule
-    val temporaryFolder = TemporaryFolder()
-
-    @Test
-    fun `applies bsdiff patch and verifies patched output hash`() {
-        val base = "console.log(\"base bundle\");\n".toByteArray()
-        val expected = "console.log(\"patched bundle\");\n".toByteArray()
-        val patch = Base64.getDecoder().decode(BSDIFF_PATCH_FIXTURE_BASE64)
-        val baseFile = temporaryFolder.newFile("base.bundle").apply { writeBytes(base) }
-        val patchFile = temporaryFolder.newFile("patch.bsdiff").apply { writeBytes(patch) }
-        val outputFile = temporaryFolder.newFile("output.bundle")
-
-        BsdiffPatch.apply(baseFile, patchFile, outputFile)
-
-        assertArrayEquals(expected, outputFile.readBytes())
-        assertTrue(HashUtils.verifyHash(outputFile, HashUtils.calculateSHA256(outputFile)))
-        assertFalse(HashUtils.verifyHash(outputFile, HashUtils.calculateSHA256(baseFile)))
-    }
-
-    @Test
-    fun `rejects invalid bsdiff patch`() {
-        val base = "console.log(\"base bundle\");\n".toByteArray()
-        val invalidPatch = "not-a-bsdiff-patch-with-header".toByteArray()
-
-        assertThrows(IllegalArgumentException::class.java) {
-            BsdiffPatch.apply(base, invalidPatch)
-        }
-    }
-
-    companion object {
-        private const val BSDIFF_PATCH_FIXTURE_BASE64 =
-            "RU5EU0xFWS9CU0RJRkY0Mx8AAAAAAAAAQlpoOTFBWSZTWb12MIEAAAB5gEQYAADQYQAIPsXOACAAIo0A0NAaNCgAGgZMgHAtYscVxxRtTt4nmaj70g4gQSF5+T4u5IpwoSF67GEC"
-    }
-}