@scalebun/react-native 2.0.0 → 2.0.2

package/android/src/main/java/com/scalebun/rn/ota/BundleDownloader.kt

@@ -58,6 +58,7 @@ internal object BundleDownloader {
      * bar overshoot 100% and walk backwards. Unknown is reported as unknown.
      */
     fun download(
+        context: android.content.Context,
         url: String,
         destination: File,
         onProgress: ((bytesRead: Long, totalBytes: Long) -> Unit)? = null,
@@ -79,6 +80,15 @@ internal object BundleDownloader {
                     setRequestProperty("Accept-Encoding", "gzip")
                 }
 
+                // Certificate pinning, when the host app ships pins. Checked after the
+                // handshake but before a single byte of the body is read, and before any
+                // redirect is followed, so an intercepted endpoint cannot serve content or
+                // bounce us somewhere else. No pins configured = no behaviour change.
+                val https = connection as? javax.net.ssl.HttpsURLConnection
+                if (https != null && !TlsPinning.verify(context, https, current.host)) {
+                  return false
+                }
+
                 val code = connection.responseCode
                 if (code == HttpURLConnection.HTTP_MOVED_PERM ||
                     code == HttpURLConnection.HTTP_MOVED_TEMP ||

package/android/src/main/java/com/scalebun/rn/ota/DeviceIntegrity.kt

@@ -0,0 +1,75 @@
+package com.scalebun.rn.ota
+
+import android.content.Context
+import android.os.Build
+import java.io.File
+
+/**
+ * Best-effort root detection.
+ *
+ * Deliberately modest in what it claims. Root detection is a signal, never a
+ * boundary: anything running with root can defeat any check made from inside the
+ * app, and a determined attacker with a rooted device has already won that
+ * argument. What it IS good for is telling an operator that a fleet's telemetry
+ * — crash rates, adoption, rollback rates — includes devices whose OTA slot is
+ * writable by other processes, and letting a security-sensitive host app decide
+ * to withhold updates on those devices.
+ *
+ * The checks are the cheap, well-understood ones: known su binaries, the
+ * test-keys build tag, and the presence of common management packages. No
+ * heuristics that produce false positives on ordinary devices, because a false
+ * positive here means a paying customer stops receiving updates.
+ */
+object DeviceIntegrity {
+
+    private val SU_PATHS = arrayOf(
+        "/system/bin/su",
+        "/system/xbin/su",
+        "/sbin/su",
+        "/system/su",
+        "/vendor/bin/su",
+        "/data/local/xbin/su",
+        "/data/local/bin/su",
+        "/system/sd/xbin/su",
+    )
+
+    private val MANAGEMENT_PACKAGES = arrayOf(
+        "com.topjohnwu.magisk",
+        "eu.chainfire.supersu",
+        "com.noshufou.android.su",
+        "com.koushikdutta.superuser",
+    )
+
+    /**
+     * Reasons this device looks rooted. Empty list = nothing detected, which is
+     * NOT the same as "device is clean" — see the class comment.
+     */
+    fun rootIndicators(context: Context): List<String> {
+        val found = mutableListOf<String>()
+
+        if (SU_PATHS.any { runCatching { File(it).exists() }.getOrDefault(false) }) {
+            found.add("su_binary_present")
+        }
+
+        // Release builds signed with Android's public test keys are development
+        // images, not retail firmware.
+        if (Build.TAGS?.contains("test-keys") == true) {
+            found.add("test_keys_build")
+        }
+
+        val pm = context.packageManager
+        for (pkg in MANAGEMENT_PACKAGES) {
+            val installed = runCatching {
+                @Suppress("DEPRECATION")
+                pm.getPackageInfo(pkg, 0)
+                true
+            }.getOrDefault(false)
+            if (installed) {
+                found.add("root_manager_installed")
+                break
+            }
+        }
+
+        return found
+    }
+}

package/android/src/main/java/com/scalebun/rn/ota/ScaleBunOtaModule.kt

@@ -154,6 +154,21 @@ class ScaleBunOtaModule(reactContext: ReactApplicationContext) :
         return slotManager.slotState().toString()
     }
 
+    /**
+     * Device integrity signals as a JSON array of reason strings.
+     *
+     * Reported, never enforced here: the SDK does not decide to withhold an
+     * update on a rooted device, because that is a product decision a host app
+     * makes with knowledge of its own users. Empty array means nothing was
+     * detected, which is not proof the device is clean.
+     */
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    override fun getDeviceIntegrity(): String {
+        return org.json.JSONArray(
+            DeviceIntegrity.rootIndicators(reactApplicationContext),
+        ).toString()
+    }
+
     /** JSON array of the trusted key IDs embedded in this app (SDK trust coverage). */
     @ReactMethod(isBlockingSynchronousMethod = true)
     override fun getTrustedKeyIds(): String {
@@ -197,7 +212,7 @@ class ScaleBunOtaModule(reactContext: ReactApplicationContext) :
             if (isRemote) {
                 val temp = File(reactApplicationContext.cacheDir, "scalebun_ota_dl_${System.nanoTime()}")
                 downloaded = temp
-                if (!BundleDownloader.download(sourcePath, temp, ::emitProgress)) {
+                if (!BundleDownloader.download(reactApplicationContext, sourcePath, temp, ::emitProgress)) {
                     promise.resolve(false)
                     return
                 }
@@ -274,7 +289,7 @@ class ScaleBunOtaModule(reactContext: ReactApplicationContext) :
 
             val temp = File(reactApplicationContext.cacheDir, "scalebun_ota_patch_${System.nanoTime()}")
             downloadedPatch = temp
-            if (!BundleDownloader.download(patchUrl, temp, ::emitProgress)) {
+            if (!BundleDownloader.download(reactApplicationContext, patchUrl, temp, ::emitProgress)) {
                 promise.resolve(false)
                 return
             }
@@ -378,7 +393,7 @@ class ScaleBunOtaModule(reactContext: ReactApplicationContext) :
 
             val temp = File(reactApplicationContext.cacheDir, "scalebun_ota_dl_${System.nanoTime()}")
             downloaded = temp
-            if (!BundleDownloader.download(url, temp, ::emitProgress)) {
+            if (!BundleDownloader.download(reactApplicationContext, url, temp, ::emitProgress)) {
                 promise.resolve(Verdict.fail(OtaFailureCode.DOWNLOAD_FAILED, "download failed").toJson())
                 return
             }

package/android/src/main/java/com/scalebun/rn/ota/SlotManager.kt

@@ -70,7 +70,68 @@ class SlotManager(private val filesDir: File) {
      */
     fun currentBundlePath(): File? {
         val bundle = File(currentSlot, BUNDLE_FILENAME)
-        return if (bundle.exists()) bundle else null
+        if (!bundle.exists()) return null
+
+        // Integrity re-check on execution.
+        //
+        // The signature and hash are verified when a bundle is STAGED. That
+        // protects the download path, but it says nothing about the bytes still
+        // being the ones we installed: on a rooted device, anything able to write
+        // into app-private storage can replace current/bundle after the fact and
+        // the old `exists()` check would happily execute it.
+        //
+        // meta.json already records the sha256 the slot manager installed, so the
+        // comparison costs one hash of the active bundle per process — not per
+        // call, hence the cache. On mismatch we refuse the slot and return null,
+        // which makes the caller fall back to the bundle compiled into the APK.
+        // Failing closed to a known-good baseline is the only safe answer here.
+        verifiedBundlePath?.let { return if (it.exists()) it else null }
+        if (integrityFailed) return null
+
+        val expected = readMeta(currentSlot)?.optString("sha256", "").orEmpty()
+        if (expected.isEmpty()) {
+            // Pre-integrity install, or metadata lost. Nothing to compare against;
+            // do not invent a failure for a bundle that may be perfectly good.
+            Log.w(TAG, "current/ has no recorded sha256 — skipping integrity re-check")
+            verifiedBundlePath = bundle
+            return bundle
+        }
+
+        val actual = try {
+            sha256(bundle)
+        } catch (e: Exception) {
+            Log.e(TAG, "Integrity re-check could not hash current/ — refusing the slot", e)
+            integrityFailed = true
+            return null
+        }
+
+        if (!constantTimeEquals(actual, expected)) {
+            Log.e(
+                TAG,
+                "INTEGRITY FAILURE — current/ bundle does not match the sha256 recorded " +
+                    "at install (expected=${expected.take(12)}… actual=${actual.take(12)}…). " +
+                    "The bundle was modified after installation. Falling back to the " +
+                    "binary baseline and clearing the slot.",
+            )
+            integrityFailed = true
+            runCatching { currentSlot.deleteRecursively() }
+            return null
+        }
+
+        verifiedBundlePath = bundle
+        return bundle
+    }
+
+    /** Per-process memo so the active bundle is hashed once, not on every call. */
+    private var verifiedBundlePath: File? = null
+    private var integrityFailed = false
+
+    /** Length-independent comparison, so a mismatch leaks nothing through timing. */
+    private fun constantTimeEquals(a: String, b: String): Boolean {
+        if (a.length != b.length) return false
+        var diff = 0
+        for (i in a.indices) diff = diff or (a[i].code xor b[i].code)
+        return diff == 0
     }
 
     /**

package/android/src/main/java/com/scalebun/rn/ota/TlsPinning.kt

@@ -0,0 +1,118 @@
+package com.scalebun.rn.ota
+
+import android.content.Context
+import android.util.Base64
+import android.util.Log
+import java.security.MessageDigest
+import java.security.cert.X509Certificate
+import javax.net.ssl.HttpsURLConnection
+import org.json.JSONObject
+
+/**
+ * Optional certificate pinning for the OTA artifact download.
+ *
+ * Pins are **SPKI SHA-256 hashes**, not certificates. Pinning a certificate
+ * breaks on every renewal even when the key is unchanged, which is how pinning
+ * earns its reputation for bricking apps; pinning the public key survives
+ * renewal and only needs rotating when the key itself rotates.
+ *
+ * Configuration is a native asset, `scalebun_tls_pins.json`, alongside the
+ * trusted-key registry — JavaScript must not be able to introduce or remove a
+ * pin, for the same reason it cannot introduce a signing key:
+ *
+ *   { "pins": {
+ *       "api.scalebun.com": ["sha256/AAAA…", "sha256/BBBB…"]
+ *   }}
+ *
+ * **Absent asset = pinning disabled.** That is deliberate. A pin that ships
+ * wrong cannot be fixed over the air — it takes a store release — so this is
+ * opt-in, and refuses to arm with fewer than two pins for a host: one live, one
+ * backup. An operator who pins a single key has built a single point of failure
+ * that a routine key rotation will detonate.
+ */
+object TlsPinning {
+
+    private const val TAG = "ScaleBunOta"
+    private const val ASSET = "scalebun_tls_pins.json"
+    private const val MIN_PINS = 2
+
+    private var loaded = false
+    private var pinsByHost: Map<String, Set<String>> = emptyMap()
+
+    @Synchronized
+    private fun load(context: Context) {
+        if (loaded) return
+        loaded = true
+        try {
+            val json = context.assets.open(ASSET).use {
+                it.readBytes().toString(Charsets.UTF_8)
+            }
+            val root = JSONObject(json).optJSONObject("pins") ?: return
+            val map = mutableMapOf<String, Set<String>>()
+            for (host in root.keys()) {
+                val arr = root.optJSONArray(host) ?: continue
+                val set = (0 until arr.length()).mapNotNull { arr.optString(it, null) }.toSet()
+                if (set.size < MIN_PINS) {
+                    Log.e(
+                        TAG,
+                        "TLS pinning NOT armed for $host — ${set.size} pin(s) configured, " +
+                            "at least $MIN_PINS required (a live pin and a backup). " +
+                            "Shipping one pin means the next key rotation bricks the app.",
+                    )
+                    continue
+                }
+                map[host.lowercase()] = set
+            }
+            pinsByHost = map
+            if (map.isNotEmpty()) {
+                Log.i(TAG, "TLS pinning armed for: ${map.keys.joinToString(", ")}")
+            }
+        } catch (_: Exception) {
+            // No asset shipped: pinning is simply not in use.
+            pinsByHost = emptyMap()
+        }
+    }
+
+    /** True when this host has pins configured, so callers can log honestly. */
+    fun isPinned(context: Context, host: String): Boolean {
+        load(context)
+        return pinsByHost.containsKey(host.lowercase())
+    }
+
+    /**
+     * Verify an established HTTPS connection against the pins for its host.
+     *
+     * Returns true when the connection is acceptable — either because no pins
+     * are configured for that host, or because one of the certificates in the
+     * presented chain matches a pin. Returns false ONLY when pins exist and none
+     * matched, which is a hard failure the caller must treat as a failed
+     * download rather than retrying against the same endpoint.
+     */
+    fun verify(context: Context, connection: HttpsURLConnection, host: String): Boolean {
+        load(context)
+        val expected = pinsByHost[host.lowercase()] ?: return true
+
+        val chain = try {
+            connection.serverCertificates
+        } catch (e: Exception) {
+            Log.e(TAG, "TLS pin check could not read the certificate chain for $host", e)
+            return false
+        }
+
+        for (cert in chain) {
+            val x509 = cert as? X509Certificate ?: continue
+            val spki = x509.publicKey.encoded ?: continue
+            val digest = MessageDigest.getInstance("SHA-256").digest(spki)
+            val pin = "sha256/" + Base64.encodeToString(digest, Base64.NO_WRAP)
+            if (expected.contains(pin)) return true
+        }
+
+        Log.e(
+            TAG,
+            "TLS PIN MISMATCH for $host — the presented certificate chain matches none " +
+                "of the ${expected.size} configured pins. Refusing the download. This is " +
+                "either an interception attempt or a rotated key whose pin was never shipped.",
+        )
+        return false
+    }
+}

package/android/src/oldarch/java/com/scalebun/rn/ota/ScaleBunOtaSpec.kt

@@ -18,6 +18,8 @@ abstract class ScaleBunOtaSpec(reactContext: ReactApplicationContext) :
     abstract fun getActiveBundle(): String?
     abstract fun getSlotState(): String
     abstract fun getTrustedKeyIds(): String
+
+    abstract fun getDeviceIntegrity(): String
     abstract fun stageBundle(sourcePath: String, sha256: String, promise: Promise)
     abstract fun stagePatch(
         patchUrl: String,