@onekeyfe/react-native-range-downloader 3.0.81-alpha.7 → 3.0.81-alpha.9

package/ReactNativeRangeDownloader.podspec

@@ -23,7 +23,7 @@ Pod::Spec.new do |s|
   s.dependency 'React-jsi'
   s.dependency 'React-callinvoker'
   s.dependency 'ReactNativeNativeLogger'
-  s.dependency 'SniConnect', package["version"]
+  s.dependency 'SniConnect', package["peerDependencies"]["@onekeyfe/react-native-sni-connect"]
   s.public_header_files = "ios/FirmwareArchiveMinizipBridge.h"
   s.pod_target_xcconfig = {
     'HEADER_SEARCH_PATHS' => '"$(PODS_ROOT)/SSZipArchive/SSZipArchive/minizip"',

package/android/src/main/java/com/margelo/nitro/reactnativerangedownloader/FirmwareArchiveRules.kt

@@ -78,24 +78,31 @@ internal object FirmwareArchiveRules {
 
   fun validateCentralDirectory(
     file: File,
-    requirements: List<FirmwareArchiveExpectedEntry>,
+    requirements: List<FirmwareArchiveExpectedEntry>?,
   ): List<FirmwareArchiveCentralEntry> {
     val entries = scanCentralDirectory(file)
-    require(entries.size == requirements.size) {
+    require(requirements == null || entries.size == requirements.size) {
       "Firmware archive has missing or extra entries"
     }
-    val requirementsByName = requirements.associateBy { it.entryName }
+    val requirementsByName = requirements?.associateBy { it.entryName }.orEmpty()
     val names = mutableSetOf<String>()
     val canonicalNames = mutableSetOf<String>()
+    var totalSize = 0L
     entries.forEach { entry ->
       val requirement = requirementsByName[entry.name]
-        ?: error("Firmware archive contains an unexpected entry")
-      val expectedSize = requirement.expectedSize.toLong()
+      require(requirements == null || requirement != null) {
+        "Firmware archive contains an unexpected entry"
+      }
+      val expectedSize = requirement?.expectedSize?.toLong()
+        ?: entry.uncompressedSize
+      totalSize = Math.addExact(totalSize, entry.uncompressedSize)
       require(
         names.add(entry.name) &&
           validatePortableName(entry.name, canonicalNames) &&
           entry.uncompressedSize == expectedSize &&
           entry.uncompressedSize > 0 &&
+          entry.uncompressedSize <= MAX_ARCHIVE_ENTRY_BYTES &&
+          totalSize <= MAX_ARCHIVE_EXPANDED_BYTES &&
           entry.compressedSize in 0..MAX_ARCHIVE_EXPANDED_BYTES &&
           entry.uncompressedSize <=
           Math.multiplyExact(entry.compressedSize.coerceAtLeast(1), 1000) &&

package/android/src/main/java/com/margelo/nitro/reactnativerangedownloader/FirmwareArtifactOrphanSweep.kt

@@ -0,0 +1,111 @@
+package com.margelo.nitro.reactnativerangedownloader
+
+import java.io.File
+
+internal const val FIRMWARE_ARTIFACT_FINAL_GRACE_MS = 24L * 60 * 60 * 1000
+internal const val FIRMWARE_ARTIFACT_PARTIAL_GRACE_MS = 7L * 24 * 60 * 60 * 1000
+internal const val FIRMWARE_ARTIFACT_SCRATCH_GRACE_MS =
+  FIRMWARE_ARTIFACT_PARTIAL_GRACE_MS
+
+private val firmwareArtifactSha256Pattern = Regex("^[a-f0-9]{64}$")
+private val firmwareArchiveScratchPattern = Regex(
+  "^archive-[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-" +
+    "[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$",
+)
+private val firmwarePromoteScratchPattern = Regex(
+  "^\\.promote-[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-" +
+    "[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$",
+)
+
+private fun File.isSymbolicLinkEntry(): Boolean = try {
+  val canonicalParent = parentFile?.canonicalFile
+  val entryFromCanonicalParent = canonicalParent?.let { File(it, name) } ?: this
+  entryFromCanonicalParent.canonicalFile != entryFromCanonicalParent.absoluteFile
+} catch (_: Exception) {
+  true
+}
+
+private fun firmwareArtifactEntrySize(entry: File): Long {
+  if (entry.isSymbolicLinkEntry()) return 0
+  if (entry.isFile) return entry.length()
+  if (!entry.isDirectory) return 0
+  return entry.listFiles()?.sumOf(::firmwareArtifactEntrySize) ?: 0
+}
+
+private fun deleteFirmwareArtifactEntry(entry: File): Boolean {
+  if (entry.isSymbolicLinkEntry()) return entry.delete()
+  if (entry.isDirectory) {
+    val children = entry.listFiles() ?: return false
+    if (children.any { !deleteFirmwareArtifactEntry(it) }) return false
+  }
+  return entry.delete()
+}
+
+private fun firmwareArtifactEntryExceededGrace(
+  entry: File,
+  nowMs: Long,
+  graceMs: Long,
+): Boolean {
+  val modifiedAt = entry.lastModified()
+  return modifiedAt > 0 && modifiedAt <= nowMs && nowMs - modifiedAt >= graceMs
+}
+
+internal fun sweepFirmwareArtifactOrphansAtRoot(
+  root: File,
+  retainedSha256: Set<String>,
+  activeSha256: Set<String>,
+  openPaths: Set<String>,
+  nowMs: Long = System.currentTimeMillis(),
+): Pair<Int, Long> {
+  var deletedFiles = 0
+  var deletedBytes = 0L
+  root.listFiles()?.forEach { entry ->
+    val isSymbolicLink = entry.isSymbolicLinkEntry()
+    val isArchiveScratch = firmwareArchiveScratchPattern.matches(entry.name)
+    val isPromoteScratch = firmwarePromoteScratchPattern.matches(entry.name)
+    val isScratchCandidate = !isSymbolicLink &&
+      ((isArchiveScratch && entry.isDirectory) ||
+        (isPromoteScratch && entry.isFile))
+    if (isScratchCandidate) {
+      if (
+        firmwareArtifactEntryExceededGrace(
+          entry,
+          nowMs,
+          FIRMWARE_ARTIFACT_SCRATCH_GRACE_MS,
+        )
+      ) {
+        val size = firmwareArtifactEntrySize(entry)
+        if (deleteFirmwareArtifactEntry(entry)) {
+          deletedFiles += 1
+          deletedBytes += size
+        }
+      }
+      return@forEach
+    }
+
+    if (!entry.isFile || isSymbolicLink || entry.name.length < 64) return@forEach
+    val sha256 = entry.name.take(64)
+    if (
+      !firmwareArtifactSha256Pattern.matches(sha256) ||
+      sha256 in retainedSha256 ||
+      sha256 in activeSha256 ||
+      entry.absolutePath in openPaths
+    ) {
+      return@forEach
+    }
+    val grace = if (entry.name.endsWith(".bin")) {
+      FIRMWARE_ARTIFACT_FINAL_GRACE_MS
+    } else if (entry.name.endsWith(".partial")) {
+      FIRMWARE_ARTIFACT_PARTIAL_GRACE_MS
+    } else {
+      return@forEach
+    }
+    if (!firmwareArtifactEntryExceededGrace(entry, nowMs, grace)) return@forEach
+    val size = entry.length()
+    if (entry.delete()) {
+      deletedFiles += 1
+      deletedBytes += size
+    }
+  }
+  return deletedFiles to deletedBytes
+}

package/android/src/main/java/com/margelo/nitro/reactnativerangedownloader/FirmwareArtifactStore.kt

@@ -57,7 +57,9 @@ private data class StagedFirmwareArchiveEntry(
 )
 
 private data class FirmwareDownloadKey(
-  val expectedSha256: String,
+  val transactionId: String,
+  val taskId: String,
+  val downloadToken: String,
 )
 
 private class FirmwareDownloadLock {
@@ -69,8 +71,6 @@ internal object FirmwareArtifactStore {
   const val MAX_READ_BYTES = 256 * 1024
 
   private const val MAX_ARTIFACT_BYTES = 512L * 1024 * 1024
-  private const val FINAL_ARTIFACT_GRACE_MS = 24L * 60 * 60 * 1000
-  private const val PARTIAL_ARTIFACT_GRACE_MS = 7L * 24 * 60 * 60 * 1000
   private val sha256Pattern = Regex("^[a-fA-F0-9]{64}$")
   private val artifactRefPattern = Regex("^fw:[a-f0-9]{64}$")
   private val leaseRefPattern = Regex("^fwlease:[a-f0-9-]{36}$")
@@ -115,27 +115,39 @@ internal object FirmwareArtifactStore {
     check(!cancelledTransactions.contains(params.transactionId)) {
       "ARTIFACT_CANCELLED: firmware artifact download was cancelled"
     }
-    retainExpectedArtifact(
-      leaseRef = params.leaseRef,
-      transactionId = params.transactionId,
-      artifactRef = "fw:${validated.expectedSha256}",
+    validated.expectedSha256?.let {
+      retainExpectedArtifact(
+        leaseRef = params.leaseRef,
+        transactionId = params.transactionId,
+        artifactRef = "fw:$it",
+      )
+    } ?: requireLeaseTransaction(params.leaseRef, params.transactionId)
+    val lockKey = FirmwareDownloadKey(
+      params.transactionId,
+      params.taskId,
+      validated.downloadToken,
     )
-    val lockKey = FirmwareDownloadKey(validated.expectedSha256)
     val downloadLock = downloadLocks.compute(lockKey) { _, current ->
       (current ?: FirmwareDownloadLock()).also {
         it.references += 1
       }
     } ?: error("Firmware artifact lock is unavailable")
-    markDownloadActive(validated.expectedSha256, 1)
+    markDownloadActive(validated.downloadToken, 1)
     try {
-      return synchronized(downloadLock.monitor) {
+      val artifact = synchronized(downloadLock.monitor) {
         check(!cancelledTransactions.contains(params.transactionId)) {
           "ARTIFACT_CANCELLED: firmware artifact download was cancelled"
         }
         downloadLocked(params, validated)
       }
+      retainExpectedArtifact(
+        leaseRef = params.leaseRef,
+        transactionId = params.transactionId,
+        artifactRef = artifact.artifactRef,
+      )
+      return artifact
     } finally {
-      markDownloadActive(validated.expectedSha256, -1)
+      markDownloadActive(validated.downloadToken, -1)
       downloadLocks.compute(lockKey) { _, current ->
         if (current !== downloadLock) {
           current
@@ -213,16 +225,19 @@ internal object FirmwareArtifactStore {
   fun materializeArchive(
     leaseRef: String,
     artifactRef: String,
-    expectedEntries: Array<FirmwareArchiveExpectedEntry>,
+    expectedEntries: Array<FirmwareArchiveExpectedEntry>?,
   ): List<StoredFirmwareArchiveEntry> {
     requireLease(leaseRef)
     val archiveFile = resolveArtifactFile(artifactRef)
-    val requirements = FirmwareArchiveRules.validateRequirements(expectedEntries)
+    val requirements = expectedEntries?.let {
+      FirmwareArchiveRules.validateRequirements(it)
+    }
     val centralEntries = FirmwareArchiveRules.validateCentralDirectory(
       archiveFile,
       requirements,
     )
-    val requirementsByName = requirements.associateBy { it.entryName }
+    val requirementsByName = requirements?.associateBy { it.entryName }.orEmpty()
+    val centralEntriesByName = centralEntries.associateBy { it.name }
     val centralNames = centralEntries.mapTo(mutableSetOf()) { it.name }
     val scratchDir = File(root, "archive-${UUID.randomUUID()}")
     check(scratchDir.mkdirs()) { "Firmware archive scratch directory cannot be created" }
@@ -235,16 +250,18 @@ internal object FirmwareArtifactStore {
           require(!zipEntry.isDirectory) {
             "Firmware archive contains an unexpected directory"
           }
-          val requirement = requirementsByName[zipEntry.name]
+          val centralEntry = centralEntriesByName[zipEntry.name]
             ?: error("Firmware archive contains an unexpected entry")
+          val requirement = requirementsByName[zipEntry.name]
           require(
             centralNames.contains(zipEntry.name) &&
               entryNames.add(zipEntry.name)
           ) {
             "Firmware archive contains a duplicate or mismatched entry"
           }
-          val expectedSize = requirement.expectedSize.toLong()
-          val expectedSha256 = requirement.expectedSha256.lowercase()
+          val expectedSize = requirement?.expectedSize?.toLong()
+            ?: centralEntry.uncompressedSize
+          val expectedSha256 = requirement?.expectedSha256?.lowercase()
           val scratchFile = File(scratchDir, "${staged.size}.entry")
           val digest = MessageDigest.getInstance("SHA-256")
           var entrySize = 0L
@@ -264,11 +281,14 @@ internal object FirmwareArtifactStore {
             output.fd.sync()
           }
           val sha256 = digest.digest().toHex()
-          require(entrySize == expectedSize && sha256 == expectedSha256) {
+          require(
+            entrySize == expectedSize &&
+              (expectedSha256 == null || sha256 == expectedSha256)
+          ) {
             "Firmware archive entry integrity mismatch"
           }
           staged += StagedFirmwareArchiveEntry(
-            entryName = requirement.entryName,
+            entryName = zipEntry.name,
             size = entrySize,
             sha256 = sha256,
             file = scratchFile,
@@ -307,9 +327,10 @@ internal object FirmwareArtifactStore {
   }
 
   private data class ValidatedDownload(
-    val expectedSize: Long,
+    val expectedSize: Long?,
     val maxBytes: Long,
-    val expectedSha256: String,
+    val expectedSha256: String?,
+    val downloadToken: String,
     val hostname: String,
     val overallDeadlineSeconds: Double,
   )
@@ -344,12 +365,16 @@ internal object FirmwareArtifactStore {
     ) {
       "Firmware URL must use HTTPS port 443"
     }
-    val expectedSize = params.expectedSize.toExactPositiveLong("expectedSize")
+    val expectedSize = params.expectedSize?.toExactPositiveLong("expectedSize")
     val maxBytes = params.maxBytes.toExactPositiveLong("maxBytes")
-    require(maxBytes == expectedSize && maxBytes <= MAX_ARTIFACT_BYTES) {
+    require(
+      maxBytes <= MAX_ARTIFACT_BYTES &&
+        (expectedSize == null || expectedSize <= maxBytes)
+    ) {
       "Invalid firmware maxBytes"
     }
-    require(sha256Pattern.matches(params.expectedSha256)) {
+    val expectedSha256 = params.expectedSha256?.lowercase()
+    require(expectedSha256 == null || sha256Pattern.matches(expectedSha256)) {
       "Invalid firmware artifact SHA-256"
     }
     val overallDeadlineSeconds =
@@ -369,7 +394,8 @@ internal object FirmwareArtifactStore {
     return ValidatedDownload(
       expectedSize = expectedSize,
       maxBytes = maxBytes,
-      expectedSha256 = params.expectedSha256.lowercase(),
+      expectedSha256 = expectedSha256,
+      downloadToken = expectedSha256 ?: sha256(params.url),
       hostname = url.host,
       overallDeadlineSeconds = overallDeadlineSeconds,
     )
@@ -379,26 +405,37 @@ internal object FirmwareArtifactStore {
     params: FirmwareArtifactDownloadParams,
     validated: ValidatedDownload,
   ): StoredFirmwareArtifact {
-    val finalFile = artifactFile(validated.expectedSha256)
-    validateStoredArtifactOrNull(
-      finalFile,
-      validated.expectedSize,
-      validated.expectedSha256,
-    )?.let { return it }
+    validated.expectedSha256?.let { expectedSha256 ->
+      val finalFile = artifactFile(expectedSha256)
+      validateDownloadedArtifactOrNull(
+        finalFile,
+        validated.expectedSize,
+        expectedSha256,
+        validated.maxBytes,
+      )?.let { return it }
+    }
 
+    val transactionToken = sha256(params.transactionId).take(16)
     val partialFile = File(
       root,
-      "${validated.expectedSha256}.${params.taskId}.partial",
+      "${validated.downloadToken}.${params.taskId}.$transactionToken.partial",
     )
-    if (partialFile.length() > validated.expectedSize) {
+    if (validated.expectedSha256 == null && partialFile.length() > 0) {
+      check(partialFile.delete()) { "Unverified firmware partial cannot be removed" }
+    } else if (partialFile.length() > validated.maxBytes) {
       check(partialFile.delete()) { "Invalid firmware partial cannot be removed" }
     }
-    if (partialFile.length() == validated.expectedSize) {
-      validateStoredArtifactOrNull(
+    if (
+      validated.expectedSize != null &&
+      partialFile.length() == validated.expectedSize
+    ) {
+      validateDownloadedArtifactOrNull(
         partialFile,
         validated.expectedSize,
         validated.expectedSha256,
+        validated.maxBytes,
       )?.let {
+        val finalFile = artifactFile(it.sha256)
         promoteAtomically(partialFile, finalFile)
         return StoredFirmwareArtifact(
           it.artifactRef,
@@ -475,15 +512,17 @@ internal object FirmwareArtifactStore {
     }
 
     val artifact = try {
-      validateStoredArtifact(
+      validateDownloadedArtifact(
         partialFile,
         validated.expectedSize,
         validated.expectedSha256,
+        validated.maxBytes,
       )
     } catch (error: Throwable) {
       partialFile.delete()
       throw error
     }
+    val finalFile = artifactFile(artifact.sha256)
     promoteAtomically(partialFile, finalFile)
     return StoredFirmwareArtifact(
       artifact.artifactRef,
@@ -497,7 +536,7 @@ internal object FirmwareArtifactStore {
     response: Response,
     partialFile: File,
     resumeOffset: Long,
-    expectedSize: Long,
+    expectedSize: Long?,
     maxBytes: Long,
   ) {
     require(response.code == 200 || response.code == 206) {
@@ -510,6 +549,7 @@ internal object FirmwareArtifactStore {
           response.header("Content-Range"),
           if (append) resumeOffset else 0,
           expectedSize,
+          maxBytes,
         )
       ) {
         "ARTIFACT_PROTOCOL_INVALID: firmware resume Content-Range is invalid"
@@ -542,7 +582,8 @@ internal object FirmwareArtifactStore {
   private fun validateContentRange(
     value: String?,
     expectedStart: Long,
-    expectedTotal: Long,
+    expectedTotal: Long?,
+    maxBytes: Long,
   ): Boolean {
     val match = value
       ?.lowercase()
@@ -554,7 +595,39 @@ internal object FirmwareArtifactStore {
     return start == expectedStart &&
       end >= start &&
       end < total &&
-      total == expectedTotal
+      (expectedTotal?.let { total == it } ?: (total in 1..maxBytes))
+  }
+
+  private fun validateDownloadedArtifactOrNull(
+    file: File,
+    expectedSize: Long?,
+    expectedSha256: String?,
+    maxBytes: Long,
+  ): StoredFirmwareArtifact? = try {
+    validateDownloadedArtifact(file, expectedSize, expectedSha256, maxBytes)
+  } catch (_: Throwable) {
+    null
+  }
+
+  private fun validateDownloadedArtifact(
+    file: File,
+    expectedSize: Long?,
+    expectedSha256: String?,
+    maxBytes: Long,
+  ): StoredFirmwareArtifact {
+    val size = file.length()
+    require(
+      file.isFile &&
+        size in 1..maxBytes &&
+        (expectedSize == null || size == expectedSize)
+    ) {
+      "ARTIFACT_INTEGRITY_FAILED: firmware artifact size mismatch"
+    }
+    val sha256 = hashFile(file)
+    require(expectedSha256 == null || sha256 == expectedSha256) {
+      "ARTIFACT_INTEGRITY_FAILED: firmware artifact SHA-256 mismatch"
+    }
+    return StoredFirmwareArtifact("fw:$sha256", size, sha256, file)
   }
 
   private fun validateStoredArtifactOrNull(
@@ -646,35 +719,12 @@ internal object FirmwareArtifactStore {
     val openFiles = synchronized(readerLock) {
       readers.values.mapTo(mutableSetOf()) { it.file.absolutePath }
     }
-    val now = System.currentTimeMillis()
-    var deletedFiles = 0
-    var deletedBytes = 0L
-    root.listFiles()?.forEach { file ->
-      if (!file.isFile) return@forEach
-      val sha256 = file.name.take(64)
-      if (
-        !sha256Pattern.matches(sha256) ||
-        sha256 in retainedSha256 ||
-        sha256 in activeSha256 ||
-        file.absolutePath in openFiles
-      ) {
-        return@forEach
-      }
-      val grace = if (file.name.endsWith(".bin")) {
-        FINAL_ARTIFACT_GRACE_MS
-      } else if (file.name.endsWith(".partial")) {
-        PARTIAL_ARTIFACT_GRACE_MS
-      } else {
-        return@forEach
-      }
-      if (now - file.lastModified() < grace) return@forEach
-      val size = file.length()
-      if (file.delete()) {
-        deletedFiles += 1
-        deletedBytes += size
-      }
-    }
-    return deletedFiles to deletedBytes
+    return sweepFirmwareArtifactOrphansAtRoot(
+      root = root,
+      retainedSha256 = retainedSha256,
+      activeSha256 = activeSha256,
+      openPaths = openFiles,
+    )
   }
 
   private fun requireLease(leaseRef: String) {
@@ -685,6 +735,15 @@ internal object FirmwareArtifactStore {
     }
   }
 
+  private fun requireLeaseTransaction(leaseRef: String, transactionId: String) {
+    synchronized(leaseLock) {
+      val lease = leases[validateLeaseRef(leaseRef)]
+      require(lease?.transactionId == transactionId) {
+        "Firmware artifact lease transaction mismatch"
+      }
+    }
+  }
+
   private fun retainExpectedArtifact(
     leaseRef: String,
     transactionId: String?,
@@ -736,6 +795,11 @@ internal object FirmwareArtifactStore {
     return digest.digest().toHex()
   }
 
+  private fun sha256(value: String): String =
+    MessageDigest.getInstance("SHA-256")
+      .digest(value.toByteArray(Charsets.UTF_8))
+      .toHex()
+
   private fun promoteAtomically(source: File, destination: File) {
     destination.parentFile?.mkdirs()
     Os.rename(source.absolutePath, destination.absolutePath)

package/android/src/main/java/com/margelo/nitro/reactnativerangedownloader/ReactNativeRangeDownloader.kt

@@ -272,7 +272,7 @@ class ReactNativeRangeDownloader : HybridReactNativeRangeDownloaderSpec() {
 
   override fun getFirmwareArtifactCapabilities(): FirmwareArtifactCapabilities {
     return FirmwareArtifactCapabilities(
-      firmwareArtifactProtocolVersion = 2.0,
+      firmwareArtifactProtocolVersion = 3.0,
       supportedRouteTypes = arrayOf("domain", "pinnedIp"),
       supportsArchiveMaterialization = true,
       maxReadBytes = FirmwareArtifactStore.MAX_READ_BYTES.toDouble(),

package/android/src/test/java/com/margelo/nitro/reactnativerangedownloader/FirmwareArchiveRulesTest.kt

@@ -1,10 +1,19 @@
 package com.margelo.nitro.reactnativerangedownloader
 
+import java.io.File
+import java.io.FileOutputStream
+import java.util.zip.ZipEntry
+import java.util.zip.ZipOutputStream
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertThrows
+import org.junit.Rule
 import org.junit.Test
+import org.junit.rules.TemporaryFolder
 
 class FirmwareArchiveRulesTest {
+  @get:Rule
+  val temporaryFolder = TemporaryFolder()
+
   private fun entry(
     artifactId: String = "resource-entry",
     entryName: String = "assets/icon.png",
@@ -72,4 +81,34 @@ class FirmwareArchiveRulesTest {
       )
     }
   }
+
+  @Test
+  fun acceptsPortableEntriesWithoutExpectedIntegrityMetadata() {
+    val archive = createArchive("assets/icon.png", byteArrayOf(1, 2, 3))
+
+    val entries = FirmwareArchiveRules.validateCentralDirectory(archive, null)
+
+    assertEquals(1, entries.size)
+    assertEquals("assets/icon.png", entries.single().name)
+    assertEquals(3, entries.single().uncompressedSize)
+  }
+
+  @Test
+  fun rejectsTraversalWithoutExpectedIntegrityMetadata() {
+    val archive = createArchive("../icon.png", byteArrayOf(1))
+
+    assertThrows(IllegalArgumentException::class.java) {
+      FirmwareArchiveRules.validateCentralDirectory(archive, null)
+    }
+  }
+
+  private fun createArchive(entryName: String, content: ByteArray): File {
+    val archive = temporaryFolder.newFile("firmware.zip")
+    ZipOutputStream(FileOutputStream(archive)).use { zip ->
+      zip.putNextEntry(ZipEntry(entryName))
+      zip.write(content)
+      zip.closeEntry()
+    }
+    return archive
+  }
 }