@onekeyfe/react-native-range-downloader 3.0.81-alpha.1 → 3.0.81-alpha.10

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

@@ -6,7 +6,6 @@ import com.sniconnect.SniPinnedTransport
 import java.io.BufferedInputStream
 import java.io.File
 import java.io.FileInputStream
-import java.io.FileOutputStream
 import java.io.IOException
 import java.io.RandomAccessFile
 import java.security.MessageDigest
@@ -14,14 +13,29 @@ import java.util.UUID
 import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.TimeUnit
 import java.util.zip.ZipInputStream
+import javax.net.ssl.SSLException
+import kotlin.math.ceil
 import okhttp3.Call
 import okhttp3.OkHttpClient
 import okhttp3.Protocol
 import okhttp3.Request
 import okhttp3.Response
 import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
-import org.json.JSONArray
-import org.json.JSONObject
+
+private const val DEFAULT_FIRMWARE_DOWNLOAD_DEADLINE_SECONDS = 180.0
+private const val MAX_FIRMWARE_DOWNLOAD_DEADLINE_SECONDS = 24.0 * 60 * 60
+
+internal fun validateFirmwareDownloadDeadlineSeconds(value: Double?): Double {
+  val deadline = value ?: DEFAULT_FIRMWARE_DOWNLOAD_DEADLINE_SECONDS
+  require(
+    deadline.isFinite() &&
+      deadline > 0 &&
+      deadline <= MAX_FIRMWARE_DOWNLOAD_DEADLINE_SECONDS
+  ) {
+    "Invalid firmware download deadline"
+  }
+  return deadline
+}
 
 internal data class StoredFirmwareArtifact(
   val artifactRef: String,
@@ -44,22 +58,25 @@ private data class StagedFirmwareArchiveEntry(
 
 private data class FirmwareDownloadKey(
   val transactionId: String,
-  val expectedSha256: String,
+  val taskId: String,
+  val downloadToken: String,
 )
 
+private class FirmwareDownloadLock {
+  val monitor = Any()
+  var references = 0
+}
+
 internal object FirmwareArtifactStore {
   const val MAX_READ_BYTES = 256 * 1024
 
   private const val MAX_ARTIFACT_BYTES = 512L * 1024 * 1024
-  private const val MAX_LEASE_METADATA_BYTES = 1024L * 1024
-  private const val MAX_TOTAL_LEASE_REFS = 8192
-  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}$")
   private val identifierPattern = Regex("^[A-Za-z0-9._:-]{1,160}$")
-  private val downloadLocks = ConcurrentHashMap<FirmwareDownloadKey, Any>()
+  private val downloadLocks =
+    ConcurrentHashMap<FirmwareDownloadKey, FirmwareDownloadLock>()
   private val activeCalls =
     ConcurrentHashMap<String, MutableSet<Call>>()
   private val cancelledTransactions =
@@ -69,6 +86,7 @@ internal object FirmwareArtifactStore {
   private val leaseLock = Any()
   private val readerLock = Any()
   private val readers = mutableMapOf<String, OpenReader>()
+  private val leases = mutableMapOf<String, LeaseState>()
 
   private data class LeaseState(
     val transactionId: String,
@@ -97,26 +115,47 @@ 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,
-      validated.expectedSha256,
+      params.taskId,
+      validated.downloadToken,
     )
-    val lock = downloadLocks.computeIfAbsent(lockKey) { Any() }
-    markDownloadActive(validated.expectedSha256, 1)
+    val downloadLock = downloadLocks.compute(lockKey) { _, current ->
+      (current ?: FirmwareDownloadLock()).also {
+        it.references += 1
+      }
+    } ?: error("Firmware artifact lock is unavailable")
+    markDownloadActive(validated.downloadToken, 1)
     try {
-      return synchronized(lock) {
+      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
+        } else {
+          current.references -= 1
+          current.takeIf { it.references > 0 }
+        }
+      }
     }
   }
 
@@ -133,7 +172,7 @@ internal object FirmwareArtifactStore {
   fun discard(artifactRef: String) {
     val file = resolveArtifactFile(artifactRef)
     synchronized(leaseLock) {
-      require(loadLeasesLocked().values.none { artifactRef in it.artifactRefs }) {
+      require(leases.values.none { artifactRef in it.artifactRefs }) {
         "ARTIFACT_LEASED: firmware artifact is retained"
       }
     }
@@ -186,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" }
@@ -208,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
@@ -237,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,
@@ -280,10 +327,12 @@ 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,
   )
 
   private fun validateDownloadParams(
@@ -316,14 +365,20 @@ 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 =
+      validateFirmwareDownloadDeadlineSeconds(params.overallDeadlineSeconds)
     require(params.routeType == "domain" || params.routeType == "pinnedIp") {
       "Invalid firmware route type"
     }
@@ -339,8 +394,10 @@ 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,
     )
   }
 
@@ -348,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,
@@ -400,12 +468,10 @@ internal object FirmwareArtifactStore {
         .build()
     }
     val call = client.newCall(requestBuilder.build())
-    params.overallDeadlineSeconds?.let { deadline ->
-      require(deadline.isFinite() && deadline > 0) {
-        "Invalid firmware download deadline"
-      }
-      call.timeout().timeout(deadline.toLong().coerceAtLeast(1), TimeUnit.SECONDS)
-    }
+    call.timeout().timeout(
+      ceil(validated.overallDeadlineSeconds * 1000).toLong(),
+      TimeUnit.MILLISECONDS,
+    )
 
     registerCall(params.transactionId, call)
     try {
@@ -428,6 +494,12 @@ internal object FirmwareArtifactStore {
           error,
         )
       }
+      if (generateSequence<Throwable>(error) { it.cause }.any { it is SSLException }) {
+        throw IllegalStateException(
+          "ARTIFACT_TLS_FAILED: firmware TLS validation failed",
+          error,
+        )
+      }
       throw IllegalStateException(
         "ARTIFACT_NETWORK_FAILED: firmware request failed",
         error,
@@ -440,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,
@@ -462,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) {
@@ -475,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"
@@ -507,7 +582,8 @@ internal object FirmwareArtifactStore {
   private fun validateContentRange(
     value: String?,
     expectedStart: Long,
-    expectedTotal: Long,
+    expectedTotal: Long?,
+    maxBytes: Long,
   ): Boolean {
     val match = value
       ?.lowercase()
@@ -519,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(
@@ -563,13 +671,11 @@ internal object FirmwareArtifactStore {
       "Invalid firmware transactionId"
     }
     return synchronized(leaseLock) {
-      val leases = loadLeasesLocked()
       require(leases.size < 32) {
         "Too many firmware artifact leases"
       }
       val leaseRef = "fwlease:${UUID.randomUUID()}"
       leases[leaseRef] = LeaseState(transactionId, mutableSetOf())
-      saveLeasesLocked(leases)
       leaseRef
     }
   }
@@ -592,41 +698,18 @@ internal object FirmwareArtifactStore {
       "Invalid firmware lease disposition"
     }
     val transactionId = synchronized(leaseLock) {
-      val leases = loadLeasesLocked()
       val removed = leases.remove(validateLeaseRef(leaseRef))
       require(removed != null) {
         "Firmware artifact lease is unavailable"
       }
-      saveLeasesLocked(leases)
       removed.transactionId
     }
     cancelledTransactions.remove(transactionId)
-    downloadLocks.keys.removeIf { it.transactionId == transactionId }
-  }
-
-  fun reconcileLeases(activeLeaseRefs: Array<String>) {
-    require(activeLeaseRefs.size <= 32) {
-      "Too many active firmware artifact leases"
-    }
-    val active = activeLeaseRefs.mapTo(mutableSetOf()) {
-      validateLeaseRef(it)
-    }
-    require(active.size == activeLeaseRefs.size) {
-      "Duplicate active firmware artifact lease"
-    }
-    synchronized(leaseLock) {
-      val leases = loadLeasesLocked()
-      require(active.all { leases.containsKey(it) }) {
-        "Firmware artifact lease reconciliation is incomplete"
-      }
-      leases.keys.retainAll(active)
-      saveLeasesLocked(leases)
-    }
   }
 
   fun sweepOrphans(): Pair<Int, Long> {
     val retainedSha256 = synchronized(leaseLock) {
-      loadLeasesLocked().values
+      leases.values
         .flatMap { it.artifactRefs }
         .mapTo(mutableSetOf()) { it.removePrefix("fw:") }
     }
@@ -636,45 +719,31 @@ 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 || file.name == "leases.json") 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) {
     synchronized(leaseLock) {
-      require(loadLeasesLocked().containsKey(validateLeaseRef(leaseRef))) {
+      require(leases.containsKey(validateLeaseRef(leaseRef))) {
         "Firmware artifact lease is unavailable"
       }
     }
   }
 
+  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?,
@@ -684,7 +753,6 @@ internal object FirmwareArtifactStore {
       "Invalid firmware artifactRef"
     }
     synchronized(leaseLock) {
-      val leases = loadLeasesLocked()
       val lease = leases[validateLeaseRef(leaseRef)]
         ?: error("Firmware artifact lease is unavailable")
       if (transactionId != null) {
@@ -692,9 +760,7 @@ internal object FirmwareArtifactStore {
           "Firmware artifact lease transaction mismatch"
         }
       }
-      if (lease.artifactRefs.add(artifactRef)) {
-        saveLeasesLocked(leases)
-      }
+      lease.artifactRefs.add(artifactRef)
     }
   }
 
@@ -705,81 +771,6 @@ internal object FirmwareArtifactStore {
     return leaseRef
   }
 
-  private fun loadLeasesLocked(): MutableMap<String, LeaseState> {
-    val file = File(root, "leases.json")
-    if (!file.exists()) return mutableMapOf()
-    require(file.length() in 1..MAX_LEASE_METADATA_BYTES) {
-      "Firmware lease metadata is too large"
-    }
-    val envelope = JSONObject(file.readText(Charsets.UTF_8))
-    require(envelope.optInt("schemaVersion") == 1) {
-      "Unsupported firmware lease schema"
-    }
-    val result = mutableMapOf<String, LeaseState>()
-    val jsonLeases = envelope.getJSONObject("leases")
-    val keys = jsonLeases.keys()
-    while (keys.hasNext()) {
-      val leaseRef = validateLeaseRef(keys.next())
-      val jsonLease = jsonLeases.getJSONObject(leaseRef)
-      val transactionId = jsonLease.getString("transactionId")
-      require(identifierPattern.matches(transactionId)) {
-        "Invalid persisted firmware transactionId"
-      }
-      val jsonRefs = jsonLease.getJSONArray("artifactRefs")
-      require(jsonRefs.length() <= 4096) {
-        "Too many persisted firmware artifact refs"
-      }
-      val refs = mutableSetOf<String>()
-      for (index in 0 until jsonRefs.length()) {
-        val artifactRef = jsonRefs.getString(index)
-        require(artifactRefPattern.matches(artifactRef) && refs.add(artifactRef)) {
-          "Invalid persisted firmware artifact ref"
-        }
-      }
-      result[leaseRef] = LeaseState(transactionId, refs)
-    }
-    require(result.size <= 32) {
-      "Too many persisted firmware artifact leases"
-    }
-    require(result.values.sumOf { it.artifactRefs.size } <= MAX_TOTAL_LEASE_REFS) {
-      "Too many persisted firmware artifact refs"
-    }
-    return result
-  }
-
-  private fun saveLeasesLocked(leases: Map<String, LeaseState>) {
-    require(
-      leases.size <= 32 &&
-        leases.values.sumOf { it.artifactRefs.size } <= MAX_TOTAL_LEASE_REFS
-    ) {
-      "Firmware lease metadata is too large"
-    }
-    val jsonLeases = JSONObject()
-    leases.toSortedMap().forEach { (leaseRef, lease) ->
-      jsonLeases.put(
-        leaseRef,
-        JSONObject()
-          .put("transactionId", lease.transactionId)
-          .put("artifactRefs", JSONArray(lease.artifactRefs.sorted())),
-      )
-    }
-    val bytes = JSONObject()
-      .put("schemaVersion", 1)
-      .put("leases", jsonLeases)
-      .toString()
-      .toByteArray(Charsets.UTF_8)
-    require(bytes.size.toLong() <= MAX_LEASE_METADATA_BYTES) {
-      "Firmware lease metadata is too large"
-    }
-    val destination = File(root, "leases.json")
-    val temporary = File(root, ".leases-${UUID.randomUUID()}.tmp")
-    FileOutputStream(temporary).use { output ->
-      output.write(bytes)
-      output.fd.sync()
-    }
-    Os.rename(temporary.absolutePath, destination.absolutePath)
-  }
-
   private fun markDownloadActive(sha256: String, delta: Int) {
     synchronized(activeDownloadLock) {
       val count = (activeDownloadCounts[sha256] ?: 0) + delta
@@ -804,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)