@onekeyfe/react-native-split-bundle-loader 3.0.180 → 6.7.0-2

package/android/src/main/java/com/splitbundleloader/SplitBundleLoaderModule.kt

@@ -114,6 +114,7 @@ class SplitBundleLoaderModule(reactContext: ReactApplicationContext) :
         // assets get extracted fresh on first load.
         private const val PREFS_NAME = "split_bundle_loader"
         private const val KEY_LAST_INSTALL_STAMP = "last_install_stamp"
+        private const val BUILTIN_BUNDLE_SENTINEL = "__BUILTIN__"
         // Double-checked locking: loser threads must BLOCK until the wipe
         // finishes, not just skip. AtomicBoolean.compareAndSet would let
         // losers race ahead and read half-nuked state.
@@ -121,6 +122,19 @@ class SplitBundleLoaderModule(reactContext: ReactApplicationContext) :
         private val wipeLock = Any()
     }
 
+    // Pin the OTA bundle path that this React runtime instance booted with so
+    // mid-session SharedPreferences mutations (installBundle / switchBundle /
+    // resetToBuiltInBundle during the 2500ms pre-restart window) cannot cause
+    // subsequent lazy segment loads to jump to a different bundle root.
+    @Volatile
+    private var pinnedOtaBundlePath: String? = null
+    private val pinnedOtaBundleLock = Any()
+
+    override fun initialize() {
+        super.initialize()
+        getOtaBundlePath()
+    }
+
     override fun getName(): String = NAME
 
     // -----------------------------------------------------------------------
@@ -458,6 +472,8 @@ class SplitBundleLoaderModule(reactContext: ReactApplicationContext) :
             } else {
                 SBLLogger.info("[resolveSeg] rel=$relativePath otaBundlePath=$otaBundlePath parentFile=null")
             }
+            SBLLogger.warn("[resolveSeg] rel=$relativePath missing in active OTA bundle root — refusing builtin fallback")
+            return null
         } else {
             SBLLogger.info("[resolveSeg] rel=$relativePath otaBundlePath=(empty) — skipping OTA")
         }
@@ -636,6 +652,22 @@ class SplitBundleLoaderModule(reactContext: ReactApplicationContext) :
     }
 
     private fun getOtaBundlePath(): String? {
+        val existing = pinnedOtaBundlePath
+        if (existing != null) {
+            return if (existing == BUILTIN_BUNDLE_SENTINEL) null else existing
+        }
+        synchronized(pinnedOtaBundleLock) {
+            val rechecked = pinnedOtaBundlePath
+            if (rechecked != null) {
+                return if (rechecked == BUILTIN_BUNDLE_SENTINEL) null else rechecked
+            }
+            val resolved = queryCurrentOtaBundlePath()
+            pinnedOtaBundlePath = if (resolved.isNullOrEmpty()) BUILTIN_BUNDLE_SENTINEL else resolved
+            return resolved
+        }
+    }
+
+    private fun queryCurrentOtaBundlePath(): String? {
         return try {
             val bundleUpdateStore = Class.forName(
                 "com.margelo.nitro.reactnativebundleupdate.BundleUpdateStoreAndroid"
@@ -697,7 +729,9 @@ class SplitBundleLoaderModule(reactContext: ReactApplicationContext) :
      */
     private fun verifySha256(path: String, expected: String): Boolean {
         if (expected.isEmpty()) {
-            return !currentBundleRequiresPerSegmentHash()
+            val otaPath = getOtaBundlePath()
+            val otaActive = !otaPath.isNullOrEmpty() && pinnedOtaBundlePath != BUILTIN_BUNDLE_SENTINEL
+            return otaActive && !currentBundleRequiresPerSegmentHash()
         }
         return try {
             val md = MessageDigest.getInstance("SHA-256")

package/ios/SplitBundleLoader.mm

@@ -416,7 +416,33 @@ typedef NS_ENUM(NSInteger, ESegmentEvalError) {
     ESegmentEvalErrorTimeout = 6,
 };
 
-@implementation SplitBundleLoader
+static NSString *const kSBLBuiltinBundleSentinel = @"__BUILTIN__";
+
+@implementation SplitBundleLoader {
+    os_unfair_lock _pinnedOtaLock;
+    NSString *_Nullable _pinnedOtaBundlePath;
+}
+
+- (instancetype)init
+{
+    if (self = [super init]) {
+        _pinnedOtaLock = OS_UNFAIR_LOCK_INIT;
+    }
+    return self;
+}
+
+- (nullable NSString *)pinnedOtaBundlePath
+{
+    os_unfair_lock_lock(&_pinnedOtaLock);
+    NSString *cached = _pinnedOtaBundlePath;
+    if (!cached) {
+        NSString *resolved = [SplitBundleLoader otaBundlePath];
+        cached = (resolved.length > 0) ? [resolved copy] : kSBLBuiltinBundleSentinel;
+        _pinnedOtaBundlePath = cached;
+    }
+    os_unfair_lock_unlock(&_pinnedOtaLock);
+    return [cached isEqualToString:kSBLBuiltinBundleSentinel] ? nil : cached;
+}
 
 // Reflectively asks bundle-update whether the current bundle's manifest is
 // required to ship per-segment SHA-256s (three-bundle / split-thread format).
@@ -451,11 +477,21 @@ typedef NS_ENUM(NSInteger, ESegmentEvalError) {
 // mismatch or read failure. Streams the file with a fixed-size buffer so a
 // large segment doesn't pull the whole bundle into memory just to hash it.
 + (BOOL)verifySha256OfFile:(NSString *)path expected:(NSString *)expected
+{
+    return [self verifySha256OfFile:path expected:expected otaBundlePath:[self otaBundlePath]];
+}
+
++ (BOOL)verifySha256OfFile:(NSString *)path
+                  expected:(NSString *)expected
+             otaBundlePath:(nullable NSString *)otaPath
 {
     if (expected.length == 0) {
-        // Defer to bundle-update: three-bundle format manifests must ship
-        // per-segment hashes (fail closed); older formats are allowed to omit
-        // them (back-compat).
+        // Only allow skipping SHA-256 verification when an OTA bundle IS active
+        // AND its manifest is an older format that does not require per-segment hashes.
+        // Built-in bundles and three-bundle manifests must always supply a non-empty hash.
+        if (otaPath.length == 0 || [otaPath isEqualToString:kSBLBuiltinBundleSentinel]) {
+            return NO;
+        }
         return ![SplitBundleLoader currentBundleRequiresPerSegmentHash];
     }
     NSFileHandle *handle = [NSFileHandle fileHandleForReadingAtPath:path];
@@ -486,6 +522,7 @@ typedef NS_ENUM(NSInteger, ESegmentEvalError) {
 - (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
     (const facebook::react::ObjCTurboModule::InitParams &)params
 {
+    [self pinnedOtaBundlePath];
     [SBLLogger info:@"SplitBundleLoader module initialized"];
     return std::make_shared<facebook::react::NativeSplitBundleLoaderSpecJSI>(params);
 }
@@ -761,7 +798,7 @@ typedef NS_ENUM(NSInteger, ESegmentEvalError) {
         NSString *nativeVersion = [[NSBundle mainBundle] objectForInfoDictionaryKey:@"CFBundleShortVersionString"] ?: @"";
         NSString *bundleVersion = @"";
 
-        NSString *otaPath = [SplitBundleLoader otaBundlePath];
+        NSString *otaPath = [self pinnedOtaBundlePath];
         if (otaPath && [[NSFileManager defaultManager] fileExistsAtPath:otaPath]) {
             sourceKind = @"ota";
             bundleRoot = [otaPath stringByDeletingLastPathComponent];
@@ -788,28 +825,38 @@ typedef NS_ENUM(NSInteger, ESegmentEvalError) {
 /// Resolves a relative segment path to an absolute path, checking OTA then builtin.
 /// Returns nil if the segment file is not found.
 + (nullable NSString *)resolveAbsolutePath:(NSString *)relativePath
+{
+    return [self resolveAbsolutePath:relativePath
+                       otaBundlePath:[self otaBundlePath]];
+}
+
++ (nullable NSString *)resolveAbsolutePath:(NSString *)relativePath
+                             otaBundlePath:(nullable NSString *)otaPath
 {
     // 1. Try OTA bundle root first
-    NSString *otaPath = [SplitBundleLoader otaBundlePath];
     if (otaPath) {
-        // Standardize root so hasPrefix matches candidate (iOS resolves /private/var → /var).
-        NSString *otaRoot = [[otaPath stringByDeletingLastPathComponent] stringByStandardizingPath];
-        NSString *candidate = [[otaRoot stringByAppendingPathComponent:relativePath] stringByStandardizingPath];
-        BOOL otaPrefixOk = [candidate hasPrefix:otaRoot];
+        // Resolve symlinks and enforce trailing slash boundary so sibling-prefix directories cannot match.
+        NSString *otaRoot = [[[otaPath stringByDeletingLastPathComponent] stringByResolvingSymlinksInPath] stringByStandardizingPath];
+        NSString *otaRootWithSlash = [otaRoot hasSuffix:@"/"] ? otaRoot : [otaRoot stringByAppendingString:@"/"];
+        NSString *candidate = [[[otaRoot stringByAppendingPathComponent:relativePath] stringByResolvingSymlinksInPath] stringByStandardizingPath];
+        BOOL otaPrefixOk = [candidate hasPrefix:otaRootWithSlash];
         BOOL otaExists = [[NSFileManager defaultManager] fileExistsAtPath:candidate];
         [SBLLogger info:[NSString stringWithFormat:@"[resolveAbs] rel=%@ ota root=%@ cand=%@ prefixOk=%d exists=%d",
                          relativePath, otaRoot, candidate, otaPrefixOk, otaExists]];
         if (otaPrefixOk && otaExists) {
             return candidate;
         }
+        [SBLLogger warn:[NSString stringWithFormat:@"[resolveAbs] rel=%@ missing in active OTA bundle root — refusing builtin fallback", relativePath]];
+        return nil;
     } else {
         [SBLLogger info:[NSString stringWithFormat:@"[resolveAbs] rel=%@ otaPath=(nil) — skipping OTA", relativePath]];
     }
 
     // 2. Fallback to builtin resource path
-    NSString *builtinRoot = [[[NSBundle mainBundle] resourcePath] stringByStandardizingPath];
-    NSString *candidate = [[builtinRoot stringByAppendingPathComponent:relativePath] stringByStandardizingPath];
-    BOOL builtinPrefixOk = [candidate hasPrefix:builtinRoot];
+    NSString *builtinRoot = [[[[NSBundle mainBundle] resourcePath] stringByResolvingSymlinksInPath] stringByStandardizingPath];
+    NSString *builtinRootWithSlash = [builtinRoot hasSuffix:@"/"] ? builtinRoot : [builtinRoot stringByAppendingString:@"/"];
+    NSString *candidate = [[[builtinRoot stringByAppendingPathComponent:relativePath] stringByResolvingSymlinksInPath] stringByStandardizingPath];
+    BOOL builtinPrefixOk = [candidate hasPrefix:builtinRootWithSlash];
     BOOL builtinExists = [[NSFileManager defaultManager] fileExistsAtPath:candidate];
     [SBLLogger info:[NSString stringWithFormat:@"[resolveAbs] rel=%@ builtin root=%@ cand=%@ prefixOk=%d exists=%d",
                      relativePath, builtinRoot, candidate, builtinPrefixOk, builtinExists]];
@@ -836,14 +883,16 @@ typedef NS_ENUM(NSInteger, ESegmentEvalError) {
             return;
         }
 
-        NSString *absolutePath = [SplitBundleLoader resolveAbsolutePath:relativePath];
+        NSString *otaPath = [self pinnedOtaBundlePath];
+        NSString *absolutePath = [SplitBundleLoader resolveAbsolutePath:relativePath
+                                                          otaBundlePath:otaPath];
         if (!absolutePath) {
             reject(@"SPLIT_BUNDLE_NOT_FOUND",
                    [NSString stringWithFormat:@"Segment file not found: %@", relativePath],
                    nil);
             return;
         }
-        if (![SplitBundleLoader verifySha256OfFile:absolutePath expected:sha256]) {
+        if (![SplitBundleLoader verifySha256OfFile:absolutePath expected:sha256 otaBundlePath:otaPath]) {
             reject(@"SPLIT_BUNDLE_SHA256_MISMATCH",
                    [NSString stringWithFormat:@"Segment SHA-256 mismatch: %@", relativePath],
                    nil);
@@ -1068,7 +1117,9 @@ typedef NS_ENUM(NSInteger, ESegmentEvalError) {
             return;
         }
 
-        NSString *absolutePath = [SplitBundleLoader resolveAbsolutePath:relativePath];
+        NSString *otaPath = [self pinnedOtaBundlePath];
+        NSString *absolutePath = [SplitBundleLoader resolveAbsolutePath:relativePath
+                                                          otaBundlePath:otaPath];
 
         if (!absolutePath) {
             reject(@"SPLIT_BUNDLE_NOT_FOUND",
@@ -1077,7 +1128,7 @@ typedef NS_ENUM(NSInteger, ESegmentEvalError) {
             return;
         }
 
-        if (![SplitBundleLoader verifySha256OfFile:absolutePath expected:sha256]) {
+        if (![SplitBundleLoader verifySha256OfFile:absolutePath expected:sha256 otaBundlePath:otaPath]) {
             reject(@"SPLIT_BUNDLE_SHA256_MISMATCH",
                    [NSString stringWithFormat:@"Segment SHA-256 mismatch: %@ (key=%@)", relativePath, segmentKey],
                    nil);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/react-native-split-bundle-loader",
-  "version": "3.0.180",
+  "version": "6.7.0-2",
   "description": "Native split JavaScript bundle context and segment loading for OneKey",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",