@scalebun/react-native 1.10.6 → 1.10.7

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

@@ -283,6 +283,81 @@ class ScaleBunOtaModule(reactContext: ReactApplicationContext) :
         }
     }
 
+    /**
+     * Verify a detached ed25519 signature with PLATFORM crypto.
+     *
+     * Why native: the JS verifier lives inside the very bundle it protects, so
+     * one malicious bundle can neuter it for every update after. Platform
+     * crypto sits outside the bundle's reach. It also drops the runtime need
+     * for the optional @noble peers on Android 13+.
+     *
+     * Contract (mirrors the JS spec doc):
+     *   - inputs are lowercase hex, pre-validated by the JS caller
+     *   - the message is the RAW 32 BYTES of the bundle SHA-256 — the CLI
+     *     signs the digest bytes, not their hex text
+     *   - resolves 'valid' / 'invalid' / 'unavailable'; never rejects for a
+     *     wrong signature, and any unexpected throw resolves 'unavailable' so
+     *     machinery failure is distinguishable from a forged bundle
+     *
+     * Availability: `Signature.getInstance("Ed25519")` ships in Android's
+     * conscrypt from API 33. Below that the JCA lookup throws
+     * NoSuchAlgorithmException — reported as 'unavailable', and JS falls back
+     * to its own verifier. Checked by attempting the lookup rather than by
+     * SDK_INT, because the algorithm's presence is the fact that matters.
+     */
+    @ReactMethod
+    override fun verifyEd25519(
+        messageHex: String,
+        signatureHex: String,
+        publicKeyHex: String,
+        promise: Promise,
+    ) {
+        try {
+            val message = hexToBytes(messageHex)
+            val signature = hexToBytes(signatureHex)
+            val rawKey = hexToBytes(publicKeyHex)
+            if (message == null || signature == null || rawKey == null || rawKey.size != 32) {
+                // Malformed input from our own caller is not a forgery verdict.
+                promise.resolve("unavailable")
+                return
+            }
+
+            // JCA takes X.509 SubjectPublicKeyInfo, not raw key bytes: the
+            // 12-byte ed25519 SPKI prefix (OID 1.3.101.112) + the raw 32.
+            val spkiPrefix = byteArrayOf(
+                0x30, 0x2a, 0x30, 0x05, 0x06, 0x03, 0x2b, 0x65, 0x70, 0x03, 0x21, 0x00,
+            )
+            val verifier = try {
+                java.security.Signature.getInstance("Ed25519")
+            } catch (_: java.security.NoSuchAlgorithmException) {
+                promise.resolve("unavailable") // API < 33
+                return
+            }
+            val key = java.security.KeyFactory.getInstance("Ed25519")
+                .generatePublic(java.security.spec.X509EncodedKeySpec(spkiPrefix + rawKey))
+
+            verifier.initVerify(key)
+            verifier.update(message)
+            promise.resolve(if (verifier.verify(signature)) "valid" else "invalid")
+        } catch (_: Throwable) {
+            // Fail toward "cannot check", never toward "checked out fine".
+            promise.resolve("unavailable")
+        }
+    }
+
+    /** Hex → bytes; null for odd length or a non-hex character. */
+    private fun hexToBytes(hex: String): ByteArray? {
+        if (hex.isEmpty() || hex.length % 2 != 0) return null
+        val out = ByteArray(hex.length / 2)
+        for (i in out.indices) {
+            val hi = Character.digit(hex[i * 2], 16)
+            val lo = Character.digit(hex[i * 2 + 1], 16)
+            if (hi < 0 || lo < 0) return null
+            out[i] = ((hi shl 4) or lo).toByte()
+        }
+        return out
+    }
+
     private fun sha256Hex(bytes: ByteArray): String {
         val digest = java.security.MessageDigest.getInstance("SHA-256")
         val hash = digest.digest(bytes)

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

@@ -28,4 +28,16 @@ abstract class ScaleBunOtaSpec(reactContext: ReactApplicationContext) :
     abstract fun markHealthy()
     abstract fun revertToPrevious(promise: Promise)
     abstract fun restartApp()
+
+    // Hand-maintained: this file does NOT regenerate from the JS spec. A method
+    // added to NativeScaleBunOta.ts that is missing here compiles green on New
+    // Arch and breaks EVERY old-arch consumer's build (the ScaleBunCrashModule
+    // incident). Non-null Strings to match the codegen base's signature, so the
+    // one concrete override compiles against either architecture.
+    abstract fun verifyEd25519(
+        messageHex: String,
+        signatureHex: String,
+        publicKeyHex: String,
+        promise: Promise,
+    )
 }