rn-update 1.0.0

package/cpp/patch_core/digest.cpp

@@ -0,0 +1,235 @@
+/**
+ * [INPUT]: 依赖 digest.h 的流式摘要接口与标准文件 IO
+ * [OUTPUT]: 实现 FIPS 180-4 SHA-256、IEEE CRC32 及有界内存文件摘要
+ * [POS]: digest 的跨平台实现，被包体身份、制品校验和 patch copy CRC 防线复用
+ */
+#include "digest.h"
+
+#include <cstdio>
+#include <cstring>
+
+namespace pakta {
+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 {
+
+struct Crc32TableHolder {
+  uint32_t table[256];
+
+  Crc32TableHolder() {
+    for (uint32_t i = 0; i < 256; i++) {
+      uint32_t value = i;
+      for (int bit = 0; bit < 8; bit++) {
+        value = (value & 1u) ? (value >> 1) ^ 0xEDB88320u : value >> 1;
+      }
+      table[i] = value;
+    }
+  }
+};
+
+const uint32_t* Crc32Table() {
+  // Function-local static: thread-safe one-time construction (C++11).
+  static const Crc32TableHolder holder;
+  return holder.table;
+}
+
+}  // namespace
+
+void Crc32::Update(const uint8_t* data, size_t length) {
+  const uint32_t* table = Crc32Table();
+  uint32_t state = state_;
+  for (size_t i = 0; i < length; i++) {
+    state = table[(state ^ data[i]) & 0xFFu] ^ (state >> 8);
+  }
+  state_ = state;
+}
+
+bool Crc32File(const std::string& path, uint32_t* out) {
+  std::FILE* file = std::fopen(path.c_str(), "rb");
+  if (file == nullptr) {
+    return false;
+  }
+  Crc32 crc;
+  uint8_t buffer[64 * 1024];
+  size_t read = 0;
+  while ((read = std::fread(buffer, 1, sizeof(buffer), file)) > 0) {
+    crc.Update(buffer, read);
+  }
+  const bool failed = std::ferror(file) != 0;
+  std::fclose(file);
+  if (failed) {
+    return false;
+  }
+  *out = crc.Value();
+  return true;
+}
+
+}  // namespace digest
+}  // namespace pakta

package/cpp/patch_core/digest.h

@@ -0,0 +1,66 @@
+/**
+ * [INPUT]: 依赖标准字节类型、文件路径与流式输入，不依赖平台加密库
+ * [OUTPUT]: 对外提供 Sha256、Sha256File、Crc32 与 Crc32File 摘要接口
+ * [POS]: patch_core 的内容身份与完整性原语，为 bundleHash 和 pdiff 源校验提供统一算法
+ */
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <string>
+
+namespace pakta {
+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);
+
+// Streaming CRC32 (IEEE 802.3, reflected polynomial 0xEDB88320 — the zip /
+// zlib checksum). Used to verify pdiff copy sources against the CRCs the CLI
+// records from the origin package's zip entries (copiesCrc in __diff.json):
+// the values must be byte-compatible with what any zip tool would report.
+class Crc32 {
+ public:
+  void Update(const uint8_t* data, size_t length);
+
+  uint32_t Value() const { return state_ ^ 0xFFFFFFFFu; }
+
+ private:
+  uint32_t state_ = 0xFFFFFFFFu;
+};
+
+// CRC32 of a file on disk (streaming, bounded memory). Returns false if the
+// file cannot be read.
+bool Crc32File(const std::string& path, uint32_t* out);
+
+}  // namespace digest
+}  // namespace pakta

package/cpp/patch_core/error_codes.h

@@ -0,0 +1,57 @@
+/**
+ * [INPUT]: 依赖 JS UpdateErrorCode 与 Android Java 常量共同遵守的跨平台错误语义
+ * [OUTPUT]: 对外提供稳定、机器可读的原生更新错误码常量
+ * [POS]: patch_core 的错误协议事实源，供 iOS 直接引用并约束无法包含本头的镜像实现
+ */
+#ifndef PAKTA_PATCH_CORE_ERROR_CODES_H_
+#define PAKTA_PATCH_CORE_ERROR_CODES_H_
+
+// Single source of truth for the stable, machine-readable error codes shared
+// by every platform. Native modules reject promises with one of these codes
+// so the JS layer (src/error.ts UpdateErrorCode) and user loggers can
+// aggregate errors across platforms and locales.
+//
+// Mirrors that cannot include this header MUST stay in sync by hand:
+//   - src/error.ts                      (UpdateErrorCode union, JS layer)
+//   - android/.../ErrorCodes.java      (Java constants)
+// iOS (RCTPakta.mm) includes this header directly.
+//
+// Human-readable messages are NOT part of this contract: they may differ per
+// platform and locale. Only the codes are stable.
+
+namespace pakta {
+namespace error_codes {
+
+// Method options missing or malformed (blank hash/url, wrong types).
+constexpr const char* kInvalidOptions = "INVALID_OPTIONS";
+// Native download failed (network error, bad HTTP status, truncated body).
+constexpr const char* kDownloadFailed = "DOWNLOAD_FAILED";
+// Unzip or hdiff patch application failed.
+constexpr const char* kPatchFailed = "PATCH_FAILED";
+// Local file or state persistence operation failed.
+constexpr const char* kFileOperationFailed = "FILE_OPERATION_FAILED";
+// switchVersion / setNeedUpdate state transition failed.
+constexpr const char* kSwitchVersionFailed = "SWITCH_VERSION_FAILED";
+// markSuccess state transition failed.
+constexpr const char* kMarkSuccessFailed = "MARK_SUCCESS_FAILED";
+// reloadUpdate / restartApp failed.
+constexpr const char* kRestartFailed = "RESTART_FAILED";
+// resetToPackagedBundle failed (state wipe or cleanup could not run), or the
+// installed native module predates the method (JS-layer detection).
+constexpr const char* kResetFailed = "RESET_FAILED";
+// Stored or provided hash info is not a valid JSON object.
+constexpr const char* kInvalidHashInfo = "INVALID_HASH_INFO";
+// The method is not supported on this platform (e.g. downloadAndInstallApk
+// outside Android).
+constexpr const char* kUnsupportedPlatform = "UNSUPPORTED_PLATFORM";
+// Android full-package installation requires the user to trust the app as an
+// install source before PackageInstaller can accept a session.
+constexpr const char* kApkInstallPermissionRequired =
+    "APK_INSTALL_PERMISSION_REQUIRED";
+// PackageInstaller could not create, write, commit, or continue an APK session.
+constexpr const char* kApkInstallFailed = "APK_INSTALL_FAILED";
+
+}  // namespace error_codes
+}  // namespace pakta
+
+#endif  // PAKTA_PATCH_CORE_ERROR_CODES_H_

package/cpp/patch_core/hbc_transform.cpp

@@ -0,0 +1,152 @@
+/**
+ * [INPUT]: 依赖 hbc_transform.h 的布局描述与 Hermes HBC 固定头部位置约定
+ * [OUTPUT]: 实现先全量校验、后原地执行的 delta-friendly 正向与逆向变换
+ * [POS]: hbc_transform 的字节执行核心，失败时保持输入不变以保障整包回退安全
+ */
+#include "hbc_transform.h"
+
+#include <cstring>
+
+namespace pakta {
+namespace hbc {
+
+namespace {
+
+constexpr uint8_t kHbcMagic[8] =
+    {0xc6, 0x1f, 0xbc, 0x03, 0xc1, 0x03, 0x19, 0x1f};
+constexpr size_t kHeaderSize = 128;
+constexpr size_t kCountsOffset = 32; // magic(8) + version(4) + sourceHash(20)
+constexpr uint32_t kMaxEntryCount = 0x0fffffff;
+constexpr uint32_t kMaxEntrySize = 4096;
+constexpr uint32_t kMaxSections = 64;
+constexpr uint32_t kMaxCountFields = (kHeaderSize - kCountsOffset) / 4; // 24
+
+inline uint32_t ReadU32(const uint8_t* p) {
+  return static_cast<uint32_t>(p[0]) | (static_cast<uint32_t>(p[1]) << 8) |
+      (static_cast<uint32_t>(p[2]) << 16) |
+      (static_cast<uint32_t>(p[3]) << 24);
+}
+
+inline void WriteU32(uint8_t* p, uint32_t v) {
+  p[0] = static_cast<uint8_t>(v);
+  p[1] = static_cast<uint8_t>(v >> 8);
+  p[2] = static_cast<uint8_t>(v >> 16);
+  p[3] = static_cast<uint8_t>(v >> 24);
+}
+
+inline uint64_t Align4(uint64_t x) {
+  return (x + 3) & ~static_cast<uint64_t>(3);
+}
+
+struct ResolvedSection {
+  uint64_t start;
+  uint64_t size;
+  const HbcSectionDesc* desc;
+};
+
+} // namespace
+
+bool TransformHbcInPlace(
+    uint8_t* data,
+    size_t size,
+    const HbcLayoutDesc& layout,
+    bool inverse) {
+  // ---- 校验阶段:改写任何字节之前完成全部检查 ----
+  if (data == nullptr || size < kHeaderSize) {
+    return false;
+  }
+  if (std::memcmp(data, kHbcMagic, sizeof(kHbcMagic)) != 0) {
+    return false;
+  }
+  if (layout.headerCountFields < 2 ||
+      layout.headerCountFields > kMaxCountFields) {
+    return false;
+  }
+  if (layout.sections == nullptr || layout.sectionCount == 0 ||
+      layout.sectionCount > kMaxSections) {
+    return false;
+  }
+
+  uint32_t counts[kMaxCountFields];
+  for (uint32_t i = 0; i < layout.headerCountFields; ++i) {
+    counts[i] = ReadU32(data + kCountsOffset + static_cast<size_t>(i) * 4);
+  }
+  // 位置约定:槽位 0 = fileLength,最后一个槽位 = debugInfoOffset
+  const uint64_t fileLength = counts[0];
+  const uint64_t debugInfoOffset = counts[layout.headerCountFields - 1];
+  if (fileLength != size) {
+    return false;
+  }
+  if (debugInfoOffset < kHeaderSize || debugInfoOffset > size) {
+    return false;
+  }
+
+  ResolvedSection resolved[kMaxSections];
+  uint64_t off = kHeaderSize;
+  for (uint32_t i = 0; i < layout.sectionCount; ++i) {
+    const HbcSectionDesc& s = layout.sections[i];
+    if (s.countIndex >= layout.headerCountFields) {
+      return false;
+    }
+    if (s.entrySize == 0 || s.entrySize > kMaxEntrySize) {
+      return false;
+    }
+    const uint64_t count = counts[s.countIndex];
+    if (count > kMaxEntryCount) {
+      return false;
+    }
+    if (s.deltaFieldCount > 0 && s.deltaFields == nullptr) {
+      return false;
+    }
+    for (uint32_t f = 0; f < s.deltaFieldCount; ++f) {
+      const HbcDeltaField& field = s.deltaFields[f];
+      // bit 必须单独设上界:bit=0xFFFFFFFF 时 bit+bits 的 uint32 求和会回绕
+      // 绕过 >32 检查,改写阶段的 << bit 就成了移位量 ≥32 的 UB。
+      // bits≥1 时合法 bit 必 ≤31。
+      if (field.bits < 1 || field.bits > 32 || field.bit > 31 ||
+          field.bit + field.bits > 32 ||
+          static_cast<uint64_t>(field.byte) + 4 > s.entrySize) {
+        return false;
+      }
+    }
+    const uint64_t sectionSize = count * s.entrySize; // ≤ 2^28 × 2^12 < 2^40
+    off = Align4(off);
+    if (off + sectionSize > debugInfoOffset) {
+      return false;
+    }
+    resolved[i] = {off, sectionSize, &s};
+    off += sectionSize;
+  }
+
+  // ---- 改写阶段:校验通过后不再有失败路径 ----
+  for (uint32_t i = 0; i < layout.sectionCount; ++i) {
+    const ResolvedSection& r = resolved[i];
+    const HbcSectionDesc& s = *r.desc;
+    for (uint32_t f = 0; f < s.deltaFieldCount; ++f) {
+      const HbcDeltaField& field = s.deltaFields[f];
+      const uint32_t fieldMask =
+          field.bits == 32 ? 0xffffffffu : ((1u << field.bits) - 1u);
+      const uint32_t mask = fieldMask << field.bit;
+      uint32_t prev = 0;
+      const uint64_t end = r.start + r.size;
+      for (uint64_t p = r.start + field.byte; p < end; p += s.entrySize) {
+        uint8_t* wordPtr = data + p;
+        const uint32_t word = ReadU32(wordPtr);
+        const uint32_t val = (word >> field.bit) & fieldMask;
+        uint32_t enc;
+        if (!inverse) {
+          enc = (val - prev) & fieldMask;
+          prev = val;
+        } else {
+          enc = (val + prev) & fieldMask;
+          prev = enc;
+        }
+        WriteU32(wordPtr, (word & ~mask) | (enc << field.bit));
+      }
+    }
+  }
+  return true;
+}
+
+} // namespace hbc
+} // namespace pakta

package/cpp/patch_core/hbc_transform.h

@@ -0,0 +1,58 @@
+/**
+ * [INPUT]: 依赖调用方提供的 HBC 原始字节与经校验的布局描述，不内置 Hermes 版本分支
+ * [OUTPUT]: 对外提供 HbcDeltaField、HbcSectionDesc、HbcLayoutDesc 与可逆原地变换函数
+ * [POS]: patch_core 的 Hermes 变换解释器，由 wire 元数据层驱动并为 hdiff 变换域服务
+ */
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+
+namespace pakta {
+namespace hbc {
+
+// Hermes 字节码(HBC)delta-friendly 可逆变换的通用解释器。
+//
+// 布局描述表来自 patch 的 __diff.json 元数据(生成端 CLI 写入),本解释器
+// 不含任何 HBC 版本分支——Hermes 版本演进只需要生成端更新描述表,客户端
+// 零跟进。描述表被视为不可信输入:所有段边界、条目大小、位域范围在改写
+// 任何字节之前完成全量校验;校验失败时 buffer 保持原样。
+//
+// 变换语义与生成端(rn-update-cli src/utils/hbcTransform.ts)
+// 严格一致:对描述的偏移位域做前项差分(wrapping,模字段位宽)。
+// wrapping 保证与数据单调性无关的严格可逆。
+
+struct HbcDeltaField {
+  // 条目内字节偏移处按小端读取 u32,取 [bit, bit+bits) 位做差分
+  uint32_t byte;
+  uint32_t bit;
+  uint32_t bits;
+};
+
+struct HbcSectionDesc {
+  // 段大小 = headerCounts[countIndex] × entrySize(字节段 entrySize 为 1)
+  uint32_t countIndex;
+  uint32_t entrySize;
+  const HbcDeltaField* deltaFields;
+  uint32_t deltaFieldCount;
+};
+
+// 与 wire 格式的位置约定一致:counts 槽位 0 = fileLength,
+// 最后一个槽位 = debugInfoOffset(结构校验依赖)。
+struct HbcLayoutDesc {
+  uint32_t headerCountFields;
+  const HbcSectionDesc* sections;
+  uint32_t sectionCount;
+};
+
+// 对 data 原地执行变换(inverse=false)或逆变换(inverse=true)。
+// 返回 false 表示 data 不是该描述表下结构合法的 HBC(或描述表本身非法),
+// 此时 data 未被修改。
+bool TransformHbcInPlace(
+    uint8_t* data,
+    size_t size,
+    const HbcLayoutDesc& layout,
+    bool inverse);
+
+} // namespace hbc
+} // namespace pakta