@hot-updater/react-native 0.29.1 → 0.29.3

package/ios/HotUpdater/Internal/TarGzDecompressionStrategy.swift

@@ -1,6 +1,4 @@
 import Foundation
-import SWCompression
-import Compression
 
 /**
  * Strategy for handling TAR+GZIP compressed files
@@ -35,7 +33,8 @@ class TarGzDecompressionStrategy: DecompressionStrategy {
             fileHandle.closeFile()
         }
 
-        guard let header = try? fileHandle.read(upToCount: 2), header.count == 2 else {
+        guard let header = try? ArchiveExtractionUtilities.readUpToCount(from: fileHandle, count: 2),
+              header.count == 2 else {
             NSLog("[TarGzStrategy] Invalid file: cannot read header")
             return false
         }
@@ -49,129 +48,12 @@ class TarGzDecompressionStrategy: DecompressionStrategy {
 
     func decompress(file: String, to destination: String, progressHandler: @escaping (Double) -> Void) throws {
         NSLog("[TarGzStrategy] Starting extraction of \(file) to \(destination)")
-
-        guard let compressedData = try? Data(contentsOf: URL(fileURLWithPath: file)) else {
-            throw NSError(
-                domain: "TarGzDecompressionStrategy",
-                code: 1,
-                userInfo: [NSLocalizedDescriptionKey: "Failed to read tar.gz file at: \(file)"]
-            )
-        }
-
-        progressHandler(0.3)
-        let decompressedData: Data
-        do {
-            decompressedData = try decompressGzip(compressedData)
-            NSLog("[TarGzStrategy] GZIP decompression successful, size: \(decompressedData.count) bytes")
-            progressHandler(0.6)
-        } catch {
-            throw NSError(
-                domain: "TarGzDecompressionStrategy",
-                code: 2,
-                userInfo: [NSLocalizedDescriptionKey: "GZIP decompression failed: \(error.localizedDescription)"]
-            )
-        }
-
-        let tarEntries: [TarEntry]
-        do {
-            tarEntries = try TarContainer.open(container: decompressedData)
-            NSLog("[TarGzStrategy] Tar extraction successful, found \(tarEntries.count) entries")
-        } catch {
-            throw NSError(
-                domain: "TarGzDecompressionStrategy",
-                code: 3,
-                userInfo: [NSLocalizedDescriptionKey: "Tar extraction failed: \(error.localizedDescription)"]
-            )
-        }
-
-        let destinationURL = URL(fileURLWithPath: destination)
-        let canonicalDestination = destinationURL.standardized.path
-
-        let fileManager = FileManager.default
-        if !fileManager.fileExists(atPath: canonicalDestination) {
-            try fileManager.createDirectory(
-                atPath: canonicalDestination,
-                withIntermediateDirectories: true,
-                attributes: nil
-            )
-        }
-
-        let totalEntries = Double(tarEntries.count)
-        for (index, entry) in tarEntries.enumerated() {
-            try extractTarEntry(entry, to: canonicalDestination)
-            progressHandler(0.6 + (Double(index + 1) / totalEntries * 0.4))
-        }
-
+        try StreamingTarArchiveExtractor.extractCompressedTar(
+            file: file,
+            to: destination,
+            algorithm: .gzip,
+            progressHandler: progressHandler
+        )
         NSLog("[TarGzStrategy] Successfully extracted all entries")
     }
-
-    private func decompressGzip(_ data: Data) throws -> Data {
-        do {
-            let decompressedData = try GzipArchive.unarchive(archive: data)
-            NSLog("[TarGzStrategy] GZIP decompression successful using SWCompression")
-            return decompressedData
-        } catch {
-            throw NSError(
-                domain: "TarGzDecompressionStrategy",
-                code: 5,
-                userInfo: [NSLocalizedDescriptionKey: "GZIP decompression failed: \(error.localizedDescription)"]
-            )
-        }
-    }
-
-    private func extractTarEntry(_ entry: TarEntry, to destination: String) throws {
-        let fileManager = FileManager.default
-        let entryPath = entry.info.name.trimmingCharacters(in: .init(charactersIn: "/"))
-
-        guard !entryPath.isEmpty,
-              !entryPath.contains(".."),
-              !entryPath.hasPrefix("/") else {
-            NSLog("[TarGzStrategy] Skipping suspicious path: \(entry.info.name)")
-            return
-        }
-
-        let fullPath = (destination as NSString).appendingPathComponent(entryPath)
-        let fullURL = URL(fileURLWithPath: fullPath)
-        let canonicalFullPath = fullURL.standardized.path
-        let canonicalDestination = URL(fileURLWithPath: destination).standardized.path
-
-        guard canonicalFullPath.hasPrefix(canonicalDestination + "/") ||
-              canonicalFullPath == canonicalDestination else {
-            throw NSError(
-                domain: "TarGzDecompressionStrategy",
-                code: 4,
-                userInfo: [NSLocalizedDescriptionKey: "Path traversal attempt detected: \(entry.info.name)"]
-            )
-        }
-
-        if entry.info.type == .directory {
-            if !fileManager.fileExists(atPath: canonicalFullPath) {
-                try fileManager.createDirectory(
-                    atPath: canonicalFullPath,
-                    withIntermediateDirectories: true,
-                    attributes: nil
-                )
-            }
-            return
-        }
-
-        if entry.info.type == .regular {
-            let parentPath = (canonicalFullPath as NSString).deletingLastPathComponent
-            if !fileManager.fileExists(atPath: parentPath) {
-                try fileManager.createDirectory(
-                    atPath: parentPath,
-                    withIntermediateDirectories: true,
-                    attributes: nil
-                )
-            }
-
-            guard let data = entry.data else {
-                NSLog("[TarGzStrategy] Skipping file with no data: \(entry.info.name)")
-                return
-            }
-
-            try data.write(to: URL(fileURLWithPath: canonicalFullPath))
-            NSLog("[TarGzStrategy] Extracted: \(entryPath)")
-        }
-    }
 }

package/ios/HotUpdater/Internal/URLSessionDownloadService.swift

@@ -179,7 +179,7 @@ extension URLSessionDownloadService: URLSessionDownloadDelegate {
                 try FileManager.default.removeItem(at: destinationURL)
             }
 
-            try FileManager.default.copyItem(at: location, to: destinationURL)
+            try persistDownloadedFile(from: location, to: destinationURL)
             NSLog("[DownloadService] Download completed successfully: \(actualSize ?? 0) bytes")
             completion?(.success(destinationURL))
         } catch {
@@ -236,4 +236,15 @@ extension URLSessionDownloadService: URLSessionDownloadDelegate {
             NotificationCenter.default.post(name: .downloadProgressUpdate, object: downloadTask, userInfo: ["progress": 0.0, "totalBytesReceived": 0, "totalBytesExpected": 0])
         }
     }
-}
+}
+
+private extension URLSessionDownloadService {
+    func persistDownloadedFile(from location: URL, to destinationURL: URL) throws {
+        do {
+            try FileManager.default.moveItem(at: location, to: destinationURL)
+        } catch {
+            NSLog("[DownloadService] Move failed, falling back to copy: \(error.localizedDescription)")
+            try FileManager.default.copyItem(at: location, to: destinationURL)
+        }
+    }
+}

package/ios/HotUpdater/Internal/ZipArchiveExtractor.swift

@@ -0,0 +1,462 @@
+import Foundation
+import zlib
+
+enum ZipArchiveExtractor {
+    private static let localFileHeaderSignature: UInt32 = 0x04034B50
+    private static let centralDirectoryHeaderSignature: UInt32 = 0x02014B50
+    private static let endOfCentralDirectorySignature: UInt32 = 0x06054B50
+    private static let storedMethod: UInt16 = 0
+    private static let deflatedMethod: UInt16 = 8
+    private static let encryptedFlag: UInt16 = 1 << 0
+    private static let maxCommentLength = 0xFFFF
+    private static let unixHostIdentifier: UInt8 = 3
+    private static let fileTypeMask: UInt16 = 0o170000
+    private static let symbolicLinkMode: UInt16 = 0o120000
+    private static let directoryMode: UInt16 = 0o040000
+
+    private struct CentralDirectoryEntry {
+        let path: String
+        let compressionMethod: UInt16
+        let flags: UInt16
+        let compressedSize: UInt64
+        let uncompressedSize: UInt64
+        let checksum: UInt32
+        let localHeaderOffset: UInt64
+        let isDirectory: Bool
+        let isSymbolicLink: Bool
+    }
+
+    private struct EndOfCentralDirectoryRecord {
+        let totalEntries: UInt16
+        let centralDirectoryOffset: UInt64
+    }
+
+    static func extract(file: String, to destination: String, progressHandler: @escaping (Double) -> Void) throws {
+        let fileURL = URL(fileURLWithPath: file)
+        let fileSize = try archiveFileSize(at: file)
+        let handle = try FileHandle(forReadingFrom: fileURL)
+
+        defer {
+            try? handle.close()
+        }
+
+        let entries = try readCentralDirectoryEntries(from: handle, fileSize: fileSize)
+
+        let destinationURL = URL(fileURLWithPath: destination)
+        try ArchiveExtractionUtilities.ensureDirectory(at: destinationURL)
+
+        let totalCompressedBytes = entries.reduce(UInt64(0)) { $0 + max($1.compressedSize, 1) }
+        var processedCompressedBytes: UInt64 = 0
+
+        for entry in entries {
+            try extractEntry(entry, from: handle, to: destinationURL.standardizedFileURL.path)
+            processedCompressedBytes += max(entry.compressedSize, 1)
+
+            guard totalCompressedBytes > 0 else {
+                continue
+            }
+
+            let progress = min(Double(processedCompressedBytes) / Double(totalCompressedBytes), 1.0)
+            progressHandler(progress)
+        }
+
+        progressHandler(1.0)
+    }
+
+    private static func readCentralDirectoryEntries(
+        from handle: FileHandle,
+        fileSize: UInt64
+    ) throws -> [CentralDirectoryEntry] {
+        let endRecord = try locateEndOfCentralDirectory(in: handle, fileSize: fileSize)
+
+        try ArchiveExtractionUtilities.seek(handle, to: endRecord.centralDirectoryOffset)
+
+        var entries: [CentralDirectoryEntry] = []
+        entries.reserveCapacity(Int(endRecord.totalEntries))
+
+        for _ in 0..<endRecord.totalEntries {
+            let header = try ArchiveExtractionUtilities.readExactly(from: handle, count: 46)
+
+            guard header.archiveUInt32LE(at: 0) == centralDirectoryHeaderSignature else {
+                throw NSError(
+                    domain: "ZipArchiveExtractor",
+                    code: 1,
+                    userInfo: [NSLocalizedDescriptionKey: "Invalid ZIP central directory header"]
+                )
+            }
+
+            let flags = header.archiveUInt16LE(at: 8)
+            let compressionMethod = header.archiveUInt16LE(at: 10)
+            let compressedSize = header.archiveUInt32LE(at: 20)
+            let uncompressedSize = header.archiveUInt32LE(at: 24)
+            let fileNameLength = Int(header.archiveUInt16LE(at: 28))
+            let extraFieldLength = Int(header.archiveUInt16LE(at: 30))
+            let commentLength = Int(header.archiveUInt16LE(at: 32))
+            let checksum = header.archiveUInt32LE(at: 16)
+            let localHeaderOffset = header.archiveUInt32LE(at: 42)
+            let versionMadeBy = header.archiveUInt16LE(at: 4)
+            let externalAttributes = header.archiveUInt32LE(at: 38)
+
+            guard compressedSize != UInt32.max,
+                  uncompressedSize != UInt32.max,
+                  localHeaderOffset != UInt32.max else {
+                throw NSError(
+                    domain: "ZipArchiveExtractor",
+                    code: 2,
+                    userInfo: [NSLocalizedDescriptionKey: "ZIP64 archives are not supported"]
+                )
+            }
+
+            let fileNameData = try ArchiveExtractionUtilities.readExactly(from: handle, count: fileNameLength)
+            let extraFieldData = try ArchiveExtractionUtilities.readExactly(from: handle, count: extraFieldLength)
+            _ = extraFieldData
+            if commentLength > 0 {
+                try ArchiveExtractionUtilities.skipBytes(UInt64(commentLength), in: handle)
+            }
+
+            let path = decodePath(from: fileNameData)
+            let mode = unixFileMode(versionMadeBy: versionMadeBy, externalAttributes: externalAttributes)
+            let isDirectory = path.hasSuffix("/") || mode == directoryMode
+            let isSymbolicLink = mode == symbolicLinkMode
+
+            entries.append(
+                CentralDirectoryEntry(
+                    path: path,
+                    compressionMethod: compressionMethod,
+                    flags: flags,
+                    compressedSize: UInt64(compressedSize),
+                    uncompressedSize: UInt64(uncompressedSize),
+                    checksum: checksum,
+                    localHeaderOffset: UInt64(localHeaderOffset),
+                    isDirectory: isDirectory,
+                    isSymbolicLink: isSymbolicLink
+                )
+            )
+        }
+
+        return entries
+    }
+
+    private static func locateEndOfCentralDirectory(
+        in handle: FileHandle,
+        fileSize: UInt64
+    ) throws -> EndOfCentralDirectoryRecord {
+        let minimumRecordLength = 22
+        let searchLength = Int(min(fileSize, UInt64(maxCommentLength + minimumRecordLength)))
+        let searchOffset = fileSize - UInt64(searchLength)
+
+        try ArchiveExtractionUtilities.seek(handle, to: searchOffset)
+        let tailData = try ArchiveExtractionUtilities.readExactly(from: handle, count: searchLength)
+
+        let signatureBytes: [UInt8] = [0x50, 0x4B, 0x05, 0x06]
+
+        guard let recordIndex = findLastSignature(signatureBytes, in: tailData) else {
+            throw NSError(
+                domain: "ZipArchiveExtractor",
+                code: 3,
+                userInfo: [NSLocalizedDescriptionKey: "ZIP end of central directory record not found"]
+            )
+        }
+
+        let minimumEndIndex = recordIndex + minimumRecordLength
+        guard minimumEndIndex <= tailData.count else {
+            throw NSError(
+                domain: "ZipArchiveExtractor",
+                code: 4,
+                userInfo: [NSLocalizedDescriptionKey: "ZIP end of central directory record is truncated"]
+            )
+        }
+
+        let commentLength = Int(tailData.archiveUInt16LE(at: recordIndex + 20))
+        guard minimumEndIndex + commentLength == tailData.count else {
+            throw NSError(
+                domain: "ZipArchiveExtractor",
+                code: 5,
+                userInfo: [NSLocalizedDescriptionKey: "ZIP central directory comment is malformed"]
+            )
+        }
+
+        return EndOfCentralDirectoryRecord(
+            totalEntries: tailData.archiveUInt16LE(at: recordIndex + 10),
+            centralDirectoryOffset: UInt64(tailData.archiveUInt32LE(at: recordIndex + 16))
+        )
+    }
+
+    private static func extractEntry(
+        _ entry: CentralDirectoryEntry,
+        from handle: FileHandle,
+        to destinationRoot: String
+    ) throws {
+        guard entry.flags & encryptedFlag == 0 else {
+            throw NSError(
+                domain: "ZipArchiveExtractor",
+                code: 6,
+                userInfo: [NSLocalizedDescriptionKey: "Encrypted ZIP entries are not supported"]
+            )
+        }
+
+        guard let relativePath = ArchiveExtractionUtilities.normalizedRelativePath(from: entry.path) else {
+            return
+        }
+
+        let targetURL = try ArchiveExtractionUtilities.extractionURL(
+            for: relativePath,
+            destinationRoot: destinationRoot
+        )
+
+        if entry.isDirectory {
+            try ArchiveExtractionUtilities.ensureDirectory(at: targetURL)
+            return
+        }
+
+        if entry.isSymbolicLink {
+            NSLog("[ZipArchiveExtractor] Skipping symbolic link entry: \(entry.path)")
+            return
+        }
+
+        try ArchiveExtractionUtilities.seek(handle, to: entry.localHeaderOffset)
+        let localHeader = try ArchiveExtractionUtilities.readExactly(from: handle, count: 30)
+
+        guard localHeader.archiveUInt32LE(at: 0) == localFileHeaderSignature else {
+            throw NSError(
+                domain: "ZipArchiveExtractor",
+                code: 7,
+                userInfo: [NSLocalizedDescriptionKey: "Invalid ZIP local file header for \(entry.path)"]
+            )
+        }
+
+        let fileNameLength = UInt64(localHeader.archiveUInt16LE(at: 26))
+        let extraFieldLength = UInt64(localHeader.archiveUInt16LE(at: 28))
+        let dataOffset = entry.localHeaderOffset + 30 + fileNameLength + extraFieldLength
+
+        try ArchiveExtractionUtilities.seek(handle, to: dataOffset)
+        let outputHandle = try ArchiveExtractionUtilities.createOutputFile(at: targetURL)
+
+        defer {
+            try? outputHandle.close()
+        }
+
+        let extractionResult: (writtenSize: UInt64, checksum: UInt32)
+
+        switch entry.compressionMethod {
+        case storedMethod:
+            extractionResult = try extractStoredEntry(
+                from: handle,
+                compressedSize: entry.compressedSize,
+                to: outputHandle
+            )
+        case deflatedMethod:
+            extractionResult = try extractDeflatedEntry(
+                from: handle,
+                compressedSize: entry.compressedSize,
+                to: outputHandle
+            )
+        default:
+            throw NSError(
+                domain: "ZipArchiveExtractor",
+                code: 8,
+                userInfo: [NSLocalizedDescriptionKey: "Unsupported ZIP compression method \(entry.compressionMethod) for \(entry.path)"]
+            )
+        }
+
+        guard extractionResult.writtenSize == entry.uncompressedSize else {
+            throw NSError(
+                domain: "ZipArchiveExtractor",
+                code: 9,
+                userInfo: [NSLocalizedDescriptionKey: "ZIP entry size mismatch for \(entry.path)"]
+            )
+        }
+
+        guard extractionResult.checksum == entry.checksum else {
+            throw NSError(
+                domain: "ZipArchiveExtractor",
+                code: 10,
+                userInfo: [NSLocalizedDescriptionKey: "ZIP entry checksum mismatch for \(entry.path)"]
+            )
+        }
+    }
+
+    private static func extractStoredEntry(
+        from handle: FileHandle,
+        compressedSize: UInt64,
+        to outputHandle: FileHandle
+    ) throws -> (writtenSize: UInt64, checksum: UInt32) {
+        var remainingBytes = compressedSize
+        var totalWritten: UInt64 = 0
+        var checksum: uLong = crc32(0, nil, 0)
+
+        while remainingBytes > 0 {
+            let chunkSize = Int(min(remainingBytes, UInt64(ArchiveExtractionUtilities.bufferSize)))
+            let chunk = try ArchiveExtractionUtilities.readExactly(from: handle, count: chunkSize)
+            outputHandle.write(chunk)
+            totalWritten += UInt64(chunk.count)
+            checksum = updateCRC32(checksum, with: chunk)
+            remainingBytes -= UInt64(chunk.count)
+        }
+
+        return (totalWritten, UInt32(checksum))
+    }
+
+    private static func extractDeflatedEntry(
+        from handle: FileHandle,
+        compressedSize: UInt64,
+        to outputHandle: FileHandle
+    ) throws -> (writtenSize: UInt64, checksum: UInt32) {
+        let outputBuffer = UnsafeMutablePointer<UInt8>.allocate(capacity: ArchiveExtractionUtilities.bufferSize)
+
+        defer {
+            outputBuffer.deallocate()
+        }
+
+        var stream = z_stream()
+        let initStatus = inflateInit2_(
+            &stream,
+            -MAX_WBITS,
+            ZLIB_VERSION,
+            Int32(MemoryLayout<z_stream>.size)
+        )
+
+        guard initStatus == Z_OK else {
+            throw NSError(
+                domain: "ZipArchiveExtractor",
+                code: 11,
+                userInfo: [NSLocalizedDescriptionKey: "Failed to initialize ZIP inflater"]
+            )
+        }
+
+        defer {
+            inflateEnd(&stream)
+        }
+
+        var remainingBytes = compressedSize
+        var totalWritten: UInt64 = 0
+        var checksum: uLong = crc32(0, nil, 0)
+        var reachedStreamEnd = false
+
+        while remainingBytes > 0 {
+            let chunkSize = Int(min(remainingBytes, UInt64(ArchiveExtractionUtilities.bufferSize)))
+            let chunk = try ArchiveExtractionUtilities.readExactly(from: handle, count: chunkSize)
+            remainingBytes -= UInt64(chunk.count)
+
+            try chunk.withUnsafeBytes { rawBuffer in
+                guard let baseAddress = rawBuffer.bindMemory(to: UInt8.self).baseAddress else {
+                    return
+                }
+
+                stream.next_in = UnsafeMutablePointer(mutating: baseAddress)
+                stream.avail_in = uInt(chunk.count)
+
+                repeat {
+                    stream.next_out = outputBuffer
+                    stream.avail_out = uInt(ArchiveExtractionUtilities.bufferSize)
+
+                    let status = inflate(&stream, Z_NO_FLUSH)
+                    switch status {
+                    case Z_OK, Z_STREAM_END:
+                        let producedBytes = ArchiveExtractionUtilities.bufferSize - Int(stream.avail_out)
+                        if producedBytes > 0 {
+                            let outputData = Data(bytes: outputBuffer, count: producedBytes)
+                            outputHandle.write(outputData)
+                            totalWritten += UInt64(producedBytes)
+                            checksum = updateCRC32(checksum, with: outputData)
+                        }
+
+                        if status == Z_STREAM_END {
+                            guard stream.avail_in == 0, remainingBytes == 0 else {
+                                throw NSError(
+                                    domain: "ZipArchiveExtractor",
+                                    code: 12,
+                                    userInfo: [NSLocalizedDescriptionKey: "ZIP deflate stream ended unexpectedly"]
+                                )
+                            }
+
+                            reachedStreamEnd = true
+                        }
+
+                    default:
+                        let message = stream.msg.map { String(cString: $0) } ?? "Unknown zlib error"
+                        throw NSError(
+                            domain: "ZipArchiveExtractor",
+                            code: 13,
+                            userInfo: [NSLocalizedDescriptionKey: "ZIP deflate failed: \(message)"]
+                        )
+                    }
+                } while stream.avail_in > 0 || stream.avail_out == 0
+            }
+
+            if reachedStreamEnd {
+                break
+            }
+        }
+
+        guard reachedStreamEnd || compressedSize == 0 else {
+            throw NSError(
+                domain: "ZipArchiveExtractor",
+                code: 14,
+                userInfo: [NSLocalizedDescriptionKey: "ZIP deflate stream did not terminate correctly"]
+            )
+        }
+
+        return (totalWritten, UInt32(checksum))
+    }
+
+    private static func findLastSignature(_ signature: [UInt8], in data: Data) -> Int? {
+        guard signature.count <= data.count else {
+            return nil
+        }
+
+        let lastStartIndex = data.count - signature.count
+        for startIndex in stride(from: lastStartIndex, through: 0, by: -1) {
+            if Array(data[startIndex..<(startIndex + signature.count)]) == signature {
+                return startIndex
+            }
+        }
+
+        return nil
+    }
+
+    private static func decodePath(from data: Data) -> String {
+        if let utf8Path = String(data: data, encoding: .utf8) {
+            return utf8Path
+        }
+
+        return String(decoding: data, as: UTF8.self)
+    }
+
+    private static func updateCRC32(_ checksum: uLong, with data: Data) -> uLong {
+        data.withUnsafeBytes { rawBuffer in
+            guard let baseAddress = rawBuffer.bindMemory(to: Bytef.self).baseAddress else {
+                return checksum
+            }
+
+            return crc32(checksum, baseAddress, uInt(data.count))
+        }
+    }
+
+    private static func unixFileMode(versionMadeBy: UInt16, externalAttributes: UInt32) -> UInt16? {
+        let hostIdentifier = UInt8((versionMadeBy >> 8) & 0xFF)
+        guard hostIdentifier == unixHostIdentifier else {
+            return nil
+        }
+
+        let mode = UInt16((externalAttributes >> 16) & 0xFFFF) & fileTypeMask
+        guard mode != 0 else {
+            return nil
+        }
+
+        return mode
+    }
+
+    private static func archiveFileSize(at path: String) throws -> UInt64 {
+        let attributes = try FileManager.default.attributesOfItem(atPath: path)
+        if let number = attributes[.size] as? NSNumber {
+            return number.uint64Value
+        }
+
+        if let value = attributes[.size] as? UInt64 {
+            return value
+        }
+
+        return 0
+    }
+}