add bundlehash

Author: sunnylqm

android/jni/Android.mk

@@ -24,8 +24,10 @@ LOCAL_SRC_FILES := \
 	../../cpp/patch_core/archive_patch_core.cpp \
 	../../cpp/patch_core/patch_core.cpp \
 	../../cpp/patch_core/patch_core_android.cpp \
+	../../cpp/patch_core/sha256_util.cpp \
 	../../cpp/patch_core/state_core.cpp \
 	../../cpp/patch_core/update_core_android.cpp \
+	lzma/C/Sha256.c \
 	$(Hdp_Files)
 
 include $(BUILD_SHARED_LIBRARY)

android/jni/Application.mk

@@ -5,6 +5,7 @@ APP_CFLAGS += -ffunction-sections -fdata-sections
 APP_CFLAGS += -Oz -fno-unwind-tables -fno-asynchronous-unwind-tables
 APP_CPPFLAGS += -std=c++17 -Oz -fno-exceptions -fno-rtti -fno-unwind-tables -fno-asynchronous-unwind-tables
 APP_LDFLAGS += -Wl,--gc-sections -Wl,--exclude-libs,ALL
+APP_LDFLAGS += -Wl,--icf=all
 APP_BUILD_SCRIPT := Android.mk
 APP_ABI := armeabi-v7a arm64-v8a x86 x86_64
 APP_STL := c++_static

android/lib/arm64-v8a/librnupdate.so

@@ -4,11 +4,15 @@
 import android.content.SharedPreferences;
 import android.content.pm.PackageInfo;
 import android.content.pm.PackageManager;
+import android.content.res.AssetManager;
 import android.os.Build;
 import android.os.Environment;
 import android.util.Log;
 import com.facebook.react.ReactInstanceManager;
+import java.io.ByteArrayOutputStream;
 import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
 import java.util.concurrent.Executor;
 import java.util.concurrent.Executors;
 
@@ -35,6 +39,9 @@ public class UpdateContext {
     private static final int STATE_OP_CLEAR_ROLLBACK_MARK = 5;
     private static final int STATE_OP_RESOLVE_LAUNCH = 6;
     private static final String KEY_FIRST_LOAD_MARKED = "firstLoadMarked";
+    private static final String KEY_BUNDLE_HASH_CACHE_IDENTITY = "bundleHashCacheIdentity";
+    private static final String KEY_BUNDLE_HASH_CACHE_VALUE = "bundleHashCacheValue";
+    private static final String EMBEDDED_BUNDLE_ASSET_NAME = "index.android.bundle";
 
     // Singleton instance
     private static UpdateContext sInstance;
@@ -55,6 +62,8 @@ private static native StateCoreResult runStateCore(
         boolean flagB
     );
 
+    private static native String hashBytes(byte[] data);
+
     public UpdateContext(Context context) {
         this.context = context.getApplicationContext();
         this.executor = Executors.newSingleThreadExecutor();
@@ -110,6 +119,47 @@ public boolean getIsUsingBundleUrl() {
         return isUsingBundleUrl;
     }
 
+    public String getBundleHash() {
+        String identity = "embedded:" + getPackageVersion() + ":" + getBuildTime();
+        String cachedIdentity = sp.getString(KEY_BUNDLE_HASH_CACHE_IDENTITY, null);
+        String cachedValue = sp.getString(KEY_BUNDLE_HASH_CACHE_VALUE, null);
+        if (identity.equals(cachedIdentity) && cachedValue != null && !cachedValue.isEmpty()) {
+            return cachedValue;
+        }
+
+        String bundleHash = hashAsset(EMBEDDED_BUNDLE_ASSET_NAME);
+        if (bundleHash == null) {
+            return "";
+        }
+
+        SharedPreferences.Editor editor = sp.edit();
+        editor.putString(KEY_BUNDLE_HASH_CACHE_IDENTITY, identity);
+        editor.putString(KEY_BUNDLE_HASH_CACHE_VALUE, bundleHash);
+        persistEditor(editor, "cache bundle hash");
+        return bundleHash;
+    }
+
+    private String hashAsset(String assetName) {
+        try (InputStream stream = context.getAssets().open(assetName, AssetManager.ACCESS_STREAMING)) {
+            return hashInputStream(stream);
+        } catch (IOException e) {
+            if (DEBUG) {
+                Log.w(TAG, "Failed to hash asset bundle " + assetName, e);
+            }
+            return null;
+        }
+    }
+
+    private String hashInputStream(InputStream stream) throws IOException {
+        ByteArrayOutputStream output = new ByteArrayOutputStream();
+        byte[] buffer = new byte[8192];
+        int read;
+        while ((read = stream.read(buffer)) != -1) {
+            output.write(buffer, 0, read);
+        }
+        return hashBytes(output.toByteArray());
+    }
+
     private void enqueue(DownloadTaskParams params) {
         executor.execute(new DownloadTask(context, params));
     }

android/lib/armeabi-v7a/librnupdate.so

@@ -23,6 +23,7 @@ static Map<String, Object> getConstants(UpdateContext updateContext) {
         constants.put("currentVersion", currentVersion);
         constants.put("currentVersionInfo", updateContext.getKv("hash_" + currentVersion));
         constants.put("buildTime", updateContext.getBuildTime());
+        constants.put("bundleHash", updateContext.getBundleHash());
         constants.put("isUsingBundleUrl", updateContext.getIsUsingBundleUrl());
 
         boolean isFirstTime = updateContext.consumeFirstLoadMarker();

android/lib/x86/librnupdate.so

@@ -9,7 +9,6 @@
 #include <unistd.h>
 
 #include <set>
-#include <sstream>
 #include <vector>
 
 extern "C" {
@@ -31,12 +30,19 @@ class HdiffBundlePatcher final : public BundlePatcher {
 };
 
 Status MakeErrnoStatus(const std::string& message, int err = errno) {
-  std::ostringstream stream;
-  stream << message;
-  if (err != 0) {
-    stream << ": " << std::strerror(err);
+  if (err == 0) {
+    return Status::Error(message);
   }
-  return Status::Error(stream.str());
+  return Status::Error(message + ": " + std::strerror(err));
+}
+
+std::string IntToString(int value) {
+  char buffer[32] = {0};
+  const int written = std::snprintf(buffer, sizeof(buffer), "%d", value);
+  if (written <= 0) {
+    return "0";
+  }
+  return std::string(buffer, static_cast<size_t>(written));
 }
 
 bool EndsWithSlash(const std::string& path) {
@@ -522,9 +528,8 @@ Status HdiffBundlePatcher::Apply(
       destination_bundle_path.c_str(),
       bundle_patch_path.c_str());
   if (result != 0) {
-    std::ostringstream stream;
-    stream << "Failed to apply bundle patch, hpatch error " << result;
-    return Status::Error(stream.str());
+    return Status::Error(
+        "Failed to apply bundle patch, hpatch error " + IntToString(result));
   }
   return Status::Ok();
 }

android/lib/x86_64/librnupdate.so

@@ -0,0 +1,49 @@
+#include "sha256_util.h"
+
+namespace pushy {
+namespace crypto {
+
+namespace {
+
+std::string ToHexString(const Byte* digest, size_t size) {
+  static constexpr char kHexDigits[] = "0123456789abcdef";
+  std::string hex(size * 2, '\0');
+  for (size_t index = 0; index < size; ++index) {
+    const unsigned char byte = digest[index];
+    hex[index * 2] = kHexDigits[byte >> 4];
+    hex[index * 2 + 1] = kHexDigits[byte & 0x0f];
+  }
+  return hex;
+}
+
+}  // namespace
+
+Sha256Hasher::Sha256Hasher() {
+  Sha256_Init(&context_);
+}
+
+void Sha256Hasher::Update(const void* data, size_t size) {
+  if (finalized_ || data == nullptr || size == 0) {
+    return;
+  }
+  Sha256_Update(
+      &context_,
+      static_cast<const Byte*>(data),
+      size);
+}
+
+std::string Sha256Hasher::FinalHex() {
+  Byte digest[SHA256_DIGEST_SIZE] = {0};
+  Sha256_Final(&context_, digest);
+  finalized_ = true;
+  return ToHexString(digest, SHA256_DIGEST_SIZE);
+}
+
+std::string Sha256Hex(const void* data, size_t size) {
+  Sha256Hasher hasher;
+  hasher.Update(data, size);
+  return hasher.FinalHex();
+}
+
+}  // namespace crypto
+}  // namespace pushy