rn-update 1.0.0

package/cpp/patch_core/hbc_transform_wire.cpp

@@ -0,0 +1,332 @@
+/**
+ * [INPUT]: 依赖 hbc_transform_wire.h 的元数据模型与受限 JSON 字段约定
+ * [OUTPUT]: 实现带输入大小、递归深度和字段数量上限的解析及布局装配
+ * [POS]: hbc_transform_wire 的安全解析实现，拒绝异常 patch 元数据而不引入通用 JSON 依赖
+ */
+#include "hbc_transform_wire.h"
+
+namespace pakta {
+namespace hbc {
+
+namespace {
+
+// 面向单一受限格式的手写递归下降解析器。不追求通用 JSON 兼容,
+// 追求:无第三方依赖、输入不可信下的确定性行为、显式上限。
+constexpr size_t kMaxInputBytes = 64 * 1024;
+constexpr int kMaxDepth = 8;
+constexpr uint32_t kMaxSections = 64;
+constexpr uint32_t kMaxDeltaFields = 8;
+
+struct Cursor {
+  const char* p;
+  const char* end;
+};
+
+void SkipWs(Cursor* c) {
+  while (c->p < c->end &&
+         (*c->p == ' ' || *c->p == '\t' || *c->p == '\n' || *c->p == '\r')) {
+    ++c->p;
+  }
+}
+
+bool Consume(Cursor* c, char ch) {
+  SkipWs(c);
+  if (c->p < c->end && *c->p == ch) {
+    ++c->p;
+    return true;
+  }
+  return false;
+}
+
+bool Peek(Cursor* c, char ch) {
+  SkipWs(c);
+  return c->p < c->end && *c->p == ch;
+}
+
+// 仅接受非负整数(本格式中所有数值都是非负整数)
+bool ParseUInt(Cursor* c, uint32_t* out) {
+  SkipWs(c);
+  if (c->p >= c->end || *c->p < '0' || *c->p > '9') {
+    return false;
+  }
+  uint64_t value = 0;
+  while (c->p < c->end && *c->p >= '0' && *c->p <= '9') {
+    value = value * 10 + static_cast<uint64_t>(*c->p - '0');
+    if (value > 0xffffffffull) {
+      return false;
+    }
+    ++c->p;
+  }
+  *out = static_cast<uint32_t>(value);
+  return true;
+}
+
+bool ParseKey(Cursor* c, std::string* out) {
+  SkipWs(c);
+  if (!Consume(c, '"')) {
+    return false;
+  }
+  out->clear();
+  while (c->p < c->end && *c->p != '"') {
+    if (*c->p == '\\') {
+      return false; // 本格式的键不含转义
+    }
+    out->push_back(*c->p);
+    ++c->p;
+    if (out->size() > 64) {
+      return false;
+    }
+  }
+  return Consume(c, '"');
+}
+
+// 跳过未知键的值(数字/字符串/数组/对象),深度受限
+bool SkipValue(Cursor* c, int depth) {
+  if (depth > kMaxDepth) {
+    return false;
+  }
+  SkipWs(c);
+  if (c->p >= c->end) {
+    return false;
+  }
+  const char ch = *c->p;
+  if (ch == '"') {
+    ++c->p;
+    while (c->p < c->end && *c->p != '"') {
+      if (*c->p == '\\') {
+        ++c->p;
+      }
+      ++c->p;
+    }
+    return Consume(c, '"');
+  }
+  if (ch == '[' || ch == '{') {
+    const char close = ch == '[' ? ']' : '}';
+    ++c->p;
+    SkipWs(c);
+    if (Consume(c, close)) {
+      return true;
+    }
+    while (true) {
+      if (close == '}') {
+        std::string key;
+        if (!ParseKey(c, &key) || !Consume(c, ':')) {
+          return false;
+        }
+      }
+      if (!SkipValue(c, depth + 1)) {
+        return false;
+      }
+      if (Consume(c, close)) {
+        return true;
+      }
+      if (!Consume(c, ',')) {
+        return false;
+      }
+    }
+  }
+  if ((ch >= '0' && ch <= '9') || ch == '-') {
+    ++c->p;
+    while (c->p < c->end &&
+           ((*c->p >= '0' && *c->p <= '9') || *c->p == '.' || *c->p == 'e' ||
+            *c->p == 'E' || *c->p == '+' || *c->p == '-')) {
+      ++c->p;
+    }
+    return true;
+  }
+  // true/false/null
+  for (const char* lit : {"true", "false", "null"}) {
+    const size_t n = std::char_traits<char>::length(lit);
+    if (static_cast<size_t>(c->end - c->p) >= n &&
+        std::char_traits<char>::compare(c->p, lit, n) == 0) {
+      c->p += n;
+      return true;
+    }
+  }
+  return false;
+}
+
+// [byte, bit, bits]
+bool ParseDeltaField(Cursor* c, HbcDeltaField* out) {
+  if (!Consume(c, '[')) {
+    return false;
+  }
+  if (!ParseUInt(c, &out->byte) || !Consume(c, ',') ||
+      !ParseUInt(c, &out->bit) || !Consume(c, ',') ||
+      !ParseUInt(c, &out->bits)) {
+    return false;
+  }
+  // 语义范围在解析层就拒绝(与 TransformHbcInPlace 的校验双保险):
+  // 位域必须落在一个 32 位字内,bit>31 的值没有任何合法用途。
+  if (out->bits < 1 || out->bits > 32 || out->bit > 31 ||
+      out->bit + out->bits > 32) {
+    return false;
+  }
+  return Consume(c, ']');
+}
+
+// [countIndex, entrySize, [field, ...]]
+bool ParseSection(Cursor* c, HbcTransformMeta::Section* out) {
+  if (!Consume(c, '[')) {
+    return false;
+  }
+  if (!ParseUInt(c, &out->countIndex) || !Consume(c, ',') ||
+      !ParseUInt(c, &out->entrySize) || !Consume(c, ',')) {
+    return false;
+  }
+  if (!Consume(c, '[')) {
+    return false;
+  }
+  if (!Consume(c, ']')) {
+    while (true) {
+      HbcDeltaField field{};
+      if (out->deltaFields.size() >= kMaxDeltaFields ||
+          !ParseDeltaField(c, &field)) {
+        return false;
+      }
+      out->deltaFields.push_back(field);
+      if (Consume(c, ']')) {
+        break;
+      }
+      if (!Consume(c, ',')) {
+        return false;
+      }
+    }
+  }
+  return Consume(c, ']');
+}
+
+bool ParseLayout(Cursor* c, HbcTransformMeta* out) {
+  if (!Consume(c, '{')) {
+    return false;
+  }
+  bool sawCounts = false;
+  bool sawSections = false;
+  if (!Consume(c, '}')) {
+    while (true) {
+      std::string key;
+      if (!ParseKey(c, &key) || !Consume(c, ':')) {
+        return false;
+      }
+      if (key == "counts") {
+        if (!ParseUInt(c, &out->headerCountFields)) {
+          return false;
+        }
+        sawCounts = true;
+      } else if (key == "sections") {
+        if (!Consume(c, '[')) {
+          return false;
+        }
+        if (!Consume(c, ']')) {
+          while (true) {
+            HbcTransformMeta::Section section;
+            if (out->sections.size() >= kMaxSections ||
+                !ParseSection(c, &section)) {
+              return false;
+            }
+            out->sections.push_back(std::move(section));
+            if (Consume(c, ']')) {
+              break;
+            }
+            if (!Consume(c, ',')) {
+              return false;
+            }
+          }
+        }
+        sawSections = true;
+      } else if (!SkipValue(c, 0)) {
+        return false;
+      }
+      if (Consume(c, '}')) {
+        break;
+      }
+      if (!Consume(c, ',')) {
+        return false;
+      }
+    }
+  }
+  return sawCounts && sawSections;
+}
+
+} // namespace
+
+bool ParseHbcTransformMeta(const std::string& json, HbcTransformMeta* out) {
+  if (out == nullptr || json.empty() || json.size() > kMaxInputBytes) {
+    return false;
+  }
+  *out = HbcTransformMeta{};
+  Cursor c{json.data(), json.data() + json.size()};
+
+  if (!Consume(&c, '{')) {
+    return false;
+  }
+  bool sawV = false;
+  bool sawHbcVersion = false;
+  bool sawLayout = false;
+  if (!Consume(&c, '}')) {
+    while (true) {
+      std::string key;
+      if (!ParseKey(&c, &key) || !Consume(&c, ':')) {
+        return false;
+      }
+      if (key == "v") {
+        if (!ParseUInt(&c, &out->v)) {
+          return false;
+        }
+        sawV = true;
+      } else if (key == "hbcVersion") {
+        if (!ParseUInt(&c, &out->hbcVersion)) {
+          return false;
+        }
+        sawHbcVersion = true;
+      } else if (key == "layout") {
+        if (!Peek(&c, '{') || !ParseLayout(&c, out)) {
+          return false;
+        }
+        sawLayout = true;
+      } else if (!SkipValue(&c, 0)) {
+        return false;
+      }
+      if (Consume(&c, '}')) {
+        break;
+      }
+      if (!Consume(&c, ',')) {
+        return false;
+      }
+    }
+  }
+  SkipWs(&c);
+  if (c.p != c.end) {
+    return false; // 尾部不允许有多余内容
+  }
+  if (!sawV || !sawHbcVersion || !sawLayout) {
+    return false;
+  }
+  if (out->sections.empty() || out->headerCountFields == 0) {
+    return false;
+  }
+  return true;
+}
+
+HbcLayoutDesc BuildLayout(
+    const HbcTransformMeta& meta,
+    std::vector<HbcSectionDesc>* sections_scratch) {
+  sections_scratch->clear();
+  sections_scratch->reserve(meta.sections.size());
+  for (const HbcTransformMeta::Section& s : meta.sections) {
+    HbcSectionDesc desc;
+    desc.countIndex = s.countIndex;
+    desc.entrySize = s.entrySize;
+    desc.deltaFields = s.deltaFields.empty() ? nullptr : s.deltaFields.data();
+    desc.deltaFieldCount = static_cast<uint32_t>(s.deltaFields.size());
+    sections_scratch->push_back(desc);
+  }
+  HbcLayoutDesc layout;
+  layout.headerCountFields = meta.headerCountFields;
+  layout.sections = sections_scratch->data();
+  layout.sectionCount = static_cast<uint32_t>(sections_scratch->size());
+  return layout;
+}
+
+} // namespace hbc
+} // namespace pakta

package/cpp/patch_core/hbc_transform_wire.h

@@ -0,0 +1,57 @@
+/**
+ * [INPUT]: 依赖 hbc_transform.h 的布局类型与随补丁下发的受限 hbcTransform JSON 协议
+ * [OUTPUT]: 对外提供 diffV 常量、HbcTransformMeta、严格解析器与布局构建函数
+ * [POS]: patch_core 的不可信元数据防腐层，把 wire JSON 收敛为变换解释器可消费的描述
+ */
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+#include "hbc_transform.h"
+
+namespace pakta {
+namespace hbc {
+
+// 客户端当前支持的变换规范版本(内部 wire 版本,仅用于校验 __diff.json
+// 中 hbcTransform.v)。v 不在支持范围时调用方必须放弃 diff 应用(回退
+// 整包),不能忽略元数据。
+constexpr uint32_t kHbcTransformSupportedVersion = 1;
+
+// 客户端可消费的 diff 轨道版本(客户端↔服务端接口用这个数字):
+//   1 = baseline(普通 hdiff single 格式)
+//   2 = v2 轨道(HBC 变换元数据 spec v1 + HDIFF13 流式容器)
+// 经 getConstants 暴露给 JS,随 checkUpdate 以 diffV 上报,服务端据此
+// 决定下发 v2/ 前缀产物。轨道号与 OSS 前缀/文档中的 "v2" 语义对齐;
+// 变换 spec 版本是其内部实现细节(轨道 v2 ⇒ spec ≤ 1)。
+constexpr uint32_t kSupportedDiffVersion = 2;
+
+// __diff.json 中单个 bundle patch 条目的 hbcTransform 元数据:
+// {"v":1,"hbcVersion":96,"layout":{"counts":19,"sections":[[ci,es,[[b,bi,bits],...]],...]}}
+// 解析结果自持有存储;BuildLayout 产出的描述指向本结构,生存期须不短于使用期。
+struct HbcTransformMeta {
+  uint32_t v = 0;
+  uint32_t hbcVersion = 0;
+  uint32_t headerCountFields = 0;
+  struct Section {
+    uint32_t countIndex = 0;
+    uint32_t entrySize = 0;
+    std::vector<HbcDeltaField> deltaFields;
+  };
+  std::vector<Section> sections;
+};
+
+// 严格解析(元数据视为不可信输入):结构、类型、数量全部受限,
+// 任何偏离返回 false。允许对象中出现未知键(数字/字符串/嵌套值会被跳过),
+// 为未来元数据扩展留余地。
+bool ParseHbcTransformMeta(const std::string& json, HbcTransformMeta* out);
+
+// 由 meta 构建解释器输入。sections_scratch 由调用方持有,生存期须覆盖
+// layout 的使用期(layout 内部指针指向 meta 与 scratch)。
+HbcLayoutDesc BuildLayout(
+    const HbcTransformMeta& meta,
+    std::vector<HbcSectionDesc>* sections_scratch);
+
+} // namespace hbc
+} // namespace pakta

package/cpp/patch_core/install_record.h

@@ -0,0 +1,41 @@
+/**
+ * [INPUT]: 无依赖（自包含 constexpr 常量），定义两阶段安装完成记录的 schema 与命名
+ * [OUTPUT]: 提供 .pakta-complete 记录名、schema 版本与 staging 后缀常量
+ * [POS]: patch_core 的安装完整性头，Java/ArkTS 镜像必须手动保持同步，iOS 直接包含
+ */
+#ifndef PAKTA_PATCH_CORE_INSTALL_RECORD_H_
+#define PAKTA_PATCH_CORE_INSTALL_RECORD_H_
+
+// The completion record every platform writes into a version directory once
+// an install fully succeeded, and reads back before trusting that directory.
+//
+//   <root>/<hash>/.pakta-complete
+//   {"schema":1,"versionHash":"<hash>","bundleSha256":"<hex>","artifactSha256":"<hex>"}
+//
+// - Written by the SDK only (archives may not ship a `.pakta-*` entry), as
+//   the LAST step of a two-phase install: unpack/patch into
+//   <root>/<hash>.staging, write the record there, then atomically rename
+//   the staging directory to <root>/<hash>.
+// - versionHash must equal the directory name; bundleSha256 is the digest of
+//   the final index.bundlejs (bundle.harmony.js on Harmony) and is
+//   re-verified at switchVersion time; artifactSha256 is the digest of the
+//   downloaded archive (diagnostics / CDN corruption attribution).
+// - Legacy: an EMPTY file is a completed install written by SDK < 10.53
+//   (no digests); it stays trusted for presence, nothing to verify.
+//
+// Mirrors that cannot include this header MUST stay in sync by hand:
+//   - android/.../InstallRecord.java
+//   - harmony/pakta/src/main/ets/InstallRecord.ts
+// iOS (RCTPakta.mm) includes this header directly.
+
+namespace pakta {
+namespace install_record {
+
+constexpr int kSchema = 1;
+constexpr const char* kFileName = ".pakta-complete";
+constexpr const char* kStagingSuffix = ".staging";
+
+}  // namespace install_record
+}  // namespace pakta
+
+#endif  // PAKTA_PATCH_CORE_INSTALL_RECORD_H_

package/cpp/patch_core/jni_util.h

@@ -0,0 +1,65 @@
+/**
+ * [INPUT]: 依赖 JNI 环境、Java 字符串/数组对象与标准字符串容器
+ * [OUTPUT]: 对外提供 header-only 的 JStringToString、JArrayToVector 与 ThrowRuntimeException
+ * [POS]: patch_core 的 Android JNI 公共适配层，被补丁执行和状态/归档桥接单元共同复用
+ */
+#pragma once
+
+#include <jni.h>
+
+#include <string>
+#include <vector>
+
+// Small JNI helpers shared by the Android glue translation units
+// (patch_core_android.cpp and update_core_android.cpp). Header-only with inline
+// linkage so both can include it without a separate compilation unit.
+
+namespace pakta {
+namespace jni_util {
+
+inline std::string JStringToString(JNIEnv* env, jstring value) {
+  if (value == nullptr) {
+    return std::string();
+  }
+
+  const char* chars = env->GetStringUTFChars(value, nullptr);
+  if (chars == nullptr) {
+    return std::string();
+  }
+
+  std::string result(chars);
+  env->ReleaseStringUTFChars(value, chars);
+  return result;
+}
+
+inline std::vector<std::string> JArrayToVector(
+    JNIEnv* env,
+    jobjectArray values) {
+  std::vector<std::string> result;
+  if (values == nullptr) {
+    return result;
+  }
+
+  const jsize size = env->GetArrayLength(values);
+  result.reserve(static_cast<size_t>(size));
+  for (jsize index = 0; index < size; ++index) {
+    auto* item = static_cast<jstring>(env->GetObjectArrayElement(values, index));
+    result.push_back(JStringToString(env, item));
+    env->DeleteLocalRef(item);
+  }
+  return result;
+}
+
+inline void ThrowRuntimeException(JNIEnv* env, const char* message) {
+  jclass exception = env->FindClass("java/lang/RuntimeException");
+  if (exception != nullptr) {
+    env->ThrowNew(exception, message);
+  }
+}
+
+inline void ThrowRuntimeException(JNIEnv* env, const std::string& message) {
+  ThrowRuntimeException(env, message.c_str());
+}
+
+}  // namespace jni_util
+}  // namespace pakta