@exodus/react-native-bundle-loader 0.2.0-exodus.2 → 0.2.0-exodus.4

package/README.md

@@ -50,53 +50,26 @@ Behavior:
 
 Works on iOS and Android.
 
-### Unverified loading
-
-```ts
-BundleLoader.load('https://bundles.example.com/main.jsbundle');
-```
-
-Functionally identical to the upstream `load()`: passes the URL straight through to the native bridge, which fetches and reloads. **This skips integrity verification — only use it for developer ergonomics, never in production paths.**
-
-The URL is required to use `https:`.
-
-### `BundlePrompt`
-
-A `Modal`-wrapped text input + Reload button intended for developer UX. The default URL field is **empty** (the upstream's hardcoded jsdelivr default has been removed). The button calls the unverified `load()` path.
-
-```tsx
-import { BundlePrompt } from '@exodus/react-native-bundle-loader';
-```
-
-Do not render `BundlePrompt` in store builds.
-
-## Accessing a running Metro packager
-
-Same idea as upstream: expose your local Metro packager via a tunnel (e.g. `ngrok http 8081`) and call `BundleLoader.load(<https tunnel URL>)`. Required Metro query params:
-
-- `dev`: `true` or `false` matching how the binary was built
-- `excludeSource`: `true`
-- `platform`: `ios` or `android` matching the host
-
-Example: `https://example.ngrok.io/index.bundle?dev=false&platform=ios&excludeSource=true`
+> The library exposes **only** the verified path. There is no unverified `load()`
+> API: loading a remote bundle without native SHA-256 verification is an
+> unauthenticated remote-code-execution primitive, so it was removed.
 
 ## Platform support
 
 | Capability                  | iOS | Android |
 | --------------------------- | --- | ------- |
-| `load(url)`                 | ✅  | ✅      |
 | `loadVerified(url, sha256)` | ✅  | ✅      |
 | `runningMode()`             | ✅  | ✅      |
 
 ### How bundle loading works
 
-**iOS** downloads and verifies the bundle natively via `NSURLSession` + `CommonCrypto CC_SHA256`, writes it to `NSTemporaryDirectory()` with `NSDataWritingFileProtectionComplete`, then sets the bridge's `bundleURL` via KVC (`[bridge setValue:url forKey:@"bundleURL"]`) and calls `[bridge reload]`. This is an in-process reload: the old bridge is torn down and a new one is created with the cached file. Because iOS uses ARC, the old bridge's memory (including the Hermes runtime) is freed immediately when the bridge reference is released, before the new runtime allocates — no double-memory peak.
+**iOS** downloads and verifies the bundle natively via `NSURLSession` + `CommonCrypto CC_SHA256`, then writes the verified bytes to `NSTemporaryDirectory()` with `NSDataWritingAtomic | NSDataWritingFileProtectionComplete` (nothing is written before verification). It stores that file URL in `NSUserDefaults` under `RNBundleLoaderPendingURLKey` and calls `[bridge reload]`; the host app's `loadSourceForBridge:` reads the pending URL and loads from it, so the bridge's own `bundleURL` — and therefore `SourceCode.scriptURL` — is never mutated, keeping asset resolution correct. This is an in-process reload; under ARC the old bridge (and its Hermes runtime) is freed before the new one allocates, so there is no double-memory peak.
 
 **Android** uses a process restart instead of an in-process bridge swap. The reason: Android's ART garbage collector is non-deterministic. When a new React context is created alongside an existing one, ART does not guarantee the old Hermes runtime's native heap is freed before the new runtime allocates. On real-world bundle sizes (~50 MB of Hermes bytecode) this causes OOM. The process restart avoids the problem entirely by ensuring only one runtime is ever live.
 
 After download and hash verification, the module:
 
-1. Writes the bundle to `Context.getCacheDir()/verified-bundle.jsbundle`.
+1. Downloads to a temp file, verifies the SHA-256, then **atomically promotes** it to `Context.getCacheDir()/verified-bundle.jsbundle` — the canonical path never holds unverified or partial bytes. On a hash mismatch or download error the temp file is deleted and the current bundle is left untouched.
 2. Sets a one-shot flag in `SharedPreferences` (`"BundleLoader"` / `"pending_remote_bundle"`), using a synchronous `commit()` so the flag survives the imminent process kill.
 3. Restarts the process via `startActivity` + `Process.killProcess`.
 

package/SECURITY.md

@@ -16,8 +16,9 @@ This library exists to load and execute a remote JavaScript bundle inside the ho
 | Surface                                     | Upstream `0.1.0`                                        | This fork                                                                                                                          |
 | ------------------------------------------- | ------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------- |
 | Bundle integrity                            | None — bridge fetches whatever the URL serves           | `loadVerified(url, sha256)` downloads bytes natively (iOS: `NSURLSession`, Android: `HttpURLConnection`), hashes with platform crypto (iOS: `CommonCrypto CC_SHA256`, Android: `MessageDigest SHA-256`), compares in constant-time, writes to app-private storage, and reloads the bridge from the local file — closing the TOCTOU window between fetch and load |
-| `BundlePrompt` default URL                  | Hardcoded `cdn.jsdelivr.net/gh/jusbrasil/...` (deleted) | Empty — operator must type a URL                                                                                                   |
-| Scheme enforcement                          | None — accepts `http://`, `file://`, etc.               | `https://` required at the JS boundary; both native `load` implementations re-check before touching the network                     |
+| `BundlePrompt` component                    | URL-typing UI wired to the unverified `load()`          | Removed entirely with the unverified path                                                                                          |
+| Scheme enforcement                          | None — accepts `http://`, `file://`, etc.               | `https://` required at the JS boundary; the native `loadVerified` implementation re-checks before touching the network              |
+| Unverified `load()` path                    | `load(url)` fetches and reloads any URL, no integrity   | Removed — only `loadVerified(url, sha256)` remains; the unverified native methods, JS export, and `BundlePrompt` UI are gone         |
 | Verified bundle on-disk protection (iOS)    | n/a                                                     | Written with `NSDataWritingFileProtectionComplete`                                                                                 |
 | Lockfile                                    | Not shipped                                             | `yarn.lock` committed; `.yarnrc` enforces `--frozen-lockfile`                                                                      |
 | Dependency version pinning                  | Carets (`^`)                                            | All direct deps pinned to exact versions; `.npmrc` `save-exact=true`                                                               |
@@ -31,10 +32,16 @@ This library exists to load and execute a remote JavaScript bundle inside the ho
 | `example/public/ios.min.js` (700kB blob)    | Committed; served from jsdelivr to any `BundlePrompt`   | Removed along with the rest of `example/`                                                                                          |
 | CircleCI / Node 10 build container          | `.circleci/config.yml` shipped                          | Removed                                                                                                                            |
 
+## Latest hardening
+
+- **Removed the unverified `load()` path** — the `load(url)` native methods (iOS + Android), the JS `load` export, and the `BundlePrompt` UI. Loading a remote bundle without native SHA-256 verification is an unauthenticated RCE primitive; only `loadVerified` remains.
+- **Android verifies before install.** The download streams to a temp file; the verified bytes are atomically promoted (same-directory rename) to the canonical path only after the hash matches, and the temp is deleted on mismatch or download error — the canonical path never holds unverified or partial content.
+- **iOS bundle-size cap (64 MB)**, matching Android's, rejects oversized responses before they are hashed, written, or loaded.
+
 ## Accepted residual risks
 
-- **The bridge `bundleURL` setter is a KVC write** on iOS (`[bridge setValue:url forKey:@"bundleURL"]`) to a non-public RN property. Behavior could change on an RN upgrade and silently no-op the loader.
-- **The Android bundle swap reflects on a private field.** `ReactInstanceManager.mBundleLoader` has no public setter, so we use `Field.setAccessible(true)` to install a fresh `JSBundleLoader.createFileLoader(...)` before calling `recreateReactContextInBackground()`. The field name has been stable across RN 0.62–0.74 but is not part of the public API; an RN upgrade could rename or remove it, in which case `loadVerified`/`load` will throw `NoSuchFieldException` rather than silently no-op.
+- **The verified bundle is handed to the host app to load, not installed via a private RN API.** iOS writes the verified file URL to `NSUserDefaults` (`RNBundleLoaderPendingURLKey`), which the host app's `loadSourceForBridge:` override reads on reload; Android sets a one-shot `SharedPreferences` flag and restarts the process so the host app's `getJSBundleFile()` serves the file. The library depends on the host app implementing that read side (see the integration notes); if the host omits it the swap silently no-ops rather than loading unverified code. The library deliberately does **not** reach into non-public RN internals to force the swap.
+- **Session scoping is host-driven.** The remote bundle is active for one session; the host app clears the pending URL / active flag on cold start. The library cannot do this itself because it is not in the app's cold-start entry point (it only runs once RN is up).
 - **Hash verification runs in native code, not JS.** `loadVerifiedFromUrl` uses `CommonCrypto CC_SHA256` (iOS) and `MessageDigest SHA-256` (Android) with a constant-time XOR comparison loop in native code. This avoids a Hermes `RangeError: Maximum regex stack depth reached` that the previous JS-side `response.arrayBuffer()` path hit on bundles ≥ ~70 MB. The trade-off is that the integrity contract is no longer auditable as TypeScript.
 - **`timingSafeEqual` is an inlined XOR loop in native code.** Both `ios/BundleLoader.m` and `android/src/main/java/com/reactnativebundleloader/BundleLoaderModule.java` XOR all byte pairs into an accumulator and reject the bundle if the accumulator is non-zero.
 

package/android/src/main/java/com/reactnativebundleloader/BundleLoaderModule.java

@@ -3,10 +3,10 @@ package com.reactnativebundleloader;
 import android.content.Context;
 import android.content.Intent;
 import android.content.SharedPreferences;
-import android.util.Log;
 
 import androidx.annotation.NonNull;
 
+import com.facebook.react.ReactApplication;
 import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactContextBaseJavaModule;
@@ -23,13 +23,16 @@ import java.security.NoSuchAlgorithmException;
 
 public class BundleLoaderModule extends ReactContextBaseJavaModule {
 
-  private static final String TAG = "BundleLoader";
-  // These values are referenced by string literals in the host app's MainApplication.
-  // Do not rename without updating the host app integration accordingly.
+  // Host app references these as string literals (library is debugImplementation only).
   static final String BUNDLE_FILENAME = "verified-bundle.jsbundle";
+  // Bytes are downloaded here first and only promoted to BUNDLE_FILENAME after the
+  // hash matches, so the canonical path never holds unverified/partial content.
+  static final String BUNDLE_TMP_FILENAME = "verified-bundle.jsbundle.tmp";
   static final String PREFS_NAME = "BundleLoader";
   static final String PREFS_PENDING_KEY = "pending_remote_bundle";
   static final String PREFS_ACTIVE_KEY = "active_remote_bundle";
+  // Metro/APK source URL captured at load time for correct asset resolution after restart.
+  static final String PREFS_METRO_SOURCE_URL_KEY = "metro_source_url";
 
   private static final int CONNECT_TIMEOUT_MS = 30_000;
   private static final int READ_TIMEOUT_MS = 30_000;
@@ -45,36 +48,6 @@ public class BundleLoaderModule extends ReactContextBaseJavaModule {
     return "BundleLoader";
   }
 
-  @ReactMethod
-  public void load(final String url) {
-    if (!isHttps(url)) {
-      Log.e(TAG, "Bundle URL must use the https scheme");
-      return;
-    }
-    new Thread(new Runnable() {
-      @Override
-      public void run() {
-        try {
-          File targetFile = new File(
-              getReactApplicationContext().getCacheDir(),
-              BUNDLE_FILENAME
-          );
-          downloadToCache(
-              url,
-              targetFile,
-              CONNECT_TIMEOUT_MS,
-              READ_TIMEOUT_MS,
-              MAX_BUNDLE_BYTES
-          );
-          setPendingFlag();
-          restartApp();
-        } catch (Exception e) {
-          Log.e(TAG, "load(" + url + ") failed", e);
-        }
-      }
-    }, "BundleLoader-load").start();
-  }
-
   @ReactMethod
   public void loadVerifiedFromUrl(final String url, final String expectedSha256, final Promise promise) {
     if (!isHttps(url)) {
@@ -93,19 +66,22 @@ public class BundleLoaderModule extends ReactContextBaseJavaModule {
     new Thread(new Runnable() {
       @Override
       public void run() {
+        File cacheDir = getReactApplicationContext().getCacheDir();
+        File targetFile = new File(cacheDir, BUNDLE_FILENAME);
+        File tmpFile = new File(cacheDir, BUNDLE_TMP_FILENAME);
+        // Never write to the canonical path before verifying: download to a temp
+        // file, then promote it atomically only after the hash matches. Clear any
+        // stale temp left by a previously interrupted download.
+        tmpFile.delete();
         try {
-          File targetFile = new File(
-              getReactApplicationContext().getCacheDir(),
-              BUNDLE_FILENAME
-          );
           byte[] actualDigest = downloadAndHashToCache(
               url,
-              targetFile,
+              tmpFile,
               CONNECT_TIMEOUT_MS,
               READ_TIMEOUT_MS,
               MAX_BUNDLE_BYTES
           );
-          if (!timingSafeEquals(actualDigest, expectedDigest)) {
+          if (!verifyAndInstall(tmpFile, targetFile, actualDigest, expectedDigest)) {
             promise.reject("E_HASH_MISMATCH", "Bundle hash mismatch — refusing to load");
             return;
           }
@@ -114,6 +90,8 @@ public class BundleLoaderModule extends ReactContextBaseJavaModule {
           setPendingFlag();
           restartApp();
         } catch (Exception e) {
+          // Never leave a partial/unverified temp bundle on disk.
+          tmpFile.delete();
           promise.reject("E_LOAD_FAILED", e.getMessage(), e);
         }
       }
@@ -128,21 +106,35 @@ public class BundleLoaderModule extends ReactContextBaseJavaModule {
   }
 
   private void setPendingFlag() {
-    // commit() not apply() — apply() is async and the write may not reach disk
-    // before killProcess() terminates the process.
-    getReactApplicationContext()
+    SharedPreferences.Editor editor = getReactApplicationContext()
         .getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
         .edit()
-        .putBoolean(PREFS_PENDING_KEY, true)
-        .commit();
+        .putBoolean(PREFS_PENDING_KEY, true);
+
+    // Store scriptURL for asset resolution after restart: Metro URL if available,
+    // asset:/// otherwise (genesis/release — assets served from APK).
+    String sourceUrl = getMetroSourceUrl();
+    editor.putString(PREFS_METRO_SOURCE_URL_KEY,
+        sourceUrl != null ? sourceUrl : "asset:///index.android.bundle");
+
+    // commit() not apply() — write must reach disk before killProcess().
+    editor.commit();
   }
 
-  /**
-   * Restarts the app process. On next launch, MainApplication reads the pending
-   * flag from SharedPreferences and loads the cached bundle instead of Metro.
-   * A process restart avoids running both the old and new Hermes runtimes
-   * simultaneously, which would exceed the device heap limit.
-   */
+  private String getMetroSourceUrl() {
+    try {
+      ReactApplication app = (ReactApplication) getReactApplicationContext().getApplicationContext();
+      String url = app.getReactNativeHost()
+          .getReactInstanceManager()
+          .getDevSupportManager()
+          .getSourceUrl();
+      return (url != null && !url.isEmpty()) ? url : null;
+    } catch (Exception e) {
+      return null;
+    }
+  }
+
+  /** Kills and relaunches the process. Avoids running two Hermes runtimes simultaneously. */
   private void restartApp() {
     Context context = getReactApplicationContext();
     Intent intent = context.getPackageManager()
@@ -154,20 +146,12 @@ public class BundleLoaderModule extends ReactContextBaseJavaModule {
     android.os.Process.killProcess(android.os.Process.myPid());
   }
 
-  /**
-   * Returns true iff the URL is non-null and uses the https scheme.
-   * Extracted as a static helper so it can be unit-tested without the threading
-   * machinery in {@link #load(String)}.
-   */
+  /** Package-private for testing. */
   static boolean isHttps(String url) {
     return url != null && url.startsWith("https://");
   }
 
-  /**
-   * Parses a 64-character lowercase hex string into a 32-byte SHA-256 digest.
-   * Throws {@link IllegalArgumentException} on invalid input so callers can
-   * reject the promise before touching the network.
-   */
+  /** Parses a 64-char hex string into a 32-byte digest. Package-private for testing. */
   static byte[] parseHexSha256(String hex) {
     if (hex == null || hex.length() != 64) {
       throw new IllegalArgumentException("Expected SHA-256 must be a 64-character hex string");
@@ -184,11 +168,7 @@ public class BundleLoaderModule extends ReactContextBaseJavaModule {
     return out;
   }
 
-  /**
-   * Constant-time byte array comparison: XORs all pairs into an accumulator
-   * and returns true iff the accumulator is zero. Both arrays must be the
-   * same length; returns false immediately if they differ.
-   */
+  /** Constant-time equality check to prevent timing attacks. Package-private for testing. */
   static boolean timingSafeEquals(byte[] a, byte[] b) {
     if (a.length != b.length) return false;
     int diff = 0;
@@ -199,14 +179,34 @@ public class BundleLoaderModule extends ReactContextBaseJavaModule {
   }
 
   /**
-   * Downloads {@code urlString} into {@code targetFile}, computing SHA-256 of
-   * the body in the same streaming pass. Returns the 32-byte digest.
-   * <p>
-   * Mirrors the security properties of {@link #downloadToCache}: redirects are
-   * disabled, non-200 responses throw, and the body is capped at {@code maxBytes}.
-   * <p>
-   * Package-private and static so the JVM unit tests can drive it against a
-   * MockWebServer without spinning up a ReactApplicationContext.
+   * Constant-time compares {@code actualDigest} to {@code expectedDigest}. On match, atomically
+   * promotes {@code tmpFile} onto {@code targetFile} (same-directory rename) and returns true —
+   * so {@code targetFile} only ever holds verified bytes. On mismatch, deletes {@code tmpFile}
+   * and returns false. On a promotion failure, deletes {@code tmpFile} and throws. The temp file
+   * is never left behind. Package-private for testing.
+   */
+  static boolean verifyAndInstall(
+      File tmpFile,
+      File targetFile,
+      byte[] actualDigest,
+      byte[] expectedDigest
+  ) throws IOException {
+    if (!timingSafeEquals(actualDigest, expectedDigest)) {
+      tmpFile.delete();
+      return false;
+    }
+    // Same-directory rename is atomic on the app's (POSIX) filesystem and replaces any
+    // existing verified bundle in place, so the canonical path is never partially written.
+    if (!tmpFile.renameTo(targetFile)) {
+      tmpFile.delete();
+      throw new IOException("Failed to promote verified bundle to " + targetFile.getName());
+    }
+    return true;
+  }
+
+  /**
+   * Downloads into {@code targetFile} and returns its SHA-256 digest.
+   * No redirects; non-200 throws; body capped at {@code maxBytes}. Package-private for testing.
    */
   static byte[] downloadAndHashToCache(
       String urlString,
@@ -251,52 +251,4 @@ public class BundleLoaderModule extends ReactContextBaseJavaModule {
       conn.disconnect();
     }
   }
-
-  /**
-   * Downloads {@code urlString} into {@code targetFile} using HttpURLConnection.
-   * Redirects are not followed and non-200 responses throw IOException with the
-   * status code in the message. The download is hard-capped at {@code maxBytes};
-   * once the cap is exceeded the read loop aborts with IOException.
-   * <p>
-   * Package-private and static so the JVM unit tests can drive it against a
-   * MockWebServer without spinning up a ReactApplicationContext.
-   */
-  static File downloadToCache(
-      String urlString,
-      File targetFile,
-      int connectTimeoutMs,
-      int readTimeoutMs,
-      long maxBytes
-  ) throws IOException {
-    URL url = new URL(urlString);
-    HttpURLConnection conn = (HttpURLConnection) url.openConnection();
-    conn.setConnectTimeout(connectTimeoutMs);
-    conn.setReadTimeout(readTimeoutMs);
-    // Disallow follow-redirects so an HTTPS URL cannot transparently downgrade to HTTP.
-    conn.setInstanceFollowRedirects(false);
-    try {
-      int code = conn.getResponseCode();
-      if (code != HttpURLConnection.HTTP_OK) {
-        throw new IOException("Bundle fetch failed: HTTP " + code);
-      }
-      long total = 0;
-      try (InputStream in = conn.getInputStream();
-           FileOutputStream out = new FileOutputStream(targetFile)) {
-        byte[] buf = new byte[8192];
-        int n;
-        while ((n = in.read(buf)) != -1) {
-          total += n;
-          if (total > maxBytes) {
-            throw new IOException(
-                "Bundle exceeds " + maxBytes + " bytes"
-            );
-          }
-          out.write(buf, 0, n);
-        }
-      }
-      return targetFile;
-    } finally {
-      conn.disconnect();
-    }
-  }
 }

package/ios/BundleLoader.h

@@ -1,6 +1,9 @@
 #import <React/RCTBridgeModule.h>
 #import <React/RCTRootView.h>
 
+// NSUserDefaults key storing the pending remote bundle URL for loadSourceForBridge:.
+extern NSString * const RNBundleLoaderPendingURLKey;
+
 @interface BundleLoader : NSObject <RCTBridgeModule>
 
 @end

package/ios/BundleLoader.m

@@ -1,6 +1,13 @@
 #import "BundleLoader.h"
 #import <CommonCrypto/CommonDigest.h>
 
+NSString * const RNBundleLoaderPendingURLKey = @"RNBundleLoaderPendingURL";
+
+// Defensive cap on the downloaded bundle size (parity with the Android module's
+// MAX_BUNDLE_BYTES). Real bundles are ~50 MB; reject anything absurd before it is
+// hashed, written, or loaded.
+static const NSUInteger RNBundleLoaderMaxBundleBytes = 64UL * 1024UL * 1024UL;
+
 @implementation BundleLoader
 
 @synthesize bridge = _bridge;
@@ -9,26 +16,16 @@ RCT_EXPORT_MODULE()
 
 - (void)setBundleURLAndReload:(NSURL *)url
 {
-  [_bridge setValue:url forKey:@"bundleURL"];
+  [[NSUserDefaults standardUserDefaults] setURL:url forKey:RNBundleLoaderPendingURLKey];
+  [[NSUserDefaults standardUserDefaults] synchronize];
   [_bridge reload];
 }
 
 RCT_EXPORT_METHOD(runningMode:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 {
-  NSString *scheme = [[_bridge bundleURL] scheme];
-  BOOL isRemote = [scheme isEqualToString:@"https"];
-  resolve(isRemote ? @"REMOTE" : @"LOCAL");
-}
-
-RCT_EXPORT_METHOD(load:(NSURL *)url)
-{
-  if (![[url scheme] isEqualToString:@"https"]) {
-    return;
-  }
-  dispatch_async(dispatch_get_main_queue(), ^{
-    [self setBundleURLAndReload:url];
-  });
+  NSURL *pending = [[NSUserDefaults standardUserDefaults] URLForKey:RNBundleLoaderPendingURLKey];
+  resolve(pending ? @"REMOTE" : @"LOCAL");
 }
 
 // Downloads the bundle at `urlString`, verifies its SHA-256 digest against
@@ -84,6 +81,14 @@ RCT_EXPORT_METHOD(loadVerifiedFromUrl:(NSString *)urlString
       return;
     }
 
+    if (data.length > RNBundleLoaderMaxBundleBytes) {
+      reject(@"E_TOO_LARGE",
+             [NSString stringWithFormat:@"Bundle exceeds %lu bytes",
+                 (unsigned long)RNBundleLoaderMaxBundleBytes],
+             nil);
+      return;
+    }
+
     // Compute SHA-256 of the downloaded bytes.
     uint8_t actualDigest[CC_SHA256_DIGEST_LENGTH];
     CC_SHA256(data.bytes, (CC_LONG)data.length, actualDigest);

package/lib/commonjs/index.js

@@ -4,17 +4,10 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.loadVerified = loadVerified;
-exports.BundlePrompt = BundlePrompt;
 exports.default = void 0;
 
-var _react = _interopRequireWildcard(require("react"));
-
 var _reactNative = require("react-native");
 
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
 /** @format */
 function getNative() {
   const m = _reactNative.NativeModules.BundleLoader;
@@ -52,81 +45,17 @@ async function loadVerified(url, expectedSha256Hex) {
   await native.loadVerifiedFromUrl(url, expectedSha256Hex);
 }
 
-function loadUnverified(url) {
-  assertSafeUrl(url);
-  getNative().load(url);
-}
-
 async function runningMode() {
   return getNative().runningMode();
-}
+} // Only the verified load path is exposed. The unverified `load()` path was
+// removed (security): loading a remote bundle without native SHA-256
+// verification is a remote-code-execution primitive with no integrity check.
+
 
 const BundleLoader = {
-  load: loadUnverified,
   loadVerified,
   runningMode
 };
 var _default = BundleLoader;
 exports.default = _default;
-
-const styles = _reactNative.StyleSheet.create({
-  container: {
-    marginTop: 48,
-    padding: 16,
-    flex: 1
-  },
-  input: {
-    height: 48,
-    marginTop: 8,
-    paddingHorizontal: 8,
-    borderColor: 'gray',
-    borderRadius: 4,
-    borderWidth: 1
-  },
-  button: {
-    backgroundColor: '#007AFF',
-    marginTop: 16,
-    height: 48,
-    justifyContent: 'center'
-  },
-  buttonText: {
-    color: 'white',
-    alignSelf: 'center',
-    fontSize: 18,
-    alignContent: 'center'
-  }
-});
-
-function BundlePrompt() {
-  const [url, setUrl] = (0, _react.useState)('');
-  const reload = (0, _react.useCallback)(() => {
-    if (!url) {
-      _reactNative.Alert.alert('Oops…', 'You need to provide a URL');
-
-      return;
-    }
-
-    try {
-      loadUnverified(url);
-    } catch (e) {
-      _reactNative.Alert.alert('Invalid URL', e.message);
-    }
-  }, [url]);
-  return /*#__PURE__*/_react.default.createElement(_reactNative.Modal, null, /*#__PURE__*/_react.default.createElement(_reactNative.View, {
-    style: styles.container
-  }, /*#__PURE__*/_react.default.createElement(_reactNative.TextInput, {
-    keyboardType: "url",
-    onChange: e => setUrl(e.nativeEvent.text.trim()),
-    style: styles.input,
-    clearButtonMode: "always",
-    autoFocus: true,
-    placeholder: "https://\u2026"
-  }), /*#__PURE__*/_react.default.createElement(_reactNative.TouchableOpacity, {
-    style: styles.button,
-    onPress: reload,
-    accessibilityLabel: "Reload entire app"
-  }, /*#__PURE__*/_react.default.createElement(_reactNative.Text, {
-    style: styles.buttonText
-  }, "Reload"))));
-}
 //# sourceMappingURL=index.js.map

package/lib/module/index.js

@@ -1,6 +1,5 @@
 /** @format */
-import React, { useCallback, useState } from 'react';
-import { Alert, Modal, NativeModules, StyleSheet, Text, TextInput, TouchableOpacity, View } from 'react-native';
+import { NativeModules } from 'react-native';
 
 function getNative() {
   const m = NativeModules.BundleLoader;
@@ -38,77 +37,16 @@ export async function loadVerified(url, expectedSha256Hex) {
   await native.loadVerifiedFromUrl(url, expectedSha256Hex);
 }
 
-function loadUnverified(url) {
-  assertSafeUrl(url);
-  getNative().load(url);
-}
-
 async function runningMode() {
   return getNative().runningMode();
-}
+} // Only the verified load path is exposed. The unverified `load()` path was
+// removed (security): loading a remote bundle without native SHA-256
+// verification is a remote-code-execution primitive with no integrity check.
+
 
 const BundleLoader = {
-  load: loadUnverified,
   loadVerified,
   runningMode
 };
 export default BundleLoader;
-const styles = StyleSheet.create({
-  container: {
-    marginTop: 48,
-    padding: 16,
-    flex: 1
-  },
-  input: {
-    height: 48,
-    marginTop: 8,
-    paddingHorizontal: 8,
-    borderColor: 'gray',
-    borderRadius: 4,
-    borderWidth: 1
-  },
-  button: {
-    backgroundColor: '#007AFF',
-    marginTop: 16,
-    height: 48,
-    justifyContent: 'center'
-  },
-  buttonText: {
-    color: 'white',
-    alignSelf: 'center',
-    fontSize: 18,
-    alignContent: 'center'
-  }
-});
-export function BundlePrompt() {
-  const [url, setUrl] = useState('');
-  const reload = useCallback(() => {
-    if (!url) {
-      Alert.alert('Oops…', 'You need to provide a URL');
-      return;
-    }
-
-    try {
-      loadUnverified(url);
-    } catch (e) {
-      Alert.alert('Invalid URL', e.message);
-    }
-  }, [url]);
-  return /*#__PURE__*/React.createElement(Modal, null, /*#__PURE__*/React.createElement(View, {
-    style: styles.container
-  }, /*#__PURE__*/React.createElement(TextInput, {
-    keyboardType: "url",
-    onChange: e => setUrl(e.nativeEvent.text.trim()),
-    style: styles.input,
-    clearButtonMode: "always",
-    autoFocus: true,
-    placeholder: "https://\u2026"
-  }), /*#__PURE__*/React.createElement(TouchableOpacity, {
-    style: styles.button,
-    onPress: reload,
-    accessibilityLabel: "Reload entire app"
-  }, /*#__PURE__*/React.createElement(Text, {
-    style: styles.buttonText
-  }, "Reload"))));
-}
 //# sourceMappingURL=index.js.map

package/lib/typescript/index.d.ts

@@ -1,12 +1,8 @@
-/// <reference types="react" />
 export declare type RunningMode = 'LOCAL' | 'REMOTE';
 export declare function loadVerified(url: string, expectedSha256Hex: string): Promise<void>;
-declare function loadUnverified(url: string): void;
 declare function runningMode(): Promise<RunningMode>;
 declare const BundleLoader: {
-    load: typeof loadUnverified;
     loadVerified: typeof loadVerified;
     runningMode: typeof runningMode;
 };
 export default BundleLoader;
-export declare function BundlePrompt(): JSX.Element;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/react-native-bundle-loader",
-  "version": "0.2.0-exodus.2",
+  "version": "0.2.0-exodus.4",
   "description": "Loads a remote React Native JS bundle.",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",

package/src/index.tsx

@@ -1,22 +1,9 @@
 /** @format */
-import React, { useCallback, useState } from 'react';
-import {
-  Alert,
-  Modal,
-  NativeModules,
-  NativeSyntheticEvent,
-  StyleSheet,
-  Text,
-  TextInput,
-  TextInputChangeEventData,
-  TouchableOpacity,
-  View,
-} from 'react-native';
+import { NativeModules } from 'react-native';
 
 export type RunningMode = 'LOCAL' | 'REMOTE';
 
 type NativeBundleLoader = {
-  load(url: string): void;
   loadVerifiedFromUrl?(url: string, sha256: string): Promise<void>;
   runningMode(): Promise<RunningMode>;
 };
@@ -66,83 +53,16 @@ export async function loadVerified(
   await native.loadVerifiedFromUrl(url, expectedSha256Hex);
 }
 
-function loadUnverified(url: string): void {
-  assertSafeUrl(url);
-  getNative().load(url);
-}
-
 async function runningMode(): Promise<RunningMode> {
   return getNative().runningMode();
 }
 
+// Only the verified load path is exposed. The unverified `load()` path was
+// removed (security): loading a remote bundle without native SHA-256
+// verification is a remote-code-execution primitive with no integrity check.
 const BundleLoader = {
-  load: loadUnverified,
   loadVerified,
   runningMode,
 };
 
 export default BundleLoader;
-
-const styles = StyleSheet.create({
-  container: { marginTop: 48, padding: 16, flex: 1 },
-  input: {
-    height: 48,
-    marginTop: 8,
-    paddingHorizontal: 8,
-    borderColor: 'gray',
-    borderRadius: 4,
-    borderWidth: 1,
-  },
-  button: {
-    backgroundColor: '#007AFF',
-    marginTop: 16,
-    height: 48,
-    justifyContent: 'center',
-  },
-  buttonText: {
-    color: 'white',
-    alignSelf: 'center',
-    fontSize: 18,
-    alignContent: 'center',
-  },
-});
-
-export function BundlePrompt() {
-  const [url, setUrl] = useState<string>('');
-
-  const reload = useCallback(() => {
-    if (!url) {
-      Alert.alert('Oops…', 'You need to provide a URL');
-      return;
-    }
-    try {
-      loadUnverified(url);
-    } catch (e) {
-      Alert.alert('Invalid URL', (e as Error).message);
-    }
-  }, [url]);
-
-  return (
-    <Modal>
-      <View style={styles.container}>
-        <TextInput
-          keyboardType="url"
-          onChange={(e: NativeSyntheticEvent<TextInputChangeEventData>) =>
-            setUrl(e.nativeEvent.text.trim())
-          }
-          style={styles.input}
-          clearButtonMode="always"
-          autoFocus
-          placeholder="https://…"
-        />
-        <TouchableOpacity
-          style={styles.button}
-          onPress={reload}
-          accessibilityLabel="Reload entire app"
-        >
-          <Text style={styles.buttonText}>Reload</Text>
-        </TouchableOpacity>
-      </View>
-    </Modal>
-  );
-}