react-native-ota-client 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2026 boyka
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/OtaSdk.podspec

@@ -0,0 +1,20 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "OtaSdk"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported }
+  s.source       = { :git => "https://github.com/arjunnarangali/react-native-ota-client.git", :tag => "v#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm,swift,cpp}"
+  s.private_header_files = "ios/**/*.h"
+
+  install_modules_dependencies(s)
+end

package/README.md

@@ -1,3 +1,137 @@
-# Temporary Holding Version
+# react-native-ota-client
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Android OTA update support for React Native applications using the New Architecture and Hermes. The SDK checks for signed releases, verifies the release manifest and packaged bundle, stages verified updates, selects the bundle on cold start, and rolls back a release that does not confirm healthy.
+
+OTA can update JavaScript and bundled assets. Native code, permissions, React Native/Hermes versions, and Codegen contract changes require a new APK.
+
+## Requirements and support
+
+- Android only; iOS OTA support is not implemented.
+- React Native 0.88.x, Android New Architecture, and Hermes.
+- Android min SDK 24.
+- A host application with a release-signing setup and a public verification key.
+
+## Installation
+
+```sh
+npm install react-native-ota-client
+```
+
+React Native autolinking discovers the Android package. Rebuild the native application after installation; Metro alone cannot add native code.
+
+For local development, the example workspace consumes the SDK source directly. In a host app, install the package using the command above.
+
+## JavaScript API
+
+```tsx
+import { OTAUpdates, type OtaUpdateStatus } from 'react-native-ota-client';
+
+const status: OtaUpdateStatus = await OTAUpdates.getStatus();
+const result = await OTAUpdates.checkForUpdate();
+await OTAUpdates.markUpdateSuccessful();
+await OTAUpdates.closeAppToApplyUpdate();
+```
+
+`markUpdateSuccessful()` should run after the first React screen has mounted. `closeAppToApplyUpdate()` only succeeds when a verified update is staged and waiting for a restart. Debug applications report OTA activation as disabled because Metro supplies the JavaScript bundle.
+
+The package also retains the generated-template `multiply()` example; it is not part of the OTA API.
+
+## Android configuration
+
+Configure the SDK once in the host application's `Application` class. Initialize it in `onCreate()` before calling `loadReactNative()`, and provide the selected bundle path to React Native's host configuration. The SDK's own `BuildConfig.DEBUG` is not the consumer app's build type.
+
+```kotlin
+import android.app.Application
+import com.facebook.react.PackageList
+import com.facebook.react.ReactApplication
+import com.facebook.react.ReactHost
+import com.facebook.react.ReactNativeApplicationEntryPoint.loadReactNative
+import com.facebook.react.defaults.DefaultReactHost.getDefaultReactHost
+import com.otasdk.OtaSdkUpdates
+
+class MainApplication : Application(), ReactApplication {
+  override val reactHost: ReactHost by lazy {
+    getDefaultReactHost(
+      context = applicationContext,
+      packageList = PackageList(this).packages,
+      jsBundleFilePath = OtaSdkUpdates.bundlePathForReactHost(),
+    )
+  }
+
+  override fun onCreate() {
+    super.onCreate()
+    val publicKeyPem = resources.openRawResource(R.raw.ota_publisher_public).use { it.readBytes() }
+    val config = otaSdkConfigForCurrentVariant(publicKeyPem)
+    OtaSdkUpdates.initialize(this, config)
+    OtaSdkUpdates.beginProcess()
+    loadReactNative(this)
+  }
+}
+```
+
+Call `beginProcess()` before `loadReactNative()` so the selected bundle is ready when the JS runtime starts. `bundlePathForReactHost()` returns `null` when the APK bundle should be used.
+
+The `ota_publisher_public` Android raw resource contains only the verification key. It may be placed in `src/main/res/raw/` when shared by all variants, or in a flavor-specific source set such as `src/development/res/raw/` when variants use different keys. Never package the publisher's signing private key in the app or SDK.
+
+### Flavor-specific configuration
+
+Define each environment as an Android `productFlavor` and provide the SDK values as flavor-specific `BuildConfig` fields. The flavor controls the app ID, runtime version, channel, base version, and public key source set; use distinct runtime versions and channels when environments must receive separate updates. For example:
+
+```groovy
+android {
+    flavorDimensions "environment"
+    productFlavors {
+        development {
+            dimension "environment"
+            applicationIdSuffix ".dev"
+            buildConfigField "String", "OTA_RUNTIME_VERSION", '"rn-0.88-android-dev"'
+            buildConfigField "String", "OTA_CHANNEL", '"development"'
+            buildConfigField "int", "OTA_BASE_VERSION", "0"
+        }
+        staging {
+            dimension "environment"
+            applicationIdSuffix ".staging"
+            buildConfigField "String", "OTA_RUNTIME_VERSION", '"rn-0.88-android-staging"'
+            buildConfigField "String", "OTA_CHANNEL", '"staging"'
+            buildConfigField "int", "OTA_BASE_VERSION", "0"
+        }
+    }
+}
+```
+
+The host application's configuration helper should import `com.otasdk.OtaSdkConfig` and build a fully populated config for the selected variant. The `OTA_*` field names and types must match those read by that helper. Set `react.debuggableVariants` for every flavor's debug variants (for example, `developmentDebug` and `stagingDebug`) so React Native uses Metro for those builds. `BuildConfig.DEBUG` is supplied by the selected build type, while `BuildConfig.APPLICATION_ID` includes any flavor suffix.
+
+## Native startup operations
+
+`OtaSdkUpdates` exposes the Android startup and host integration API:
+
+- `initialize(context, config)` — configure the manager once before use.
+- `beginProcess()` — select/rollback the startup bundle before React Native starts.
+- `bundlePathForReactHost()` — return the selected bundle path, or `null` for the APK bundle.
+- `status()`, `checkForUpdate()`, `markHealthy()`, and `closeAppForUpdate(activity)` — operations used by the TurboModule implementation.
+
+The SDK autolinks a single `OtaSdkPackage` containing both the sample `OtaSdk` TurboModule and the OTA `OTAUpdates` TurboModule. Do not add another manual package registration in the host app.
+
+## Development and verification
+
+For implementation architecture, behavioral invariants, suggested change workflow, and verification commands, see the [coding-agent implementation guide](agent.md).
+
+From the SDK package directory, install the locked Yarn dependencies with the bundled Yarn executable and build its example:
+
+```sh
+node .yarn/releases/yarn-4.18.1.cjs install
+node .yarn/releases/yarn-4.18.1.cjs workspace react-native-ota-client-example build:android
+```
+
+The library unit tests run through the example's Gradle project:
+
+```sh
+cd example/android
+./gradlew :react-native-ota-client:testDebugUnitTest
+```
+
+Build a development debug app to verify native linking and Metro. OTA activation requires a release APK; debug builds use Metro and report activation as disabled.
+
+## License
+
+MIT

package/android/build.gradle

@@ -0,0 +1,37 @@
+ext.OtaSdk = [
+  minSdkVersion: 24,
+  compileSdkVersion: 36
+]
+
+ext.getExtOrDefault = { prop ->
+  if (rootProject.ext.has(prop)) {
+    return rootProject.ext.get(prop)
+  }
+
+  return OtaSdk[prop]
+}
+
+
+apply plugin: "com.android.library"
+
+if (project.extensions.findByName("kotlin") == null) {
+  apply plugin: "kotlin-android"
+}
+
+
+apply plugin: "com.facebook.react"
+
+android {
+  namespace "com.otasdk"
+
+  compileSdkVersion getExtOrDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrDefault("minSdkVersion")
+  }
+}
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  testImplementation("junit:junit:4.13.2")
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/java/com/otasdk/OtaActivationPolicy.kt

@@ -0,0 +1,74 @@
+package com.otasdk
+
+/** Pure state transitions for selecting a pending update and reverting an unconfirmed boot. */
+internal data class OtaActivationState(
+    val activeReleaseId: String? = null,
+    val activeVersion: Int,
+    val pendingReleaseId: String? = null,
+    val pendingVersion: Int? = null,
+    val previousReleaseId: String? = null,
+    val previousVersion: Int? = null,
+    val pendingLaunchAttempted: Boolean = false,
+    val failedReleaseId: String? = null,
+)
+
+internal data class OtaStartupTransition(
+    val state: OtaActivationState,
+    val selectedReleaseId: String?,
+    val failedReleaseId: String? = null,
+)
+
+internal object OtaActivationPolicy {
+  fun beginStartup(state: OtaActivationState): OtaStartupTransition {
+    val pendingId = state.pendingReleaseId ?: return OtaStartupTransition(state, state.activeReleaseId)
+
+    if (!state.pendingLaunchAttempted) {
+      return OtaStartupTransition(
+          state = state.copy(pendingLaunchAttempted = true),
+          selectedReleaseId = pendingId,
+      )
+    }
+
+    val rolledBack =
+        state.copy(
+            activeReleaseId = state.previousReleaseId,
+            activeVersion = state.previousVersion ?: state.activeVersion,
+            pendingReleaseId = null,
+            pendingVersion = null,
+            previousReleaseId = null,
+            previousVersion = null,
+            pendingLaunchAttempted = false,
+            failedReleaseId = pendingId,
+        )
+    return OtaStartupTransition(
+        state = rolledBack,
+        selectedReleaseId = rolledBack.activeReleaseId,
+        failedReleaseId = pendingId,
+    )
+  }
+
+  fun stage(state: OtaActivationState, releaseId: String, version: Int): OtaActivationState =
+      state.copy(
+          pendingReleaseId = releaseId,
+          pendingVersion = version,
+          previousReleaseId = state.activeReleaseId,
+          previousVersion = state.activeVersion,
+          pendingLaunchAttempted = false,
+      )
+
+  fun markHealthy(state: OtaActivationState): OtaActivationState {
+    val pendingId = state.pendingReleaseId ?: return state
+    if (!state.pendingLaunchAttempted) return state
+
+    return state.copy(
+        activeReleaseId = pendingId,
+        activeVersion = state.pendingVersion ?: state.activeVersion,
+        pendingReleaseId = null,
+        pendingVersion = null,
+        previousReleaseId = null,
+        previousVersion = null,
+        pendingLaunchAttempted = false,
+        failedReleaseId = null,
+    )
+  }
+}

package/android/src/main/java/com/otasdk/OtaBundleInstaller.kt

@@ -0,0 +1,280 @@
+package com.otasdk
+
+import java.io.BufferedInputStream
+import java.io.File
+import java.io.FileOutputStream
+import java.security.MessageDigest
+import java.util.Enumeration
+import java.util.Locale
+import java.util.zip.ZipEntry
+import java.util.zip.ZipFile
+import org.json.JSONArray
+import org.json.JSONObject
+
+internal object OtaBundleInstaller {
+  private const val ENTRYPOINT = "index.android.bundle"
+  private const val PACKAGE_MANIFEST = "ota-manifest.json"
+  private const val MAX_PACKAGE_MANIFEST_BYTES = 1024L * 1024L
+  private const val MAX_UNCOMPRESSED_BYTES = 500L * 1024L * 1024L
+  private const val MAX_ARCHIVE_ENTRIES = 10_000
+
+  fun releaseDirectory(updatesDirectory: File, releaseId: String): File =
+      File(updatesDirectory, releaseId)
+
+  fun verifyExisting(
+      releaseDirectory: File,
+      release: VerifiedOtaRelease,
+  ): Boolean {
+    return try {
+      if (!releaseDirectory.isDirectory) return false
+      if (!File(releaseDirectory, "release-manifest.json").readBytes().contentEquals(
+          release.manifest.canonicalBytes()
+      )) return false
+      if (File(releaseDirectory, "release-signature.txt").readText(Charsets.US_ASCII) != release.signature) {
+        return false
+      }
+      val internalManifest = JSONObject(File(releaseDirectory, PACKAGE_MANIFEST).readText(Charsets.UTF_8))
+      validateExtractedFiles(releaseDirectory, internalManifest)
+    } catch (_: Exception) {
+      false
+    }
+  }
+
+  fun install(
+      archiveFile: File,
+      updatesDirectory: File,
+      release: VerifiedOtaRelease,
+  ): File {
+    val finalDirectory = releaseDirectory(updatesDirectory, release.manifest.releaseId)
+    if (finalDirectory.exists()) {
+      if (verifyExisting(finalDirectory, release)) return finalDirectory
+      throw OtaVerificationException("A stored release with this ID failed local verification")
+    }
+
+    updatesDirectory.mkdirs()
+    val stagingDirectory = File(updatesDirectory, ".${release.manifest.releaseId}.${java.util.UUID.randomUUID()}.staging")
+    if (!stagingDirectory.mkdirs()) throw OtaVerificationException("Cannot create update staging directory")
+
+    try {
+      val internalManifest = extractAndValidate(archiveFile, stagingDirectory)
+      File(stagingDirectory, "release-manifest.json").writeBytes(release.manifest.canonicalBytes())
+      File(stagingDirectory, "release-signature.txt").writeText(release.signature, Charsets.US_ASCII)
+
+      if (finalDirectory.exists()) {
+        if (verifyExisting(finalDirectory, release)) return finalDirectory
+        throw OtaVerificationException("A stored release with this ID failed local verification")
+      }
+      if (!stagingDirectory.renameTo(finalDirectory)) {
+        throw OtaVerificationException("Cannot atomically activate the staged bundle files")
+      }
+      if (!validateExtractedFiles(finalDirectory, internalManifest)) {
+        finalDirectory.deleteRecursively()
+        throw OtaVerificationException("Installed bundle failed its final integrity check")
+      }
+      return finalDirectory
+    } catch (exception: Exception) {
+      stagingDirectory.deleteRecursively()
+      throw exception
+    }
+  }
+
+  private fun extractAndValidate(archiveFile: File, destination: File): JSONObject {
+    ZipFile(archiveFile).use { archive ->
+      val entries = entriesAsList(archive.entries())
+      if (entries.size !in 2..MAX_ARCHIVE_ENTRIES) {
+        throw OtaVerificationException("Bundle ZIP has an invalid number of entries")
+      }
+      if (entries.any { it.size < 0L }) {
+        throw OtaVerificationException("Bundle ZIP contains an entry with unknown size")
+      }
+      val names = entries.map { it.name }
+      if (names.size != names.toSet().size) throw OtaVerificationException("Bundle ZIP has duplicate entries")
+      entries.forEach { entry ->
+        if (entry.isDirectory || !isSafeRelativePath(entry.name)) {
+          throw OtaVerificationException("Bundle ZIP contains an unsafe path")
+        }
+      }
+      if (entries.sumOf { it.size.coerceAtLeast(0L) } > MAX_UNCOMPRESSED_BYTES) {
+        throw OtaVerificationException("Bundle ZIP expands beyond the allowed size")
+      }
+
+      val packageManifestEntry = archive.getEntry(PACKAGE_MANIFEST)
+          ?: throw OtaVerificationException("Bundle package manifest is missing")
+      if (packageManifestEntry.size !in 1..MAX_PACKAGE_MANIFEST_BYTES) {
+        throw OtaVerificationException("Bundle package manifest has an invalid size")
+      }
+      val packageManifestBytes = archive.getInputStream(packageManifestEntry).use { it.readBytes() }
+      val packageManifest = JSONObject(String(packageManifestBytes, Charsets.UTF_8))
+      val expectedFiles = expectedPackageFiles(packageManifest)
+      if (expectedFiles != names.toSet()) {
+        throw OtaVerificationException("Bundle ZIP does not match its internal package manifest")
+      }
+      if (entries.sumOf { it.size } > MAX_UNCOMPRESSED_BYTES) {
+        throw OtaVerificationException("Bundle ZIP expands beyond the allowed size")
+      }
+
+      entries.filter { it.name != PACKAGE_MANIFEST }.forEach { entry ->
+        val targetRelativePath =
+            if (entry.name == ENTRYPOINT) ENTRYPOINT else entry.name.removePrefix("assets/")
+        val output = safeOutputFile(destination, targetRelativePath)
+        output.parentFile?.mkdirs()
+        if (!output.createNewFile()) throw OtaVerificationException("Duplicate package output path")
+        val expectedHash =
+            if (entry.name == ENTRYPOINT) {
+              packageManifest.getString("entrypoint_sha256")
+            } else {
+              assetForPath(packageManifest.getJSONArray("assets"), entry.name).getString("sha256")
+            }
+        val expectedSize =
+            if (entry.name == ENTRYPOINT) {
+              entry.size
+            } else {
+              assetForPath(packageManifest.getJSONArray("assets"), entry.name).getLong("size_bytes")
+            }
+        copyAndVerify(archive.getInputStream(entry), output, expectedHash, expectedSize)
+      }
+
+      File(destination, PACKAGE_MANIFEST).writeBytes(packageManifestBytes)
+      if (!validateExtractedFiles(destination, packageManifest)) {
+        throw OtaVerificationException("Bundle package contents failed integrity verification")
+      }
+      return packageManifest
+    }
+  }
+
+  private fun expectedPackageFiles(packageManifest: JSONObject): Set<String> {
+    if (packageManifest.optInt("format_version") != 1) {
+      throw OtaVerificationException("Unsupported bundle package format")
+    }
+    if (packageManifest.optString("entrypoint") != ENTRYPOINT ||
+        packageManifest.optString("entrypoint_format") != "hermes-bytecode") {
+      throw OtaVerificationException("Bundle package must contain the Android Hermes bytecode entrypoint")
+    }
+    val entrypointHash = packageManifest.optString("entrypoint_sha256")
+    if (!isSha256(entrypointHash)) throw OtaVerificationException("Bundle entrypoint hash is invalid")
+
+    val expected = mutableSetOf(PACKAGE_MANIFEST, ENTRYPOINT)
+    val assets = packageManifest.optJSONArray("assets")
+        ?: throw OtaVerificationException("Bundle asset manifest is missing")
+    for (index in 0 until assets.length()) {
+      val asset = assets.optJSONObject(index)
+          ?: throw OtaVerificationException("Bundle asset metadata is invalid")
+      val path = asset.optString("path")
+      if (!isSafeAssetPath(path) || !isSha256(asset.optString("sha256"))) {
+        throw OtaVerificationException("Bundle asset metadata is invalid")
+      }
+      if (asset.optLong("size_bytes", -1L) < 0L || !expected.add(path)) {
+        throw OtaVerificationException("Bundle asset metadata contains duplicate or invalid entries")
+      }
+    }
+    return expected
+  }
+
+  private fun validateExtractedFiles(directory: File, manifest: JSONObject): Boolean {
+    val bundle = File(directory, ENTRYPOINT)
+    if (!bundle.isFile || !bundleHasHermesBytecodeHeader(bundle)) return false
+    if (sha256(bundle) != manifest.optString("entrypoint_sha256")) return false
+
+    val assets = manifest.optJSONArray("assets") ?: return false
+    for (index in 0 until assets.length()) {
+      val asset = assets.optJSONObject(index) ?: return false
+      val zipPath = asset.optString("path")
+      if (!isSafeAssetPath(zipPath)) return false
+      val localPath = zipPath.removePrefix("assets/")
+      val assetFile = safeOutputFile(directory, localPath)
+      if (!assetFile.isFile || assetFile.length() != asset.optLong("size_bytes", -1L)) return false
+      if (sha256(assetFile) != asset.optString("sha256")) return false
+    }
+    return true
+  }
+
+  private fun copyAndVerify(
+      input: java.io.InputStream,
+      output: File,
+      expectedSha256: String,
+      expectedSize: Long,
+  ) {
+    val digest = MessageDigest.getInstance("SHA-256")
+    var total = 0L
+    input.use { source ->
+      BufferedInputStream(source).use { buffered ->
+        FileOutputStream(output).use { destination ->
+          val buffer = ByteArray(DEFAULT_BUFFER_SIZE)
+          while (true) {
+            val count = buffered.read(buffer)
+            if (count < 0) break
+            total += count
+            if (total > MAX_UNCOMPRESSED_BYTES) {
+              throw OtaVerificationException("Bundle entry exceeds the allowed size")
+            }
+            digest.update(buffer, 0, count)
+            destination.write(buffer, 0, count)
+          }
+          destination.fd.sync()
+        }
+      }
+    }
+    if (total != expectedSize || digest.digest().toHex() != expectedSha256) {
+      throw OtaVerificationException("Bundle entry hash or size does not match package manifest")
+    }
+    if (output.name == ENTRYPOINT && !bundleHasHermesBytecodeHeader(output)) {
+      throw OtaVerificationException("Bundle entrypoint is not Hermes bytecode")
+    }
+  }
+
+  private fun assetForPath(assets: JSONArray, path: String): JSONObject {
+    for (index in 0 until assets.length()) {
+      val item = assets.getJSONObject(index)
+      if (item.getString("path") == path) return item
+    }
+    throw OtaVerificationException("Bundle ZIP contains an undeclared asset")
+  }
+
+  private fun entriesAsList(entries: Enumeration<out ZipEntry>): List<ZipEntry> =
+      buildList {
+        while (entries.hasMoreElements()) add(entries.nextElement())
+      }
+
+  private fun safeOutputFile(root: File, relativePath: String): File {
+    if (!isSafeRelativePath(relativePath)) throw OtaVerificationException("Bundle path is unsafe")
+    val rootPath = root.canonicalPath + File.separator
+    val file = File(root, relativePath)
+    if (!file.canonicalPath.startsWith(rootPath)) throw OtaVerificationException("Bundle path escaped staging directory")
+    return file
+  }
+
+  private fun isSafeRelativePath(path: String): Boolean {
+    if (path.isBlank() || path.startsWith('/') || path.contains('\\') || path.contains(':')) return false
+    return path.split('/').all { it.isNotEmpty() && it != "." && it != ".." }
+  }
+
+  private fun isSafeAssetPath(path: String): Boolean {
+    if (!path.startsWith("assets/") || !isSafeRelativePath(path)) return false
+    return path.removePrefix("assets/") !in
+        setOf(ENTRYPOINT, PACKAGE_MANIFEST, "release-manifest.json", "release-signature.txt")
+  }
+
+  private fun bundleHasHermesBytecodeHeader(file: File): Boolean {
+    if (file.length() < 4L) return false
+    return file.inputStream().use { input ->
+      input.read() == 0xC6 && input.read() == 0x1F && input.read() == 0xBC && input.read() == 0x03
+    }
+  }
+
+  private fun isSha256(value: String): Boolean = value.matches(Regex("^[a-f0-9]{64}$"))
+
+  private fun sha256(file: File): String {
+    val digest = MessageDigest.getInstance("SHA-256")
+    file.inputStream().use { input ->
+      val buffer = ByteArray(DEFAULT_BUFFER_SIZE)
+      while (true) {
+        val count = input.read(buffer)
+        if (count < 0) break
+        digest.update(buffer, 0, count)
+      }
+    }
+    return digest.digest().toHex()
+  }
+
+  private fun ByteArray.toHex(): String = joinToString("") { byte -> "%02x".format(Locale.ROOT, byte) }
+}