@scalebun/react-native 1.13.0 → 2.0.1

package/ios/Ota/OtaProtocol.swift

@@ -0,0 +1,242 @@
+import Foundation
+
+/**
+ * SB-OTA-RSA-SHA256-V1 binary codec — the iOS mirror of the TypeScript reference
+ * (`packages/ota-protocol/src/codec.ts`), the Android `OtaProtocol.kt`, and the
+ * JVM parity harness (`tools/rsa-ota-parity/RsaOtaParity.java`). Pure Foundation,
+ * no RN/CryptoKit dependency, so it is unit-testable and cannot be neutered by
+ * the JS bundle it protects. See docs/ota/SB-OTA-RSA-SHA256-V1.md.
+ *
+ * ⚪ Not compiled in this workspace (no macOS toolchain); the algorithm + wire
+ * format are gated by the JVM parity harness against the shared fixtures, and an
+ * XCTest (ScaleBunOtaVerifierTests) is provided ready-to-run on a simulator.
+ */
+
+enum OtaFailureCode: String {
+    case INVALID_ENVELOPE
+    case INVALID_BASE64
+    case UNSUPPORTED_PROTOCOL
+    case UNSUPPORTED_SCHEMA
+    case UNSUPPORTED_SIGNATURE_ALGORITHM
+    case UNSUPPORTED_HASH_ALGORITHM
+    case UNKNOWN_KEY_ID
+    case INVALID_PUBLIC_KEY
+    case INVALID_SIGNATURE
+    case INVALID_SIGNED_PAYLOAD
+    case PROJECT_MISMATCH
+    case APPLICATION_MISMATCH
+    case PLATFORM_MISMATCH
+    case APP_VERSION_MISMATCH
+    case RUNTIME_VERSION_MISMATCH
+    case RELEASE_DOWNGRADE_REJECTED
+    case RELEASE_EXPIRED
+    case DOWNLOAD_FAILED
+    case DOWNLOAD_TOO_LARGE
+    case ARTIFACT_SIZE_MISMATCH
+    case ARTIFACT_HASH_MISMATCH
+    case PATCH_BASE_MISMATCH
+    case PATCH_RESULT_MISMATCH
+    case UNSAFE_ARCHIVE
+    case STAGING_FAILED
+    case ACTIVATION_FAILED
+    case INTERNAL_VERIFICATION_ERROR
+}
+
+struct OtaVerifyError: Error {
+    let code: OtaFailureCode
+    let message: String
+}
+
+struct SignedRelease {
+    let signatureAlgorithm: String
+    let hashAlgorithm: String
+    let keyId: String
+    let projectId: String
+    let applicationId: String
+    let releaseId: String
+    let bundleId: String
+    let platform: String
+    let artifactType: String
+    let targetAppVersion: String
+    let targetRuntimeVersion: String
+    let minimumSdkVersion: String
+    let releaseSequence: Int64
+    let issuedAtEpochSeconds: Int64
+    let expiresAtEpochSeconds: Int64
+    let artifactSize: Int64
+    let artifactSha256: String
+    let baseBundleId: String
+    let baseArtifactSha256: String
+    let resultArtifactSha256: String
+}
+
+enum OtaProtocol {
+    static let magic = "SBOTA001"
+    static let schemaVersion = 1
+    static let signatureAlgorithm = "SB-OTA-RSA-SHA256-V1"
+    static let hashAlgorithm = "SHA-256"
+    static let maxSignedPayloadBytes = 8192
+    static let maxSignatureBytes = 1024
+    static let maxStringFieldBytes = 256
+    static let sha256Len = 32
+    static let maxSafeUint64: Int64 = 9_007_199_254_740_991 // 2^53 - 1
+
+    private static let magicBytes = Array(magic.utf8)
+
+    /// Strict canonical standard-Base64 decode with a hard size cap.
+    static func decodeBase64Strict(_ value: String, _ maxBytes: Int, _ what: String) throws -> [UInt8] {
+        if value.isEmpty { throw OtaVerifyError(code: .INVALID_BASE64, message: "\(what): empty") }
+        if value.count > (maxBytes * 4) / 3 + 4 {
+            throw OtaVerifyError(code: .INVALID_BASE64, message: "\(what): exceeds size limit")
+        }
+        if value.count % 4 != 0 || value.range(of: "^[A-Za-z0-9+/]*={0,2}$", options: .regularExpression) == nil {
+            throw OtaVerifyError(code: .INVALID_BASE64, message: "\(what): not canonical base64")
+        }
+        guard let decoded = Data(base64Encoded: value) else {
+            throw OtaVerifyError(code: .INVALID_BASE64, message: "\(what): invalid base64")
+        }
+        if decoded.base64EncodedString() != value {
+            throw OtaVerifyError(code: .INVALID_BASE64, message: "\(what): non-canonical base64")
+        }
+        if decoded.count > maxBytes {
+            throw OtaVerifyError(code: .INVALID_BASE64, message: "\(what): decoded exceeds limit")
+        }
+        return [UInt8](decoded)
+    }
+
+    /// Parse ONLY enough to obtain the (still-unauthenticated) keyId (docs §5).
+    static func peekKeyId(_ bytes: [UInt8]) throws -> String {
+        if bytes.count > maxSignedPayloadBytes {
+            throw OtaVerifyError(code: .INVALID_SIGNED_PAYLOAD, message: "payload too large")
+        }
+        var r = Reader(bytes)
+        if try r.fixed(magicBytes.count) != magicBytes {
+            throw OtaVerifyError(code: .INVALID_SIGNED_PAYLOAD, message: "bad magic")
+        }
+        if try r.u16() != schemaVersion { throw OtaVerifyError(code: .UNSUPPORTED_SCHEMA, message: "schema") }
+        _ = try r.str("signatureAlgorithm")
+        _ = try r.str("hashAlgorithm")
+        let keyId = try r.str("keyId")
+        if keyId.isEmpty { throw OtaVerifyError(code: .INVALID_SIGNED_PAYLOAD, message: "empty keyId") }
+        return keyId
+    }
+
+    /// Fully parse + validate an authenticated payload.
+    static func parse(_ bytes: [UInt8]) throws -> SignedRelease {
+        if bytes.count > maxSignedPayloadBytes {
+            throw OtaVerifyError(code: .INVALID_SIGNED_PAYLOAD, message: "payload too large")
+        }
+        var r = Reader(bytes)
+        if try r.fixed(magicBytes.count) != magicBytes {
+            throw OtaVerifyError(code: .INVALID_SIGNED_PAYLOAD, message: "bad magic")
+        }
+        if try r.u16() != schemaVersion { throw OtaVerifyError(code: .UNSUPPORTED_SCHEMA, message: "schema") }
+        let sigAlg = try r.str("signatureAlgorithm")
+        if sigAlg != signatureAlgorithm { throw OtaVerifyError(code: .UNSUPPORTED_SIGNATURE_ALGORITHM, message: sigAlg) }
+        let hashAlg = try r.str("hashAlgorithm")
+        if hashAlg != hashAlgorithm { throw OtaVerifyError(code: .UNSUPPORTED_HASH_ALGORITHM, message: hashAlg) }
+
+        let keyId = try r.str("keyId")
+        let projectId = try r.str("projectId")
+        let applicationId = try r.str("applicationId")
+        let releaseId = try r.str("releaseId")
+        let bundleId = try r.str("bundleId")
+        for v in [keyId, projectId, applicationId, releaseId, bundleId] where v.isEmpty {
+            throw OtaVerifyError(code: .INVALID_SIGNED_PAYLOAD, message: "empty id")
+        }
+        let platform = try r.str("platform")
+        if platform != "android" && platform != "ios" {
+            throw OtaVerifyError(code: .INVALID_SIGNED_PAYLOAD, message: "platform")
+        }
+        let artifactType = try r.str("artifactType")
+        if artifactType != "full" && artifactType != "patch" {
+            throw OtaVerifyError(code: .INVALID_SIGNED_PAYLOAD, message: "artifactType")
+        }
+        let targetAppVersion = try r.str("targetAppVersion")
+        let targetRuntimeVersion = try r.str("targetRuntimeVersion")
+        let minimumSdkVersion = try r.str("minimumSdkVersion")
+        let releaseSequence = try r.u64()
+        let issuedAt = try r.u64()
+        let expiresAt = try r.u64()
+        let artifactSize = try r.u64()
+        if issuedAt == 0 { throw OtaVerifyError(code: .INVALID_SIGNED_PAYLOAD, message: "issuedAt zero") }
+        if artifactSize == 0 { throw OtaVerifyError(code: .INVALID_SIGNED_PAYLOAD, message: "artifactSize zero") }
+        if expiresAt != 0 && expiresAt < issuedAt {
+            throw OtaVerifyError(code: .INVALID_SIGNED_PAYLOAD, message: "expiresAt < issuedAt")
+        }
+        let artifactSha = try r.fixed(sha256Len)
+        let baseBundleId = try r.str("baseBundleId")
+        let baseSha = try r.lenBytes(sha256Len, "baseArtifactSha256")
+        let resultSha = try r.fixed(sha256Len)
+        if artifactType == "full" {
+            if !baseBundleId.isEmpty || !baseSha.isEmpty {
+                throw OtaVerifyError(code: .INVALID_SIGNED_PAYLOAD, message: "full has base fields")
+            }
+        } else {
+            if baseBundleId.isEmpty || baseSha.count != sha256Len {
+                throw OtaVerifyError(code: .INVALID_SIGNED_PAYLOAD, message: "patch missing base")
+            }
+        }
+        if r.remaining() != 0 { throw OtaVerifyError(code: .INVALID_SIGNED_PAYLOAD, message: "trailing bytes") }
+
+        return SignedRelease(
+            signatureAlgorithm: sigAlg, hashAlgorithm: hashAlg, keyId: keyId, projectId: projectId,
+            applicationId: applicationId, releaseId: releaseId, bundleId: bundleId, platform: platform,
+            artifactType: artifactType, targetAppVersion: targetAppVersion,
+            targetRuntimeVersion: targetRuntimeVersion, minimumSdkVersion: minimumSdkVersion,
+            releaseSequence: releaseSequence, issuedAtEpochSeconds: issuedAt, expiresAtEpochSeconds: expiresAt,
+            artifactSize: artifactSize, artifactSha256: toHex(artifactSha), baseBundleId: baseBundleId,
+            baseArtifactSha256: baseSha.count == sha256Len ? toHex(baseSha) : "", resultArtifactSha256: toHex(resultSha)
+        )
+    }
+
+    static func toHex(_ bytes: [UInt8]) -> String {
+        bytes.map { String(format: "%02x", $0) }.joined()
+    }
+
+    private struct Reader {
+        let b: [UInt8]
+        var pos = 0
+        init(_ b: [UInt8]) { self.b = b }
+
+        mutating func need(_ n: Int) throws {
+            if n < 0 || pos + n > b.count { throw OtaVerifyError(code: .INVALID_SIGNED_PAYLOAD, message: "truncated") }
+        }
+        mutating func fixed(_ n: Int) throws -> [UInt8] {
+            try need(n); let o = Array(b[pos..<pos + n]); pos += n; return o
+        }
+        mutating func u16() throws -> Int {
+            let x = try fixed(2); return (Int(x[0]) << 8) | Int(x[1])
+        }
+        mutating func u32() throws -> Int64 {
+            let x = try fixed(4)
+            return (Int64(x[0]) << 24) | (Int64(x[1]) << 16) | (Int64(x[2]) << 8) | Int64(x[3])
+        }
+        mutating func u64() throws -> Int64 {
+            let x = try fixed(8)
+            var v: Int64 = 0
+            for i in 0..<8 {
+                // guard against overflow into the sign bit before shifting.
+                if v > (Int64.max >> 8) { throw OtaVerifyError(code: .INVALID_SIGNED_PAYLOAD, message: "uint64 overflow") }
+                v = (v << 8) | Int64(x[i])
+            }
+            if v < 0 || v > maxSafeUint64 {
+                throw OtaVerifyError(code: .INVALID_SIGNED_PAYLOAD, message: "uint64 out of safe range")
+            }
+            return v
+        }
+        mutating func lenBytes(_ max: Int, _ field: String) throws -> [UInt8] {
+            let n = try u32()
+            if n > Int64(max) { throw OtaVerifyError(code: .INVALID_SIGNED_PAYLOAD, message: "\(field) length \(n) > \(max)") }
+            return try fixed(Int(n))
+        }
+        mutating func str(_ field: String = "string") throws -> String {
+            let raw = try lenBytes(maxStringFieldBytes, field)
+            guard let s = String(bytes: raw, encoding: .utf8) else {
+                throw OtaVerifyError(code: .INVALID_SIGNED_PAYLOAD, message: "\(field): invalid UTF-8")
+            }
+            return s
+        }
+        func remaining() -> Int { b.count - pos }
+    }
+}

package/ios/Ota/OtaSlotManager.swift

@@ -141,6 +141,32 @@ class OtaSlotManager {
             try? FileManager.default.removeItem(at: bootMarkerFile)
             NSLog("[ScaleBunOta] Boot marker cleared — bundle marked healthy")
         }
+        // A bundle is only trusted for anti-downgrade once it has run healthily.
+        confirmCurrentSequence()
+    }
+
+    private var sequenceFile: URL { otaRoot.appendingPathComponent("highest_sequence") }
+
+    /// Highest CONFIRMED release sequence — the anti-downgrade floor (docs §15).
+    /// Raised only at markHealthy, so a failed/rolled-back higher sequence never
+    /// blocks a legitimate re-install.
+    func highestConfirmedSequence() -> Int64 {
+        guard let s = try? String(contentsOf: sequenceFile, encoding: .utf8),
+              let v = Int64(s.trimmingCharacters(in: .whitespacesAndNewlines)) else { return 0 }
+        return v
+    }
+
+    private func confirmCurrentSequence() {
+        guard let meta = readMeta(slot: currentSlot) else { return }
+        let seq: Int64
+        if let n = meta["releaseSequence"] as? Int64 { seq = n }
+        else if let n = meta["releaseSequence"] as? Int { seq = Int64(n) }
+        else if let n = meta["releaseSequence"] as? NSNumber { seq = n.int64Value }
+        else { return }
+        if seq > highestConfirmedSequence() {
+            try? FileManager.default.createDirectory(at: otaRoot, withIntermediateDirectories: true)
+            try? String(seq).write(to: sequenceFile, atomically: true, encoding: .utf8)
+        }
     }
 
     /// Revert to previous slot.

package/ios/Ota/ScaleBunOtaBridge.mm

@@ -18,6 +18,7 @@
 
 RCT_EXTERN__BLOCKING_SYNCHRONOUS_METHOD(getActiveBundle)
 RCT_EXTERN__BLOCKING_SYNCHRONOUS_METHOD(getSlotState)
+RCT_EXTERN__BLOCKING_SYNCHRONOUS_METHOD(getTrustedKeyIds)
 
 RCT_EXTERN_METHOD(stageBundle:(NSString *)sourcePath
                   sha256:(NSString *)sha256
@@ -40,9 +41,11 @@ RCT_EXTERN_METHOD(revertToPrevious:(RCTPromiseResolveBlock)resolve
 
 RCT_EXTERN_METHOD(restartApp)
 
-RCT_EXTERN_METHOD(verifyEd25519:(NSString *)messageHex
-                  signatureHex:(NSString *)signatureHex
-                  publicKeyHex:(NSString *)publicKeyHex
+RCT_EXTERN_METHOD(verifyRelease:(NSString *)envelopeJson
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(verifyAndStageRelease:(NSString *)envelopeJson
                   resolve:(RCTPromiseResolveBlock)resolve
                   reject:(RCTPromiseRejectBlock)reject)
 

package/ios/Ota/ScaleBunOtaKeyRegistry.swift

@@ -0,0 +1,147 @@
+import Foundation
+import Security
+import CommonCrypto
+
+/**
+ * Native trusted-key registry (docs §9) for iOS. Trusted RSA public keys are
+ * EMBEDDED in the app bundle (resource `ScaleBunOtaKeys.json`), never fetched
+ * over the OTA channel:
+ *
+ * ```json
+ * { "projectId": "proj_abc",
+ *   "keys": [ { "keyId": "production-2026-01", "publicKey": "-----BEGIN PUBLIC KEY----- …" } ] }
+ * ```
+ *
+ * `SecKeyCreateWithData` expects the PKCS#1 `RSAPublicKey` body, NOT the X.509
+ * SPKI wrapper (PROMPT §11.1). We therefore unwrap the SPKI to its inner PKCS#1
+ * DER with a minimal, bounded ASN.1 reader — no OpenSSL/SwiftyRSA. Keys are
+ * validated as RSA ≥ 2048 bits via `SecKeyCopyAttributes`. The fingerprint is
+ * SHA-256 over the full SPKI DER, matching the backend + Android.
+ */
+struct TrustedKey {
+    let keyId: String
+    let secKey: SecKey
+    let fingerprint: String
+}
+
+final class ScaleBunOtaKeyRegistry {
+    let projectId: String
+    private let byKeyId: [String: TrustedKey]
+
+    private init(projectId: String, byKeyId: [String: TrustedKey]) {
+        self.projectId = projectId
+        self.byKeyId = byKeyId
+    }
+
+    func get(_ keyId: String) -> TrustedKey? { byKeyId[keyId] }
+    var isEmpty: Bool { byKeyId.isEmpty }
+    func keyIds() -> [String] { Array(byKeyId.keys) }
+
+    static let defaultResource = "ScaleBunOtaKeys"
+
+    /// Load from the app bundle. Empty registry if the resource is absent →
+    /// verification fails closed (UNKNOWN_KEY_ID), never open.
+    static func fromBundle(_ bundle: Bundle = .main, resource: String = defaultResource) -> ScaleBunOtaKeyRegistry {
+        guard let url = bundle.url(forResource: resource, withExtension: "json"),
+              let data = try? Data(contentsOf: url),
+              let json = String(data: data, encoding: .utf8) else {
+            return ScaleBunOtaKeyRegistry(projectId: "", byKeyId: [:])
+        }
+        return (try? fromJson(json)) ?? ScaleBunOtaKeyRegistry(projectId: "", byKeyId: [:])
+    }
+
+    static func fromJson(_ json: String) throws -> ScaleBunOtaKeyRegistry {
+        guard let data = json.data(using: .utf8),
+              let root = try JSONSerialization.jsonObject(with: data) as? [String: Any] else {
+            throw OtaVerifyError(code: .INVALID_PUBLIC_KEY, message: "trusted-key config is not an object")
+        }
+        let projectId = (root["projectId"] as? String) ?? ""
+        guard let arr = root["keys"] as? [[String: Any]] else {
+            throw OtaVerifyError(code: .INVALID_PUBLIC_KEY, message: "trusted-key config has no `keys` array")
+        }
+        var map: [String: TrustedKey] = [:]
+        for entry in arr {
+            let keyId = ((entry["keyId"] as? String) ?? "").trimmingCharacters(in: .whitespacesAndNewlines)
+            let pem = ((entry["publicKey"] as? String) ?? "").trimmingCharacters(in: .whitespacesAndNewlines)
+            if keyId.isEmpty || pem.isEmpty {
+                throw OtaVerifyError(code: .INVALID_PUBLIC_KEY, message: "key entry missing keyId/publicKey")
+            }
+            if map[keyId] != nil {
+                throw OtaVerifyError(code: .INVALID_PUBLIC_KEY, message: "duplicate keyId \(keyId)")
+            }
+            map[keyId] = try parseKey(keyId: keyId, pem: pem)
+        }
+        return ScaleBunOtaKeyRegistry(projectId: projectId, byKeyId: map)
+    }
+
+    private static func parseKey(keyId: String, pem: String) throws -> TrustedKey {
+        let b64 = pem
+            .replacingOccurrences(of: "-----BEGIN PUBLIC KEY-----", with: "")
+            .replacingOccurrences(of: "-----END PUBLIC KEY-----", with: "")
+            .replacingOccurrences(of: "\n", with: "")
+            .replacingOccurrences(of: "\r", with: "")
+            .replacingOccurrences(of: " ", with: "")
+        guard let spkiDer = Data(base64Encoded: b64) else {
+            throw OtaVerifyError(code: .INVALID_PUBLIC_KEY, message: "key \(keyId): bad base64")
+        }
+        let pkcs1 = try Self.spkiToPkcs1([UInt8](spkiDer), keyId: keyId)
+
+        let attrs: [String: Any] = [
+            kSecAttrKeyType as String: kSecAttrKeyTypeRSA,
+            kSecAttrKeyClass as String: kSecAttrKeyClassPublic,
+        ]
+        var error: Unmanaged<CFError>?
+        guard let secKey = SecKeyCreateWithData(Data(pkcs1) as CFData, attrs as CFDictionary, &error) else {
+            throw OtaVerifyError(code: .INVALID_PUBLIC_KEY, message: "key \(keyId): SecKeyCreateWithData failed")
+        }
+        // Validate RSA size via SecKeyCopyAttributes.
+        guard let ka = SecKeyCopyAttributes(secKey) as? [String: Any],
+              let bits = ka[kSecAttrKeySizeInBits as String] as? Int, bits >= 2048 else {
+            throw OtaVerifyError(code: .INVALID_PUBLIC_KEY, message: "key \(keyId): RSA modulus < 2048 bits")
+        }
+
+        var digest = [UInt8](repeating: 0, count: Int(CC_SHA256_DIGEST_LENGTH))
+        [UInt8](spkiDer).withUnsafeBytes { _ = CC_SHA256($0.baseAddress, CC_LONG(spkiDer.count), &digest) }
+        return TrustedKey(keyId: keyId, secKey: secKey, fingerprint: OtaProtocol.toHex(digest))
+    }
+
+    // MARK: - Minimal bounded ASN.1: SPKI → inner PKCS#1 RSAPublicKey DER
+
+    /// SPKI = SEQ { AlgorithmIdentifier SEQ, BIT STRING { 0x00, RSAPublicKey } }.
+    /// Returns the RSAPublicKey PKCS#1 DER (what SecKeyCreateWithData wants).
+    private static func spkiToPkcs1(_ der: [UInt8], keyId: String) throws -> [UInt8] {
+        func fail(_ m: String) -> OtaVerifyError { OtaVerifyError(code: .INVALID_PUBLIC_KEY, message: "key \(keyId): \(m)") }
+        var i = 0
+        func readLen() throws -> Int {
+            guard i < der.count else { throw fail("truncated length") }
+            let first = Int(der[i]); i += 1
+            if first < 0x80 { return first }
+            let n = first & 0x7f
+            if n == 0 || n > 4 { throw fail("bad length form") }
+            guard i + n <= der.count else { throw fail("truncated long length") }
+            var len = 0
+            for _ in 0..<n { len = (len << 8) | Int(der[i]); i += 1 }
+            return len
+        }
+        func expectTag(_ tag: UInt8) throws {
+            guard i < der.count else { throw fail("truncated tag") }
+            guard der[i] == tag else { throw fail("unexpected tag") }
+            i += 1
+        }
+        // outer SEQUENCE
+        try expectTag(0x30); _ = try readLen()
+        // AlgorithmIdentifier SEQUENCE — skip its whole body
+        try expectTag(0x30)
+        let algLen = try readLen()
+        guard i + algLen <= der.count else { throw fail("truncated alg id") }
+        i += algLen
+        // BIT STRING
+        try expectTag(0x03)
+        let bitLen = try readLen()
+        guard bitLen >= 1, i + bitLen <= der.count else { throw fail("truncated bit string") }
+        guard der[i] == 0x00 else { throw fail("nonzero unused bits") }
+        let start = i + 1
+        let end = i + bitLen
+        return Array(der[start..<end])
+    }
+}