react-native-update 10.48.2 → 10.49.0

package/README.md

@@ -17,13 +17,45 @@ See the docs:
 ## Advantages
 
 1. react-native-update provides a dedicated global service with fast and reliable worldwide delivery.
-2. **Tiny update packages** generated with bsdiff/hdiff are typically only tens to hundreds of KB, instead of the tens of MB usually required by full-bundle update systems.
+2. **Tiny update packages** generated with bsdiff/hdiff are typically only tens to hundreds of KB, instead of the tens of MB usually required by full-bundle update systems. On top of that, the diff algorithm is **specifically optimized for Hermes bytecode** (see the [comparison below](#diff-algorithm-comparison)), shrinking patches even further.
 3. The library tracks new React Native stable releases closely, supports Hermes bytecode, and supports the new architecture. Note: Android RN 0.73.0 to 0.76.0 new architecture is unavailable because of upstream issues; versions below 0.73 or above 0.76.1 are supported.
 4. When updating across multiple versions, clients only need to download **one update package** instead of applying every intermediate version in sequence.
 5. Command-line tools and a web dashboard are both available, making release workflows simple and CI-friendly.
-6. Built-in crash rollback keeps updates safe and reliable.
-7. Meta information and open APIs make the system more extensible.
-8. Paid technical support is available.
+6. The dashboard ships with **built-in analytics** (version distribution, update success rate), **staged (gray) rollouts** by percentage, and **release health monitoring** — no need to build your own data pipeline to keep every release under control.
+7. Built-in crash rollback keeps updates safe and reliable, and health monitoring helps you catch and stop a bad release early.
+8. Meta information and open APIs make the system more extensible.
+9. Paid technical support is available.
+
+## Diff Algorithm Comparison
+
+Traditional diff algorithms operate on raw bytes. Hermes bytecode, however, is full of offset tables — a small JS change shifts every subsequent offset, which dramatically amplifies the binary difference. Before running hdiff, we apply a **delta-friendly reversible transform tailored to HBC (Hermes bytecode)**: offset bitfields are delta-encoded so the offset-shift amplification disappears at the source. The layout description table is shipped with each patch, so when Hermes evolves, **clients need zero upgrades** — compatibility is automatic.
+
+The numbers below are measured on real release bundles of a React Native 0.86 app (Hermes HBC v98, ~4.4 MB bytecode); every patch is verified by an actual round-trip before its size is recorded. Full methodology, fixtures, and runnable code: **[hbc-diff-benchmark](https://github.com/sunnylqm/hbc-diff-benchmark)**.
+
+**Hermes bytecode (.hbc) — what ships in production Hermes apps:**
+
+| Scenario | Full OTA (gzip) | bsdiff | bsdiff+lzma | hdiff | hdiff + HBC transform |
+|---|---|---|---|---|---|
+| One-line text change | 1901.5 KB | 93.7 KB | 87.7 KB | 89.0 KB | **63.5 KB** (−28% / −29%) |
+| Small feature (~60 LOC) | 1913.9 KB | 411.6 KB | 330.9 KB | 328.0 KB | **285.5 KB** (−14% / −13%) |
+| Medium feature (~300 LOC) | 1973.7 KB | 551.6 KB | 430.6 KB | 431.6 KB | **398.4 KB** (−7% / −8%) |
+
+**Plain-text JS bundle — non-Hermes apps (same scenarios, same app):**
+
+| Scenario | Full OTA (gzip) | bsdiff | bsdiff+lzma | hdiff |
+|---|---|---|---|---|
+| One-line text change | 807.2 KB | 0.3 KB | 0.7 KB | **0.1 KB** |
+| Small feature (~60 LOC) | 813.1 KB | 7.4 KB | 7.4 KB | **5.8 KB** |
+| Medium feature (~300 LOC) | 837.7 KB | 38.4 KB | 37.4 KB | **28.7 KB** |
+
+Text bundles have no offset tables, so they diff cleanly without any transform — patches are hundreds of bytes to tens of KB, and hdiff still beats bsdiff by ~20–25% on the larger changes. The offset-shift amplification is a Hermes-bytecode-specific problem, which is exactly why the HBC transform exists.
+
+Highlights:
+
+- Incremental updates save **5–30×** bandwidth compared to full-bundle OTA (63.5 KB vs 1.9 MB for a one-line change).
+- The bsdiff+lzma control group (same bsdiff delta, lzma compression) shows the compressor accounts for most of the bsdiff-vs-hdiff gap — the further **7–29%** cut from the HBC-aware transform is **pure algorithmic gain**, largest on the small, frequent updates that dominate real OTA traffic.
+- Patch generation with hdiff is **2–4× faster** than bsdiff; the transform itself costs single-digit milliseconds.
+- Safety first: section bounds and bitfield ranges are fully validated before any byte is touched, and the pipeline automatically falls back to plain hdiff on any mismatch.
 
 ## Comparison With Other OTA Libraries
 
@@ -31,6 +63,10 @@ See the docs:
 |---------|---------------------|-------------|------------------------|
 | **Price / Cost** | Free tier with multiple paid plans, bandwidth included | Free tier with multiple paid plans, extra bandwidth charges apply | ❌ **Discontinued** (Microsoft App Center shut down on March 31, 2025) |
 | **Package Size** | ⭐⭐⭐⭐⭐ Tens to hundreds of KB (incremental) | ⭐⭐⭐ Full bundle updates (usually tens of MB) | ❌ **Discontinued** |
+| **Hermes-specific diff** | ✅ HBC-aware transform, smallest patches | ❌ Full bundle | ❌ **Discontinued** |
+| **Staged (gray) rollout** | ✅ Built-in, percentage-based | ✅ Supported | ❌ **Discontinued** |
+| **Analytics** | ✅ Built-in (version distribution, success rate) | ⚠️ Limited | ❌ **Discontinued** |
+| **Release health monitoring** | ✅ Built-in | ❌ Not available | ❌ **Discontinued** |
 | **Technical Support** | ✅ Paid dedicated support | ⚠️ Community support | ❌ **Discontinued** |
 | **Server Deployment** | ✅ Hosted service or paid private deployment | ✅ Hosted by Expo (EAS Update) | ❌ **Discontinued** |
 | **Bandwidth Usage** | ⭐⭐⭐⭐⭐ Very low (incremental) | ⭐⭐⭐ Higher (full bundle) | ❌ **Discontinued** |

package/android/jni/Android.mk

@@ -21,6 +21,7 @@ Hdp_Files := \
 
 LOCAL_SRC_FILES := \
 	../../cpp/patch_core/archive_patch_core.cpp \
+	../../cpp/patch_core/digest.cpp \
 	../../cpp/patch_core/hbc_transform.cpp \
 	../../cpp/patch_core/hbc_transform_wire.cpp \
 	../../cpp/patch_core/patch_core.cpp \

package/android/src/main/java/cn/reactnative/modules/update/UpdateContext.java

@@ -9,6 +9,10 @@ import android.os.Environment;
 import android.util.Log;
 import com.facebook.react.ReactInstanceManager;
 import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
 import java.util.concurrent.Executor;
 import java.util.concurrent.Executors;
 
@@ -118,6 +122,91 @@ public class UpdateContext {
         return isUsingBundleUrl;
     }
 
+    // bundleHash cache: "<packageVersion>|<lastUpdateTime>|<sha256hex>". The
+    // key identifies the installed binary; every (re)install changes
+    // lastUpdateTime, so the hash is recomputed once per install.
+    private static final String KEY_BUNDLE_HASH_CACHE = "bundleHashCache";
+
+    public interface BundleHashListener {
+        void onBundleHash(String hash);
+    }
+
+    /**
+     * bundleHash = sha256 of the JS bundle embedded in the binary — the
+     * identity of the binary itself, not of whatever hot update is currently
+     * running. Hashes exactly the bytes pdiff patches from: the hardcoded
+     * "index.android.bundle" asset read via AssetManager, same as
+     * DownloadTask.copyBundledAssetToFile. Runs on the download executor;
+     * never fails — an empty string means "unknown" and the server falls back
+     * to the buildTime heuristic.
+     *
+     * Deliberately java.security.MessageDigest instead of the C++
+     * pushy::digest: librnupdate.so is a prebuilt artifact and this must not
+     * force a rebuild. The NIST vectors in the patch_core tests anchor both
+     * implementations to the same standard.
+     */
+    public void getBundleHash(final BundleHashListener listener) {
+        if (DEBUG) {
+            // Metro serves the bundle in debug; mirror the dev buildTime behaviour.
+            listener.onBundleHash("");
+            return;
+        }
+        executor.execute(new Runnable() {
+            @Override
+            public void run() {
+                listener.onBundleHash(computeBundleHash());
+            }
+        });
+    }
+
+    private String computeBundleHash() {
+        String cachePrefix = getPackageVersion() + "|" + getPackageLastUpdateTime() + "|";
+        String cached = sp.getString(KEY_BUNDLE_HASH_CACHE, null);
+        if (cached != null && cached.startsWith(cachePrefix)) {
+            return cached.substring(cachePrefix.length());
+        }
+        String hash = sha256OfBundledAsset("index.android.bundle");
+        if (!hash.isEmpty()) {
+            SharedPreferences.Editor editor = sp.edit();
+            editor.putString(KEY_BUNDLE_HASH_CACHE, cachePrefix + hash);
+            persistEditor(editor, "cache bundle hash");
+        }
+        return hash;
+    }
+
+    private long getPackageLastUpdateTime() {
+        try {
+            PackageInfo pi = context.getPackageManager()
+                .getPackageInfo(context.getPackageName(), 0);
+            return pi.lastUpdateTime;
+        } catch (PackageManager.NameNotFoundException e) {
+            return 0;
+        }
+    }
+
+    private String sha256OfBundledAsset(String assetName) {
+        try (InputStream in = context.getAssets().open(assetName)) {
+            MessageDigest md = MessageDigest.getInstance("SHA-256");
+            byte[] buffer = new byte[64 * 1024];
+            int read;
+            while ((read = in.read(buffer)) != -1) {
+                md.update(buffer, 0, read);
+            }
+            byte[] digest = md.digest();
+            StringBuilder hex = new StringBuilder(digest.length * 2);
+            for (byte b : digest) {
+                hex.append(Character.forDigit((b >> 4) & 0xf, 16));
+                hex.append(Character.forDigit(b & 0xf, 16));
+            }
+            return hex.toString();
+        } catch (IOException | NoSuchAlgorithmException e) {
+            // Expected when there is no embedded bundle (custom name, no
+            // release bundle); "unknown" is a valid answer, not an error.
+            Log.i(TAG, "Cannot hash bundled asset " + assetName + ": " + e);
+            return "";
+        }
+    }
+
     private void enqueue(DownloadTaskParams params) {
         executor.execute(new DownloadTask(context, params));
     }

package/android/src/main/java/cn/reactnative/modules/update/UpdateEventEmitter.java

@@ -6,6 +6,7 @@ import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
 import com.facebook.react.bridge.WritableMap;
 import java.lang.ref.WeakReference;
+import java.lang.reflect.Method;
 
 final class UpdateEventEmitter {
     private static WeakReference<ReactApplicationContext> reactContextRef =
@@ -45,12 +46,20 @@ final class UpdateEventEmitter {
     @SuppressWarnings("deprecation")
     private static boolean hasActiveInstance(ReactApplicationContext reactContext) {
         try {
-            // hasActiveCatalystInstance() is always false in bridgeless mode, which
-            // silently drops every progress event on the new architecture.
-            return reactContext.hasActiveReactInstance();
-        } catch (NoSuchMethodError e) {
+            // Use reflection for hasActiveReactInstance() because older RN versions (<0.68)
+            // don't have this method in the class signature at compile time.
+            Method method = reactContext.getClass().getMethod("hasActiveReactInstance");
+            Object result = method.invoke(reactContext);
+            if (result instanceof Boolean) {
+                return (Boolean) result;
+            }
+        } catch (Throwable ignored) {
             // RN < 0.68 has no hasActiveReactInstance(); fall back for old peers.
+        }
+        try {
             return reactContext.hasActiveCatalystInstance();
+        } catch (Throwable ignored) {
+            return false;
         }
     }
 }

package/android/src/main/java/cn/reactnative/modules/update/UpdateModuleImpl.java

@@ -191,6 +191,17 @@ public class UpdateModuleImpl {
         });
     }
 
+    public static void getBundleHash(final UpdateContext updateContext, final Promise promise) {
+        // Threading lives in UpdateContext (download executor); resolve is
+        // thread-safe. Never rejects — empty string means "unknown".
+        updateContext.getBundleHash(new UpdateContext.BundleHashListener() {
+            @Override
+            public void onBundleHash(String hash) {
+                promise.resolve(hash);
+            }
+        });
+    }
+
     public static void resetToPackagedBundle(
         final UpdateContext updateContext,
         final Promise promise

package/android/src/newarch/cn/reactnative/modules/update/UpdateModule.java

@@ -73,6 +73,11 @@ public class UpdateModule extends NativePushySpec {
         UpdateModuleImpl.markSuccess(updateContext, promise);
     }
 
+    @Override
+    public void getBundleHash(Promise promise) {
+        UpdateModuleImpl.getBundleHash(updateContext, promise);
+    }
+
     @Override
     public void resetToPackagedBundle(Promise promise) {
         UpdateModuleImpl.resetToPackagedBundle(updateContext, promise);

package/android/src/oldarch/cn/reactnative/modules/update/UpdateModule.java

@@ -75,6 +75,11 @@ public class UpdateModule extends ReactContextBaseJavaModule {
         UpdateModuleImpl.markSuccess(updateContext);
     }
 
+    @ReactMethod
+    public void getBundleHash(Promise promise) {
+        UpdateModuleImpl.getBundleHash(updateContext, promise);
+    }
+
     @ReactMethod
     public void resetToPackagedBundle(Promise promise) {
         UpdateModuleImpl.resetToPackagedBundle(updateContext, promise);

package/biome.json

@@ -0,0 +1,59 @@
+{
+  "$schema": "https://biomejs.dev/schemas/2.5.5/schema.json",
+  "vcs": {
+    "enabled": true,
+    "clientKind": "git",
+    "useIgnoreFile": true
+  },
+  "files": {
+    "ignoreUnknown": true,
+    "includes": [
+      "**/*.js",
+      "**/*.jsx",
+      "**/*.ts",
+      "**/*.tsx",
+      "**/*.json",
+      "!**/node_modules",
+      "!**/android",
+      "!**/ios",
+      "!**/dist",
+      "!**/harmony",
+      "!**/.tmp"
+    ]
+  },
+  "formatter": {
+    "enabled": true,
+    "indentStyle": "space",
+    "indentWidth": 2,
+    "lineWidth": 80
+  },
+  "assist": {
+    "actions": {
+      "source": {
+        "organizeImports": "on"
+      }
+    }
+  },
+  "linter": {
+    "enabled": true,
+    "rules": {
+      "preset": "recommended",
+      "suspicious": {
+        "noExplicitAny": "off"
+      },
+      "style": {
+        "noNonNullAssertion": "off"
+      },
+      "complexity": {
+        "noUselessFragments": "off"
+      }
+    }
+  },
+  "javascript": {
+    "formatter": {
+      "quoteStyle": "single",
+      "jsxQuoteStyle": "double",
+      "trailingCommas": "es5"
+    }
+  }
+}

package/cpp/patch_core/digest.cpp

@@ -0,0 +1,177 @@
+#include "digest.h"
+
+#include <cstdio>
+#include <cstring>
+
+namespace pushy {
+namespace digest {
+
+namespace {
+
+// FIPS 180-4 SHA-256 round constants.
+constexpr uint32_t kRoundConstants[64] = {
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1,
+    0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
+    0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786,
+    0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147,
+    0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
+    0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b,
+    0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a,
+    0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
+    0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+};
+
+inline uint32_t RotateRight(uint32_t value, uint32_t bits) {
+  return (value >> bits) | (value << (32 - bits));
+}
+
+}  // namespace
+
+Sha256::Sha256() {
+  state_[0] = 0x6a09e667;
+  state_[1] = 0xbb67ae85;
+  state_[2] = 0x3c6ef372;
+  state_[3] = 0xa54ff53a;
+  state_[4] = 0x510e527f;
+  state_[5] = 0x9b05688c;
+  state_[6] = 0x1f83d9ab;
+  state_[7] = 0x5be0cd19;
+}
+
+void Sha256::ProcessBlock(const uint8_t* block) {
+  uint32_t w[64];
+  for (int i = 0; i < 16; i++) {
+    w[i] = (static_cast<uint32_t>(block[i * 4]) << 24) |
+           (static_cast<uint32_t>(block[i * 4 + 1]) << 16) |
+           (static_cast<uint32_t>(block[i * 4 + 2]) << 8) |
+           static_cast<uint32_t>(block[i * 4 + 3]);
+  }
+  for (int i = 16; i < 64; i++) {
+    const uint32_t s0 = RotateRight(w[i - 15], 7) ^ RotateRight(w[i - 15], 18) ^
+                        (w[i - 15] >> 3);
+    const uint32_t s1 = RotateRight(w[i - 2], 17) ^ RotateRight(w[i - 2], 19) ^
+                        (w[i - 2] >> 10);
+    w[i] = w[i - 16] + s0 + w[i - 7] + s1;
+  }
+
+  uint32_t a = state_[0];
+  uint32_t b = state_[1];
+  uint32_t c = state_[2];
+  uint32_t d = state_[3];
+  uint32_t e = state_[4];
+  uint32_t f = state_[5];
+  uint32_t g = state_[6];
+  uint32_t h = state_[7];
+
+  for (int i = 0; i < 64; i++) {
+    const uint32_t s1 =
+        RotateRight(e, 6) ^ RotateRight(e, 11) ^ RotateRight(e, 25);
+    const uint32_t ch = (e & f) ^ (~e & g);
+    const uint32_t temp1 = h + s1 + ch + kRoundConstants[i] + w[i];
+    const uint32_t s0 =
+        RotateRight(a, 2) ^ RotateRight(a, 13) ^ RotateRight(a, 22);
+    const uint32_t maj = (a & b) ^ (a & c) ^ (b & c);
+    const uint32_t temp2 = s0 + maj;
+
+    h = g;
+    g = f;
+    f = e;
+    e = d + temp1;
+    d = c;
+    c = b;
+    b = a;
+    a = temp1 + temp2;
+  }
+
+  state_[0] += a;
+  state_[1] += b;
+  state_[2] += c;
+  state_[3] += d;
+  state_[4] += e;
+  state_[5] += f;
+  state_[6] += g;
+  state_[7] += h;
+}
+
+void Sha256::Update(const uint8_t* data, size_t length) {
+  total_length_ += length;
+
+  if (buffer_length_ > 0) {
+    const size_t fill = 64 - buffer_length_;
+    const size_t take = length < fill ? length : fill;
+    std::memcpy(buffer_ + buffer_length_, data, take);
+    buffer_length_ += take;
+    data += take;
+    length -= take;
+    if (buffer_length_ < 64) {
+      return;
+    }
+    ProcessBlock(buffer_);
+    buffer_length_ = 0;
+  }
+
+  while (length >= 64) {
+    ProcessBlock(data);
+    data += 64;
+    length -= 64;
+  }
+
+  if (length > 0) {
+    std::memcpy(buffer_, data, length);
+    buffer_length_ = length;
+  }
+}
+
+std::string Sha256::HexDigest() {
+  // Padding: 0x80, zeros, then the 64-bit big-endian bit length.
+  const uint64_t bit_length = total_length_ * 8;
+  const uint8_t pad_byte = 0x80;
+  Update(&pad_byte, 1);
+  const uint8_t zero = 0x00;
+  // total_length_ is mutated by the padding updates; the final length field is
+  // captured above, so this loop only needs to reach the 56-byte boundary.
+  while (buffer_length_ != 56) {
+    Update(&zero, 1);
+  }
+  uint8_t length_bytes[8];
+  for (int i = 0; i < 8; i++) {
+    length_bytes[i] = static_cast<uint8_t>(bit_length >> (56 - i * 8));
+  }
+  Update(length_bytes, 8);
+
+  static const char kHex[] = "0123456789abcdef";
+  std::string out;
+  out.reserve(64);
+  for (int i = 0; i < 8; i++) {
+    for (int shift = 24; shift >= 0; shift -= 8) {
+      const uint8_t byte = static_cast<uint8_t>(state_[i] >> shift);
+      out.push_back(kHex[byte >> 4]);
+      out.push_back(kHex[byte & 0x0f]);
+    }
+  }
+  return out;
+}
+
+std::string Sha256File(const std::string& path) {
+  std::FILE* file = std::fopen(path.c_str(), "rb");
+  if (file == nullptr) {
+    return std::string();
+  }
+  Sha256 hasher;
+  uint8_t buffer[64 * 1024];
+  size_t read = 0;
+  while ((read = std::fread(buffer, 1, sizeof(buffer), file)) > 0) {
+    hasher.Update(buffer, read);
+  }
+  const bool failed = std::ferror(file) != 0;
+  std::fclose(file);
+  if (failed) {
+    return std::string();
+  }
+  return hasher.HexDigest();
+}
+
+}  // namespace digest
+}  // namespace pushy

package/cpp/patch_core/digest.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <string>
+
+namespace pushy {
+namespace digest {
+
+// Streaming SHA-256 (FIPS 180-4). Used for bundleHash (the identity of the
+// bundle embedded in the binary) and, later, download artifact verification
+// (IO-6). Streaming because Android/Harmony read the bundle from the package
+// (AssetManager / rawfile) rather than from a plain file.
+//
+// Android intentionally does NOT use this implementation: librnupdate.so is a
+// prebuilt artifact, so the Java layer hashes with java.security.MessageDigest
+// instead. The NIST vectors in the tests anchor both implementations to the
+// same standard.
+class Sha256 {
+ public:
+  Sha256();
+
+  void Update(const uint8_t* data, size_t length);
+
+  // Finalizes and returns the lowercase hex digest. The instance must not be
+  // reused afterwards.
+  std::string HexDigest();
+
+ private:
+  void ProcessBlock(const uint8_t* block);
+
+  uint32_t state_[8];
+  uint64_t total_length_ = 0;
+  uint8_t buffer_[64];
+  size_t buffer_length_ = 0;
+};
+
+// Hashes a file on disk (streaming, bounded memory). Returns the lowercase hex
+// digest, or an empty string if the file cannot be read.
+std::string Sha256File(const std::string& path);
+
+}  // namespace digest
+}  // namespace pushy

package/cpp/patch_core/tests/patch_core_test.cpp

@@ -1,4 +1,5 @@
 #include "../archive_patch_core.h"
+#include "../digest.h"
 #include "../patch_core.h"
 #include "../state_core.h"
 
@@ -747,6 +748,72 @@ void TestStateCoreSwitchToSameVersion() {
   Expect(!switched.first_time_ok, "first_time_ok should be false");
 }
 
+// NIST FIPS 180-4 vectors. These anchor the C++ implementation (iOS/Harmony)
+// and, by transitivity, Android's java.security.MessageDigest and the CLI's
+// node:crypto to the same standard — the bundleHash produced on any of them
+// must be byte-identical for the same input.
+void TestSha256KnownVectors() {
+  {
+    pushy::digest::Sha256 hasher;
+    ExpectEq(
+        hasher.HexDigest(),
+        "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256 of empty input");
+  }
+  {
+    pushy::digest::Sha256 hasher;
+    const char* input = "abc";
+    hasher.Update(reinterpret_cast<const uint8_t*>(input), 3);
+    ExpectEq(
+        hasher.HexDigest(),
+        "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad",
+        "sha256 of \"abc\"");
+  }
+  {
+    pushy::digest::Sha256 hasher;
+    const std::string input =
+        "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq";
+    hasher.Update(
+        reinterpret_cast<const uint8_t*>(input.data()), input.size());
+    ExpectEq(
+        hasher.HexDigest(),
+        "248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1",
+        "sha256 of NIST two-block message");
+  }
+}
+
+void TestSha256StreamingMatchesOneShot() {
+  // One million 'a' (NIST long vector), fed in deliberately awkward chunk
+  // sizes to cross every buffer boundary case in Update.
+  const std::string chunk(4096 + 37, 'a');
+  size_t remaining = 1000000;
+  pushy::digest::Sha256 hasher;
+  while (remaining > 0) {
+    const size_t take = remaining < chunk.size() ? remaining : chunk.size();
+    hasher.Update(reinterpret_cast<const uint8_t*>(chunk.data()), take);
+    remaining -= take;
+  }
+  ExpectEq(
+      hasher.HexDigest(),
+      "cdc76e5c9914fb9281a1c7e284d73e67f1809a48a497200e046d39ccc7112cd0",
+      "sha256 of one million 'a' fed in odd-sized chunks");
+}
+
+void TestSha256File() {
+  TempDir temp;
+  const std::string dir = temp.path;
+  const std::string path = dir + "/input.bin";
+  WriteFile(path, "abc");
+  ExpectEq(
+      pushy::digest::Sha256File(path),
+      "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad",
+      "Sha256File over a small file");
+  ExpectEq(
+      pushy::digest::Sha256File(dir + "/missing.bin"),
+      "",
+      "Sha256File over a missing file returns empty");
+}
+
 }  // namespace
 
 int main(int argc, char** argv) {
@@ -778,6 +845,9 @@ int main(int argc, char** argv) {
       {"StateCoreRollbackToEmptyVersion", TestStateCoreRollbackToEmptyVersion},
       {"StateCoreResolveLaunchNoCurrentVersion", TestStateCoreResolveLaunchNoCurrentVersion},
       {"StateCoreSwitchToSameVersion", TestStateCoreSwitchToSameVersion},
+      {"Sha256KnownVectors", TestSha256KnownVectors},
+      {"Sha256StreamingMatchesOneShot", TestSha256StreamingMatchesOneShot},
+      {"Sha256File", TestSha256File},
   };
 
   int failures = 0;

package/harmony/pushy/src/main/cpp/CMakeLists.txt

@@ -27,6 +27,7 @@ set(LZMA_DIR ${ANDROID_JNI_DIR}/lzma)
 set(HDP_SOURCES
      ${CMAKE_CURRENT_SOURCE_DIR}/pushy.cpp
      ${PATCH_CORE_DIR}/archive_patch_core.cpp
+     ${PATCH_CORE_DIR}/digest.cpp
      ${PATCH_CORE_DIR}/hbc_transform.cpp
      ${PATCH_CORE_DIR}/hbc_transform_wire.cpp
      ${PATCH_CORE_DIR}/patch_core.cpp