@hot-updater/react-native 1.0.0-rc.14 → 1.0.0-rc.16

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

@@ -216,11 +216,10 @@ class HotUpdaterImplTest {
 
         override suspend fun updateBundle(
             bundleId: String,
-            fileUrl: String?,
-            fileHash: String?,
-            manifestUrl: String?,
-            manifestFileHash: String?,
-            changedAssets: Map<String, ChangedAssetDescriptor>?,
+            manifestUrl: String,
+            manifestFileHash: String,
+            assets: Map<String, ChangedAssetDescriptor>,
+            archiveUrl: String?,
             progressCallback: (UpdateProgressPayload) -> Unit,
         ) = Unit
 

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

@@ -0,0 +1,206 @@
+package com.hotupdater
+
+import org.junit.Assert.assertArrayEquals
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertThrows
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+import java.io.ByteArrayInputStream
+import java.io.ByteArrayOutputStream
+import java.io.File
+import java.io.IOException
+import java.util.Base64
+
+class TarBrArchiveExtractorTest {
+    @get:Rule
+    val temporaryFolder = TemporaryFolder()
+
+    @Test
+    fun `extracts exact regular file set`() {
+        val destination = extract(VALID, 3072, mapOf("assets/image.png" to 5, "index.android.bundle" to 6))
+
+        assertArrayEquals("image".toByteArray(), File(destination, "assets/image.png").readBytes())
+        assertArrayEquals("bundle".toByteArray(), File(destination, "index.android.bundle").readBytes())
+    }
+
+    @Test
+    fun `supports a POSIX PAX long path`() {
+        val path = "assets/${"x".repeat(120)}.bin"
+        val destination = extract(PAX_LONG_PATH, 3072, mapOf(path to 4))
+
+        assertArrayEquals("long".toByteArray(), File(destination, path).readBytes())
+    }
+
+    @Test
+    fun `rejects duplicate unsafe linked and malformed archives`() {
+        val cases =
+            listOf(
+                Triple(DUPLICATE, 3072L, mapOf("index.android.bundle" to 6L)),
+                Triple(TRAVERSAL, 2048L, mapOf("../escape" to 3L)),
+                Triple(SYMLINK, 1536L, mapOf("index.android.bundle" to 0L)),
+                Triple(SINGLE_END_BLOCK, 1536L, mapOf("index.android.bundle" to 6L)),
+                Triple(TRAILING_NON_ZERO, 2560L, mapOf("index.android.bundle" to 6L)),
+            )
+
+        cases.forEachIndexed { index, (fixture, tarSize, files) ->
+            val archive = temporaryFolder.newFile("invalid-$index.tar.br").apply { writeBytes(decode(fixture)) }
+            val destination = File(temporaryFolder.root, "invalid-$index")
+
+            assertThrows(Exception::class.java) {
+                TarBrArchiveExtractor.extract(archive, destination, tarSize, files)
+            }
+            check(!destination.exists())
+        }
+    }
+
+    @Test
+    fun `rejects dangling consecutive duplicate and unsupported extension metadata`() {
+        val pathRecord = paxRecord("path", "index.android.bundle")
+        val malformedShortRecord = "3 \n".toByteArray()
+        val cases =
+            listOf(
+                tarArchive(tarEntry("PaxHeader", 'x', pathRecord)),
+                tarArchive(
+                    tarEntry("PaxHeader", 'x', pathRecord),
+                    tarEntry("PaxHeader", 'x', pathRecord),
+                ),
+                tarArchive(
+                    tarEntry("PaxHeader", 'x', pathRecord + paxRecord("path", "other")),
+                    regularEntry("ignored", "bundle"),
+                ),
+                tarArchive(
+                    tarEntry("PaxHeader", 'x', malformedShortRecord),
+                    regularEntry("ignored", "bundle"),
+                ),
+                tarArchive(
+                    tarEntry("PaxHeader", 'x', paxRecord("linkpath", "target")),
+                    regularEntry("index.android.bundle", "bundle"),
+                ),
+                tarArchive(tarEntry("LongLink", 'L', "name\u0000".toByteArray())),
+            )
+
+        cases.forEach { bytes ->
+            assertThrows(IOException::class.java) { consumeTar(bytes) }
+        }
+    }
+
+    @Test
+    fun `preserves exact header paths and applies PAX size`() {
+        val spacedPathArchive = tarArchive(regularEntry("index.android.bundle ", "bundle"))
+        TarArchiveInputStream(ByteArrayInputStream(spacedPathArchive)).use { input ->
+            assertEquals("index.android.bundle ", input.getNextEntry()?.name)
+        }
+
+        val payload = "data".toByteArray()
+        val paxSizeArchive =
+            tarArchive(
+                tarEntry("PaxHeader", 'x', paxRecord("size", payload.size.toString())),
+                tarEntry("index.android.bundle", '0', payload, declaredSize = 1),
+            )
+        TarArchiveInputStream(ByteArrayInputStream(paxSizeArchive)).use { input ->
+            val entry = input.getNextEntry()
+            assertEquals(payload.size.toLong(), entry?.size)
+            assertArrayEquals(payload, input.readBytes())
+            assertEquals(null, input.getNextEntry())
+        }
+    }
+
+    private fun extract(
+        fixture: String,
+        tarSize: Long,
+        files: Map<String, Long>,
+    ): File {
+        val archive = temporaryFolder.newFile("fixture-${System.nanoTime()}.tar.br").apply { writeBytes(decode(fixture)) }
+        val destination = File(temporaryFolder.root, "extracted-${System.nanoTime()}")
+        TarBrArchiveExtractor.extract(archive, destination, tarSize, files)
+        return destination
+    }
+
+    private fun decode(value: String): ByteArray = Base64.getDecoder().decode(value)
+
+    private fun consumeTar(bytes: ByteArray) {
+        TarArchiveInputStream(ByteArrayInputStream(bytes)).use { input ->
+            while (input.getNextEntry() != null) input.readBytes()
+        }
+    }
+
+    private fun paxRecord(
+        key: String,
+        value: String,
+    ): ByteArray {
+        var length = key.toByteArray().size + value.toByteArray().size + 3
+        while (true) {
+            val record = "$length $key=$value\n".toByteArray()
+            if (record.size == length) return record
+            length = record.size
+        }
+    }
+
+    private fun regularEntry(
+        name: String,
+        content: String,
+    ): ByteArray = tarEntry(name, '0', content.toByteArray())
+
+    private fun tarEntry(
+        name: String,
+        type: Char,
+        payload: ByteArray,
+        declaredSize: Int = payload.size,
+    ): ByteArray {
+        val header = ByteArray(512)
+        name.toByteArray().copyInto(header, endIndex = name.toByteArray().size.coerceAtMost(100))
+        writeOctal(header, 100, 8, 420)
+        writeOctal(header, 108, 8, 0)
+        writeOctal(header, 116, 8, 0)
+        writeOctal(header, 124, 12, declaredSize)
+        writeOctal(header, 136, 12, 0)
+        for (index in 148 until 156) header[index] = ' '.code.toByte()
+        header[156] = type.code.toByte()
+        "ustar".toByteArray().copyInto(header, 257)
+        writeOctal(header, 148, 8, header.sumOf { it.toInt() and 0xff })
+
+        return ByteArrayOutputStream()
+            .apply {
+                write(header)
+                write(payload)
+                write(ByteArray((512 - payload.size % 512) % 512))
+            }.toByteArray()
+    }
+
+    private fun tarArchive(vararg entries: ByteArray): ByteArray =
+        ByteArrayOutputStream()
+            .apply {
+                entries.forEach(::write)
+                write(ByteArray(1024))
+            }.toByteArray()
+
+    private fun writeOctal(
+        target: ByteArray,
+        offset: Int,
+        length: Int,
+        value: Int,
+    ) {
+        val digits = value.toString(8).padStart(length - 2, '0')
+        digits.toByteArray().copyInto(target, offset)
+        target[offset + length - 2] = 0
+        target[offset + length - 1] = ' '.code.toByte()
+    }
+
+    companion object {
+        const val VALID =
+            "G/8LYI7UVnlCO6lhAMTqIo5tMQLiY7NptuP57iYyogHNeF9BlHNiXHeDMLCAJL3h9im3UyYnSs3aLbJIIBsjml0YwV1+Hd11htDfIA8GgPKHFrFNtD7SOfZo/h9mbgDYuSAJIPmy9Z2b"
+        private const val DUPLICATE =
+            "G/8L4I/UVnlCO6lh6sQAIm5ssV7ksdnUyXHelkgImbdLFCl08DwgyVOGdSmhfs8LgniesZ82/bHw7qIYoXwdSTsMVSkOBkDMM0vqHj11Ew=="
+        private const val TRAVERSAL =
+            "G/8H+AfKbRfTdvBDW1YMVZ0c3w7fLhJCyAFHCIm3xTUACIRyzK7qNZRgrBkUGlOQ+PtOBlH/uDAUZ9s9Dw=="
+        private const val SYMLINK =
+            "G/8FoI7UYs0ZrwQiHgYxvWizaUNMJ8cnP4h9lyiDwKKELcCA8pSZdZEoyN91S9BvNObx0n8IcrtxYn2sUe6QrffCuHk8LCgA"
+        private const val SINGLE_END_BLOCK =
+            "G/8F4I/UVnlCO6lh6sQAIm5ssV7ksdnUyfH9WyIhZN4uUaQSeB6Q5DGGvrXYkguCOs/YT5v+GLy7ECOUryNph6EqxcEAinlmEw=="
+        private const val TRAILING_NON_ZERO =
+            "G/8J4Adqc2ds55CPYbC2qk6O87ZEQsi0tUsUKUXN80TyGEPfWmyJBUGcZ6y72vQfJjUzyChogu7Xu5ODMLcUB0MBYu7ZOLkF"
+        private const val PAX_LONG_PATH =
+            "G/8LYAbCtn2mBfjh0GTohqrNYvNuZjueb2Ij3vmAJjz8C6jLIEtYgqi7gAMNAII62ZkiZILxgnbd1QSM8usRpO6ZyCgYZiz8dTRcx0YB/gG5MBRqZPyVyrk8J47iYenP+zXoZcGa8QLgayISZoflgdi14Q=="
+    }
+}

package/ios/HotUpdater/Internal/BrotliFileDecompressor.swift

@@ -0,0 +1,167 @@
+import Compression
+import Foundation
+
+enum BrotliFileDecompressor {
+    private static let bufferSize = 64 * 1024
+
+    static func decompress(
+        from sourcePath: String,
+        to outputPath: String,
+        expectedOutputByteSize: Int64? = nil
+    ) throws {
+        if let expectedOutputByteSize, expectedOutputByteSize < 0 {
+            throw error(6, "Invalid expected Brotli output size")
+        }
+        let fileManager = FileManager.default
+        let parentDirectory = (outputPath as NSString).deletingLastPathComponent
+        try fileManager.createDirectory(
+            atPath: parentDirectory,
+            withIntermediateDirectories: true
+        )
+        if fileManager.fileExists(atPath: outputPath) {
+            try fileManager.removeItem(atPath: outputPath)
+        }
+        guard fileManager.createFile(atPath: outputPath, contents: nil) else {
+            throw error(1, "Failed to create Brotli output file")
+        }
+
+        let input = try FileHandle(forReadingFrom: URL(fileURLWithPath: sourcePath))
+        let output = try FileHandle(forWritingTo: URL(fileURLWithPath: outputPath))
+        defer {
+            try? input.close()
+            try? output.close()
+        }
+
+        var stream = compression_stream(
+            dst_ptr: UnsafeMutablePointer<UInt8>(bitPattern: 1)!,
+            dst_size: 0,
+            src_ptr: UnsafePointer<UInt8>(bitPattern: 1)!,
+            src_size: 0,
+            state: nil
+        )
+        guard compression_stream_init(
+            &stream,
+            COMPRESSION_STREAM_DECODE,
+            COMPRESSION_BROTLI
+        ) == COMPRESSION_STATUS_OK else {
+            throw error(2, "Failed to initialize Brotli decompression")
+        }
+        defer { compression_stream_destroy(&stream) }
+
+        let outputBuffer = UnsafeMutablePointer<UInt8>.allocate(
+            capacity: bufferSize
+        )
+        defer { outputBuffer.deallocate() }
+
+        var reachedEnd = false
+        var totalOutputByteSize: UInt64 = 0
+        let maximumOutputByteSize = expectedOutputByteSize.map(UInt64.init)
+        while !reachedEnd {
+            let chunk = try FileUtilities.readUpToCount(
+                from: input,
+                count: bufferSize
+            ) ?? Data()
+            let status: compression_status
+            if chunk.isEmpty {
+                stream.src_ptr = UnsafePointer<UInt8>(bitPattern: 1)!
+                stream.src_size = 0
+                status = try process(
+                    &stream,
+                    output: output,
+                    outputBuffer: outputBuffer,
+                    finalize: true,
+                    totalOutputByteSize: &totalOutputByteSize,
+                    maximumOutputByteSize: maximumOutputByteSize
+                )
+            } else {
+                status = try chunk.withUnsafeBytes { bytes in
+                    guard let source = bytes.baseAddress?
+                        .assumingMemoryBound(to: UInt8.self) else {
+                        return COMPRESSION_STATUS_OK
+                    }
+                    stream.src_ptr = source
+                    stream.src_size = chunk.count
+                    return try process(
+                        &stream,
+                        output: output,
+                        outputBuffer: outputBuffer,
+                        finalize: false,
+                        totalOutputByteSize: &totalOutputByteSize,
+                        maximumOutputByteSize: maximumOutputByteSize
+                    )
+                }
+            }
+
+            if status == COMPRESSION_STATUS_END {
+                guard stream.src_size == 0 else {
+                    throw error(7, "Brotli stream contains trailing compressed bytes")
+                }
+                let trailing = try FileUtilities.readUpToCount(from: input, count: 1)
+                guard trailing?.isEmpty != false else {
+                    throw error(7, "Brotli stream contains trailing compressed bytes")
+                }
+                reachedEnd = true
+            } else if chunk.isEmpty {
+                throw error(3, "Brotli input ended before the stream completed")
+            }
+        }
+
+        if let maximumOutputByteSize,
+           totalOutputByteSize != maximumOutputByteSize {
+            throw error(
+                8,
+                "Brotli output size mismatch: expected \(maximumOutputByteSize), got \(totalOutputByteSize)"
+            )
+        }
+    }
+
+    private static func process(
+        _ stream: inout compression_stream,
+        output: FileHandle,
+        outputBuffer: UnsafeMutablePointer<UInt8>,
+        finalize: Bool,
+        totalOutputByteSize: inout UInt64,
+        maximumOutputByteSize: UInt64?
+    ) throws -> compression_status {
+        let flags = finalize ? Int32(COMPRESSION_STREAM_FINALIZE.rawValue) : 0
+        var status = COMPRESSION_STATUS_OK
+        repeat {
+            let previousSourceSize = stream.src_size
+            stream.dst_ptr = outputBuffer
+            stream.dst_size = bufferSize
+            status = compression_stream_process(&stream, flags)
+
+            guard status == COMPRESSION_STATUS_OK ||
+                    status == COMPRESSION_STATUS_END else {
+                throw error(4, "Brotli decompression failed")
+            }
+            let produced = bufferSize - stream.dst_size
+            if produced > 0 {
+                let (nextOutputByteSize, overflowed) = totalOutputByteSize
+                    .addingReportingOverflow(UInt64(produced))
+                guard !overflowed,
+                      maximumOutputByteSize.map({ nextOutputByteSize <= $0 }) ?? true else {
+                    throw error(6, "Brotli output exceeds expected size")
+                }
+                output.write(Data(bytes: outputBuffer, count: produced))
+                totalOutputByteSize = nextOutputByteSize
+            }
+            if finalize,
+               status == COMPRESSION_STATUS_OK,
+               produced == 0,
+               previousSourceSize == stream.src_size {
+                throw error(5, "Brotli decompression stalled")
+            }
+        } while stream.src_size > 0 || stream.dst_size == 0 ||
+            (finalize && status == COMPRESSION_STATUS_OK)
+        return status
+    }
+
+    private static func error(_ code: Int, _ message: String) -> NSError {
+        NSError(
+            domain: "BrotliFileDecompressor",
+            code: code,
+            userInfo: [NSLocalizedDescriptionKey: message]
+        )
+    }
+}

package/ios/HotUpdater/Internal/BuiltInAssetResolver.swift

@@ -0,0 +1,196 @@
+import Foundation
+
+protocol BuiltInAssetResolver: AnyObject {
+    func use(bundle: Bundle)
+    func copyIfMatches(assetPath: String, expectedHash: String, destination: String) -> Bool
+}
+
+final class IOSBuiltInAssetResolver: BuiltInAssetResolver {
+    private struct CachedIndex: Codable {
+        let schemaVersion: Int
+        let packageIdentity: String
+        var locators: [String: String]
+    }
+
+    private let cacheURL: URL
+    private let lock = NSLock()
+    private var bundle: Bundle = .main
+
+    init(cacheURL: URL) {
+        self.cacheURL = cacheURL
+    }
+
+    func use(bundle: Bundle) {
+        lock.lock()
+        self.bundle = bundle
+        lock.unlock()
+    }
+
+    func copyIfMatches(
+        assetPath: String,
+        expectedHash: String,
+        destination: String
+    ) -> Bool {
+        lock.lock()
+        defer { lock.unlock() }
+
+        guard FileUtilities.normalizedRelativePath(from: assetPath) == assetPath else {
+            return false
+        }
+        let packageIdentity = packageIdentity(for: bundle)
+        var index = readIndex(packageIdentity: packageIdentity)
+
+        if let cachedLocator = index.locators[assetPath],
+           copyLocatorIfMatches(
+            cachedLocator,
+            expectedHash: expectedHash,
+            destination: destination
+           ) {
+            return true
+        }
+
+        guard let locator = resolveLocator(assetPath: assetPath),
+              copyLocatorIfMatches(
+                locator,
+                expectedHash: expectedHash,
+                destination: destination
+              ) else {
+            return false
+        }
+
+        index.locators[assetPath] = locator
+        writeIndex(index)
+        return true
+    }
+
+    private func resolveLocator(assetPath: String) -> String? {
+        if assetPath == "index.ios.bundle" {
+            guard let bundleURL = bundle.url(forResource: "main", withExtension: "jsbundle"),
+                  let relativePath = relativePath(of: bundleURL, inside: bundle.bundleURL) else {
+                return nil
+            }
+            return "bundle:\(relativePath)"
+        }
+
+        guard let resourceURL = bundle.resourceURL else { return nil }
+        let sourceURL = resourceURL.appendingPathComponent(assetPath).standardizedFileURL
+        guard relativePath(of: sourceURL, inside: resourceURL) == assetPath,
+              isRegularFile(sourceURL) else {
+            return nil
+        }
+        return "resource:\(assetPath)"
+    }
+
+    private func copyLocatorIfMatches(
+        _ locator: String,
+        expectedHash: String,
+        destination: String
+    ) -> Bool {
+        guard let sourceURL = sourceURL(for: locator), isRegularFile(sourceURL) else {
+            return false
+        }
+        let destinationURL = URL(fileURLWithPath: destination)
+        let temporaryURL = destinationURL
+            .deletingLastPathComponent()
+            .appendingPathComponent("\(destinationURL.lastPathComponent).builtin.tmp")
+        do {
+            try FileManager.default.createDirectory(
+                at: destinationURL.deletingLastPathComponent(),
+                withIntermediateDirectories: true
+            )
+            try? FileManager.default.removeItem(at: temporaryURL)
+            try FileManager.default.copyItem(at: sourceURL, to: temporaryURL)
+            guard HashUtils.verifyHash(fileURL: temporaryURL, expectedHash: expectedHash) else {
+                try? FileManager.default.removeItem(at: temporaryURL)
+                return false
+            }
+            try? FileManager.default.removeItem(at: destinationURL)
+            try FileManager.default.moveItem(at: temporaryURL, to: destinationURL)
+            return true
+        } catch {
+            try? FileManager.default.removeItem(at: temporaryURL)
+            return false
+        }
+    }
+
+    private func sourceURL(for locator: String) -> URL? {
+        if locator.hasPrefix("bundle:") {
+            let relativePath = String(locator.dropFirst("bundle:".count))
+            let sourceURL = bundle.bundleURL.appendingPathComponent(relativePath).standardizedFileURL
+            return self.relativePath(of: sourceURL, inside: bundle.bundleURL) == relativePath
+                ? sourceURL
+                : nil
+        }
+        if locator.hasPrefix("resource:"), let resourceURL = bundle.resourceURL {
+            let relativePath = String(locator.dropFirst("resource:".count))
+            let sourceURL = resourceURL.appendingPathComponent(relativePath).standardizedFileURL
+            return self.relativePath(of: sourceURL, inside: resourceURL) == relativePath
+                ? sourceURL
+                : nil
+        }
+        return nil
+    }
+
+    private func relativePath(of fileURL: URL, inside directoryURL: URL) -> String? {
+        let directory = directoryURL.standardizedFileURL.resolvingSymlinksInPath().path
+        let file = fileURL.standardizedFileURL.resolvingSymlinksInPath().path
+        let prefix = directory.hasSuffix("/") ? directory : "\(directory)/"
+        guard file.hasPrefix(prefix) else { return nil }
+        return String(file.dropFirst(prefix.count))
+    }
+
+    private func isRegularFile(_ url: URL) -> Bool {
+        (try? url.resourceValues(forKeys: [.isRegularFileKey]).isRegularFile) == true
+    }
+
+    private func packageIdentity(for bundle: Bundle) -> String {
+        let values = try? bundle.bundleURL.resourceValues(forKeys: [.contentModificationDateKey, .fileSizeKey])
+        let bundleIdentifier = bundle.bundleIdentifier ?? ""
+        let shortVersion = bundle.object(forInfoDictionaryKey: "CFBundleShortVersionString") as? String ?? ""
+        let bundleVersion = bundle.object(forInfoDictionaryKey: "CFBundleVersion") as? String ?? ""
+        let bundlePath = bundle.bundleURL.standardizedFileURL.path
+        let fileSize = String(values?.fileSize ?? -1)
+        let modificationTime = String(values?.contentModificationDate?.timeIntervalSince1970 ?? -1)
+
+        return [
+            bundleIdentifier,
+            shortVersion,
+            bundleVersion,
+            bundlePath,
+            fileSize,
+            modificationTime,
+        ].joined(separator: "|")
+    }
+
+    private func readIndex(packageIdentity: String) -> CachedIndex {
+        if let data = try? Data(contentsOf: cacheURL),
+           let index = try? JSONDecoder().decode(CachedIndex.self, from: data),
+           index.schemaVersion == Self.schemaVersion,
+           index.packageIdentity == packageIdentity {
+            return index
+        }
+        return CachedIndex(
+            schemaVersion: Self.schemaVersion,
+            packageIdentity: packageIdentity,
+            locators: [:]
+        )
+    }
+
+    private func writeIndex(_ index: CachedIndex) {
+        do {
+            try FileManager.default.createDirectory(
+                at: cacheURL.deletingLastPathComponent(),
+                withIntermediateDirectories: true
+            )
+            let temporaryURL = cacheURL.appendingPathExtension("tmp")
+            let data = try JSONEncoder().encode(index)
+            try data.write(to: temporaryURL, options: .atomic)
+            try? FileManager.default.removeItem(at: cacheURL)
+            try FileManager.default.moveItem(at: temporaryURL, to: cacheURL)
+        } catch {
+            // Cache persistence must never block a valid install.
+        }
+    }
+
+    private static let schemaVersion = 1
+}