@scalebun-release/react-native 2.5.0

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

@@ -0,0 +1,244 @@
+package com.scalebun.rn.ota
+
+import java.nio.ByteBuffer
+import java.nio.charset.CodingErrorAction
+import java.nio.charset.StandardCharsets
+import java.util.Base64
+
+/**
+ * SB-OTA-RSA-SHA256-V1 binary codec — the Android mirror of the TypeScript
+ * reference (`packages/ota-protocol/src/codec.ts`) and the JVM parity harness
+ * (`tools/rsa-ota-parity/RsaOtaParity.java`, which is run in CI to gate this
+ * transliteration byte-for-byte against the shared fixtures).
+ *
+ * Pure Kotlin + java.* only — no Android or RN dependency — so the parser is
+ * unit-testable off-device and cannot be neutered by the JS bundle it protects.
+ * See docs/ota/SB-OTA-RSA-SHA256-V1.md for the authoritative wire format.
+ */
+
+/** Stable verification failure codes (docs §6), surfaced to JS verbatim. */
+enum class OtaFailureCode {
+    INVALID_ENVELOPE,
+    INVALID_BASE64,
+    UNSUPPORTED_PROTOCOL,
+    UNSUPPORTED_SCHEMA,
+    UNSUPPORTED_SIGNATURE_ALGORITHM,
+    UNSUPPORTED_HASH_ALGORITHM,
+    UNKNOWN_KEY_ID,
+    INVALID_PUBLIC_KEY,
+    INVALID_SIGNATURE,
+    INVALID_SIGNED_PAYLOAD,
+    PROJECT_MISMATCH,
+    APPLICATION_MISMATCH,
+    PLATFORM_MISMATCH,
+    APP_VERSION_MISMATCH,
+    RUNTIME_VERSION_MISMATCH,
+    RELEASE_DOWNGRADE_REJECTED,
+    RELEASE_EXPIRED,
+    DOWNLOAD_FAILED,
+    DOWNLOAD_TOO_LARGE,
+    ARTIFACT_SIZE_MISMATCH,
+    ARTIFACT_HASH_MISMATCH,
+    PATCH_BASE_MISMATCH,
+    PATCH_RESULT_MISMATCH,
+    UNSAFE_ARCHIVE,
+    STAGING_FAILED,
+    ACTIVATION_FAILED,
+    INTERNAL_VERIFICATION_ERROR,
+}
+
+/** Carries a stable failure code out of the parser/verifier. Never leaks secrets. */
+class OtaVerifyException(val code: OtaFailureCode, message: String) : Exception("$code: $message")
+
+/** Decoded ScaleBunSignedReleaseV1 (hashes exposed as lowercase hex). */
+data class SignedRelease(
+    val signatureAlgorithm: String,
+    val hashAlgorithm: String,
+    val keyId: String,
+    val projectId: String,
+    val applicationId: String,
+    val releaseId: String,
+    val bundleId: String,
+    val platform: String,
+    val artifactType: String,
+    val targetAppVersion: String,
+    val targetRuntimeVersion: String,
+    val minimumSdkVersion: String,
+    val releaseSequence: Long,
+    val issuedAtEpochSeconds: Long,
+    val expiresAtEpochSeconds: Long,
+    val artifactSize: Long,
+    val artifactSha256: String,
+    val baseBundleId: String,
+    val baseArtifactSha256: String,
+    val resultArtifactSha256: String,
+)
+
+object OtaProtocol {
+    const val MAGIC = "SBOTA001"
+    const val SCHEMA_VERSION = 1
+    const val SIGNATURE_ALGORITHM = "SB-OTA-RSA-SHA256-V1"
+    const val HASH_ALGORITHM = "SHA-256"
+    const val MAX_SIGNED_PAYLOAD_BYTES = 8192
+    const val MAX_SIGNATURE_BYTES = 1024
+    const val MAX_STRING_FIELD_BYTES = 256
+    const val SHA256_LEN = 32
+    const val MAX_SAFE_UINT64 = 9007199254740991L // 2^53 - 1
+
+    private val MAGIC_BYTES = MAGIC.toByteArray(StandardCharsets.US_ASCII)
+
+    /**
+     * Strict, canonical standard-Base64 decode with a hard size cap enforced
+     * before allocation. Rejects non-canonical encodings by requiring the
+     * decode→re-encode round trip to reproduce the input exactly.
+     */
+    fun decodeBase64Strict(value: String?, maxBytes: Int, what: String): ByteArray {
+        if (value.isNullOrEmpty()) throw OtaVerifyException(OtaFailureCode.INVALID_BASE64, "$what: empty")
+        if (value.length > (maxBytes * 4) / 3 + 4) {
+            throw OtaVerifyException(OtaFailureCode.INVALID_BASE64, "$what: exceeds size limit")
+        }
+        if (value.length % 4 != 0 || !value.matches(Regex("^[A-Za-z0-9+/]*={0,2}$"))) {
+            throw OtaVerifyException(OtaFailureCode.INVALID_BASE64, "$what: not canonical base64")
+        }
+        val decoded = try {
+            Base64.getDecoder().decode(value)
+        } catch (e: IllegalArgumentException) {
+            throw OtaVerifyException(OtaFailureCode.INVALID_BASE64, "$what: invalid base64")
+        }
+        if (Base64.getEncoder().encodeToString(decoded) != value) {
+            throw OtaVerifyException(OtaFailureCode.INVALID_BASE64, "$what: non-canonical base64")
+        }
+        if (decoded.size > maxBytes) {
+            throw OtaVerifyException(OtaFailureCode.INVALID_BASE64, "$what: decoded exceeds limit")
+        }
+        return decoded
+    }
+
+    /** Parse ONLY enough to obtain the (still-unauthenticated) keyId (docs §5). */
+    fun peekKeyId(bytes: ByteArray): String {
+        if (bytes.size > MAX_SIGNED_PAYLOAD_BYTES) {
+            throw OtaVerifyException(OtaFailureCode.INVALID_SIGNED_PAYLOAD, "payload too large")
+        }
+        val r = Reader(bytes)
+        if (!r.fixed(MAGIC_BYTES.size).contentEquals(MAGIC_BYTES)) {
+            throw OtaVerifyException(OtaFailureCode.INVALID_SIGNED_PAYLOAD, "bad magic")
+        }
+        if (r.u16() != SCHEMA_VERSION) throw OtaVerifyException(OtaFailureCode.UNSUPPORTED_SCHEMA, "schema")
+        r.str("signatureAlgorithm")
+        r.str("hashAlgorithm")
+        val keyId = r.str("keyId")
+        if (keyId.isEmpty()) throw OtaVerifyException(OtaFailureCode.INVALID_SIGNED_PAYLOAD, "empty keyId")
+        return keyId
+    }
+
+    /** Fully parse + validate an authenticated payload. */
+    fun parse(bytes: ByteArray): SignedRelease {
+        if (bytes.size > MAX_SIGNED_PAYLOAD_BYTES) {
+            throw OtaVerifyException(OtaFailureCode.INVALID_SIGNED_PAYLOAD, "payload too large")
+        }
+        val r = Reader(bytes)
+        if (!r.fixed(MAGIC_BYTES.size).contentEquals(MAGIC_BYTES)) {
+            throw OtaVerifyException(OtaFailureCode.INVALID_SIGNED_PAYLOAD, "bad magic")
+        }
+        if (r.u16() != SCHEMA_VERSION) throw OtaVerifyException(OtaFailureCode.UNSUPPORTED_SCHEMA, "schema")
+        val sigAlg = r.str("signatureAlgorithm")
+        if (sigAlg != SIGNATURE_ALGORITHM) throw OtaVerifyException(OtaFailureCode.UNSUPPORTED_SIGNATURE_ALGORITHM, sigAlg)
+        val hashAlg = r.str("hashAlgorithm")
+        if (hashAlg != HASH_ALGORITHM) throw OtaVerifyException(OtaFailureCode.UNSUPPORTED_HASH_ALGORITHM, hashAlg)
+
+        val keyId = r.str("keyId")
+        val projectId = r.str("projectId")
+        val applicationId = r.str("applicationId")
+        val releaseId = r.str("releaseId")
+        val bundleId = r.str("bundleId")
+        for (v in listOf(keyId, projectId, applicationId, releaseId, bundleId)) {
+            if (v.isEmpty()) throw OtaVerifyException(OtaFailureCode.INVALID_SIGNED_PAYLOAD, "empty id")
+        }
+        val platform = r.str("platform")
+        if (platform != "android" && platform != "ios") {
+            throw OtaVerifyException(OtaFailureCode.INVALID_SIGNED_PAYLOAD, "platform")
+        }
+        val artifactType = r.str("artifactType")
+        if (artifactType != "full" && artifactType != "patch") {
+            throw OtaVerifyException(OtaFailureCode.INVALID_SIGNED_PAYLOAD, "artifactType")
+        }
+        val targetAppVersion = r.str("targetAppVersion")
+        val targetRuntimeVersion = r.str("targetRuntimeVersion")
+        val minimumSdkVersion = r.str("minimumSdkVersion")
+        val releaseSequence = r.u64()
+        val issuedAt = r.u64()
+        val expiresAt = r.u64()
+        val artifactSize = r.u64()
+        if (issuedAt == 0L) throw OtaVerifyException(OtaFailureCode.INVALID_SIGNED_PAYLOAD, "issuedAt zero")
+        if (artifactSize == 0L) throw OtaVerifyException(OtaFailureCode.INVALID_SIGNED_PAYLOAD, "artifactSize zero")
+        if (expiresAt != 0L && expiresAt < issuedAt) {
+            throw OtaVerifyException(OtaFailureCode.INVALID_SIGNED_PAYLOAD, "expiresAt < issuedAt")
+        }
+        val artifactSha = r.fixed(SHA256_LEN)
+        val baseBundleId = r.str("baseBundleId")
+        val baseSha = r.lenBytes(SHA256_LEN, "baseArtifactSha256")
+        val resultSha = r.fixed(SHA256_LEN)
+        if (artifactType == "full") {
+            if (baseBundleId.isNotEmpty() || baseSha.isNotEmpty()) {
+                throw OtaVerifyException(OtaFailureCode.INVALID_SIGNED_PAYLOAD, "full has base fields")
+            }
+        } else {
+            if (baseBundleId.isEmpty() || baseSha.size != SHA256_LEN) {
+                throw OtaVerifyException(OtaFailureCode.INVALID_SIGNED_PAYLOAD, "patch missing base")
+            }
+        }
+        if (r.remaining() != 0) throw OtaVerifyException(OtaFailureCode.INVALID_SIGNED_PAYLOAD, "trailing bytes")
+
+        return SignedRelease(
+            sigAlg, hashAlg, keyId, projectId, applicationId, releaseId, bundleId, platform, artifactType,
+            targetAppVersion, targetRuntimeVersion, minimumSdkVersion,
+            releaseSequence, issuedAt, expiresAt, artifactSize,
+            toHex(artifactSha), baseBundleId, if (baseSha.size == SHA256_LEN) toHex(baseSha) else "", toHex(resultSha),
+        )
+    }
+
+    fun toHex(bytes: ByteArray): String {
+        val sb = StringBuilder(bytes.size * 2)
+        for (b in bytes) sb.append("%02x".format(b))
+        return sb.toString()
+    }
+
+    private class Reader(val b: ByteArray) {
+        var pos = 0
+        private val utf8 = StandardCharsets.UTF_8.newDecoder()
+            .onMalformedInput(CodingErrorAction.REPORT)
+            .onUnmappableCharacter(CodingErrorAction.REPORT)
+
+        fun need(n: Int) {
+            if (n < 0 || pos + n > b.size) throw OtaVerifyException(OtaFailureCode.INVALID_SIGNED_PAYLOAD, "truncated")
+        }
+        fun fixed(n: Int): ByteArray { need(n); val o = b.copyOfRange(pos, pos + n); pos += n; return o }
+        fun u16(): Int { val x = fixed(2); return ((x[0].toInt() and 0xff) shl 8) or (x[1].toInt() and 0xff) }
+        fun u32(): Long {
+            val x = fixed(4)
+            return ((x[0].toLong() and 0xff) shl 24) or ((x[1].toLong() and 0xff) shl 16) or
+                ((x[2].toLong() and 0xff) shl 8) or (x[3].toLong() and 0xff)
+        }
+        fun u64(): Long {
+            val x = fixed(8)
+            var v = 0L
+            for (i in 0 until 8) v = (v shl 8) or (x[i].toLong() and 0xff)
+            if (v < 0 || v > MAX_SAFE_UINT64) throw OtaVerifyException(OtaFailureCode.INVALID_SIGNED_PAYLOAD, "uint64 out of range")
+            return v
+        }
+        fun lenBytes(max: Int, field: String): ByteArray {
+            val n = u32()
+            if (n > max) throw OtaVerifyException(OtaFailureCode.INVALID_SIGNED_PAYLOAD, "$field length $n > $max")
+            return fixed(n.toInt())
+        }
+        fun str(field: String = "string"): String {
+            val raw = lenBytes(MAX_STRING_FIELD_BYTES, field)
+            return try {
+                utf8.reset().decode(ByteBuffer.wrap(raw)).toString()
+            } catch (e: Exception) {
+                throw OtaVerifyException(OtaFailureCode.INVALID_SIGNED_PAYLOAD, "$field: invalid UTF-8")
+            }
+        }
+        fun remaining(): Int = b.size - pos
+    }
+}

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

@@ -0,0 +1,100 @@
+package com.scalebun.rn.ota
+
+import android.content.Context
+import org.json.JSONObject
+import java.security.KeyFactory
+import java.security.MessageDigest
+import java.security.interfaces.RSAPublicKey
+import java.security.spec.X509EncodedKeySpec
+import java.util.Base64
+
+/**
+ * Native trusted-key registry (docs §9). Trusted RSA public keys are EMBEDDED in
+ * the app package — never fetched over the OTA channel — so a compromised server
+ * cannot introduce a key the device will trust.
+ *
+ * Config is a JSON asset shipped in the APK (default `scalebun_ota_keys.json`):
+ *
+ * ```json
+ * { "projectId": "proj_abc",
+ *   "keys": [ { "keyId": "production-2026-01", "publicKey": "-----BEGIN PUBLIC KEY----- …" } ] }
+ * ```
+ *
+ * `publicKey` may be an SPKI PEM or bare base64 SPKI DER. Keys are validated as
+ * RSA with a modulus of at least 2048 bits; duplicates and malformed entries are
+ * rejected. An absent/empty asset yields an empty registry — verification then
+ * fails closed (UNKNOWN_KEY_ID), never open.
+ */
+class TrustedKey(
+    val keyId: String,
+    val publicKey: RSAPublicKey,
+    /** SHA-256 over the SPKI DER, lowercase hex. */
+    val fingerprint: String,
+)
+
+class ScaleBunOtaKeyRegistry private constructor(
+    val projectId: String,
+    private val byKeyId: Map<String, TrustedKey>,
+) {
+    fun get(keyId: String): TrustedKey? = byKeyId[keyId]
+    fun isEmpty(): Boolean = byKeyId.isEmpty()
+    fun keyIds(): Set<String> = byKeyId.keys
+
+    companion object {
+        const val DEFAULT_ASSET = "scalebun_ota_keys.json"
+
+        /** Load from an APK asset. Returns an empty registry if the asset is absent. */
+        fun fromAssets(context: Context, assetName: String = DEFAULT_ASSET): ScaleBunOtaKeyRegistry {
+            return try {
+                val json = context.assets.open(assetName).use { it.readBytes().toString(Charsets.UTF_8) }
+                fromJson(json)
+            } catch (_: java.io.FileNotFoundException) {
+                ScaleBunOtaKeyRegistry("", emptyMap())
+            }
+        }
+
+        fun fromJson(json: String): ScaleBunOtaKeyRegistry {
+            val root = JSONObject(json)
+            val projectId = root.optString("projectId", "")
+            val arr = root.optJSONArray("keys") ?: throw OtaVerifyException(
+                OtaFailureCode.INVALID_PUBLIC_KEY, "trusted-key config has no `keys` array",
+            )
+            val map = LinkedHashMap<String, TrustedKey>()
+            for (i in 0 until arr.length()) {
+                val entry = arr.getJSONObject(i)
+                val keyId = entry.optString("keyId", "").trim()
+                val pem = entry.optString("publicKey", "").trim()
+                if (keyId.isEmpty() || pem.isEmpty()) {
+                    throw OtaVerifyException(OtaFailureCode.INVALID_PUBLIC_KEY, "key entry missing keyId/publicKey")
+                }
+                if (map.containsKey(keyId)) {
+                    throw OtaVerifyException(OtaFailureCode.INVALID_PUBLIC_KEY, "duplicate keyId $keyId")
+                }
+                map[keyId] = parseKey(keyId, pem)
+            }
+            return ScaleBunOtaKeyRegistry(projectId, map)
+        }
+
+        private fun parseKey(keyId: String, pem: String): TrustedKey {
+            val b64 = pem.replace(Regex("-----[A-Z ]+-----"), "").replace(Regex("\\s"), "")
+            val der = try {
+                Base64.getDecoder().decode(b64)
+            } catch (e: IllegalArgumentException) {
+                throw OtaVerifyException(OtaFailureCode.INVALID_PUBLIC_KEY, "key $keyId: bad base64")
+            }
+            val key = try {
+                KeyFactory.getInstance("RSA").generatePublic(X509EncodedKeySpec(der))
+            } catch (e: Exception) {
+                throw OtaVerifyException(OtaFailureCode.INVALID_PUBLIC_KEY, "key $keyId: not a valid SPKI RSA key")
+            }
+            if (key !is RSAPublicKey) {
+                throw OtaVerifyException(OtaFailureCode.INVALID_PUBLIC_KEY, "key $keyId: not RSA")
+            }
+            if (key.modulus.bitLength() < 2048) {
+                throw OtaVerifyException(OtaFailureCode.INVALID_PUBLIC_KEY, "key $keyId: modulus < 2048 bits")
+            }
+            val fp = MessageDigest.getInstance("SHA-256").digest(der)
+            return TrustedKey(keyId, key, OtaProtocol.toHex(fp))
+        }
+    }
+}