cyymall-cli 0.1.0 → 0.1.2

package/src/config.js

@@ -1,82 +1,82 @@
-"use strict";
-
-const fs = require("fs");
-const path = require("path");
-const os = require("os");
-
-const DEFAULT_BASE_URL = "https://dhcmall.ifoodbuy.com";
-
-/** BuildConfig-style module prefixes (app-api-cli-spec §1.2) */
-const MODULE_MAP = {
-  DEFAULT: "/mall-multishop",
-  BIZ: "/mall-biz",
-  OSS: "/mall-oss",
-  ORDER: "/mall-order",
-  PLATFORM: "/mall-platform",
-  PRODUCT: "/mall-product",
-  PAYMENT: "/mall-payment",
-};
-
-function getBaseUrl() {
-  const u = process.env.CYY_BASE_URL || DEFAULT_BASE_URL;
-  return u.endsWith("/") ? u.slice(0, -1) : u;
-}
-
-function getConfigDir() {
-  return path.join(os.homedir(), ".cyymall");
-}
-
-function getConfigPath() {
-  return path.join(getConfigDir(), "config.json");
-}
-
-function ensureConfigDir() {
-  const dir = getConfigDir();
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-}
-
-/**
- * @returns {Record<string, unknown>|null}
- */
-function loadConfig() {
-  const p = getConfigPath();
-  if (!fs.existsSync(p)) return null;
-  try {
-    const raw = fs.readFileSync(p, "utf8");
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
-
-/**
- * @param {Record<string, unknown>} data
- */
-function saveConfig(data) {
-  ensureConfigDir();
-  fs.writeFileSync(getConfigPath(), JSON.stringify(data, null, 2), "utf8");
-}
-
-/**
- * Mask token for display
- * @param {string} t
- */
-function maskToken(t) {
-  if (!t || typeof t !== "string") return "";
-  if (t.length <= 12) return "***";
-  return `${t.slice(0, 8)}...${t.slice(-4)}`;
-}
-
-module.exports = {
-  DEFAULT_BASE_URL,
-  MODULE_MAP,
-  getBaseUrl,
-  getConfigDir,
-  getConfigPath,
-  ensureConfigDir,
-  loadConfig,
-  saveConfig,
-  maskToken,
-};
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+const DEFAULT_BASE_URL = "https://dhcmall.ifoodbuy.com";
+
+/** BuildConfig-style module prefixes (app-api-cli-spec §1.2) */
+const MODULE_MAP = {
+  DEFAULT: "/mall-multishop",
+  BIZ: "/mall-biz",
+  OSS: "/mall-oss",
+  ORDER: "/mall-order",
+  PLATFORM: "/mall-platform",
+  PRODUCT: "/mall-product",
+  PAYMENT: "/mall-payment",
+};
+
+function getBaseUrl() {
+  const u = process.env.CYY_BASE_URL || DEFAULT_BASE_URL;
+  return u.endsWith("/") ? u.slice(0, -1) : u;
+}
+
+function getConfigDir() {
+  return path.join(os.homedir(), ".cyymall");
+}
+
+function getConfigPath() {
+  return path.join(getConfigDir(), "config.json");
+}
+
+function ensureConfigDir() {
+  const dir = getConfigDir();
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+/**
+ * @returns {Record<string, unknown>|null}
+ */
+function loadConfig() {
+  const p = getConfigPath();
+  if (!fs.existsSync(p)) return null;
+  try {
+    const raw = fs.readFileSync(p, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * @param {Record<string, unknown>} data
+ */
+function saveConfig(data) {
+  ensureConfigDir();
+  fs.writeFileSync(getConfigPath(), JSON.stringify(data, null, 2), "utf8");
+}
+
+/**
+ * Mask token for display
+ * @param {string} t
+ */
+function maskToken(t) {
+  if (!t || typeof t !== "string") return "";
+  if (t.length <= 12) return "***";
+  return `${t.slice(0, 8)}...${t.slice(-4)}`;
+}
+
+module.exports = {
+  DEFAULT_BASE_URL,
+  MODULE_MAP,
+  getBaseUrl,
+  getConfigDir,
+  getConfigPath,
+  ensureConfigDir,
+  loadConfig,
+  saveConfig,
+  maskToken,
+};

package/src/embeddedCyyKeys.js

@@ -0,0 +1,16 @@
+"use strict";
+
+/**
+ * RSA key material bundled for `sendCodeV2` hybrid crypto — same strings as Android
+ * `app/src/main/cpp/cyy_native_key.cpp` (`SERVER_PUBLIC_KEY` / `CLIENT_PRIVATE_KEY`).
+ *
+ * The CLI now always uses these bundled keys for验证码登录链路；不再从环境变量或文件覆盖。
+ */
+
+const SERVER_PUBLIC_KEY =
+  "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAmdMRwn1tKAotKpG5olkgvxBzty1Vd2Ms/Gi+GEBHNyy6jrAbLCyrZuDfQO1EXuZzSNJCdA+eDzPFOyaCIL6qSQKNlp65hSpDaLWVEmbkq64polgxCRextFXcjArVSGhNPLNNcPGkcP5c5pZsJWPo17X7UYqRV5gCHsG93PZtgErX7CMM3KytumTmfkAnXxGYhWHqZtNYcaz+NrTjPA829MhmYRG7GnVnbTU3szX8FFxnDEqbr8iNDg2Jj2vzQxLreAp+pG6cHH/hdCYm6PSgSgJoTEAg28iY/HXjPcnhcCK49wsp1buxKoAGevJSgEdwgFczkt6H1L7/9MYlGbydMQIDAQAB";
+
+const CLIENT_PRIVATE_KEY =
+  "MIIEvwIBADANBgkqhkiG9w0BAQEFAASCBKkwggSlAgEAAoIBAQCx+zfpGV9vgxNoLYOOT2vuWrAdbKE73TLFZWapFFAZ4Ehtmt8vzq2R2JCujTKuuRMUBMyeNbxxLuPkq202HdlIh6nh78tqlS7uO/sQXNP2ym4IdTN7/+4QKvgmnPuKsHsVyoUPRUM1/A6GoNRIPrvfh0+BPYAACOwjC/J9T/WpJWcE2MfXJT4e5IU9wOcawJzxP0me9+g2SfnoXwMybTkQtZtwDTsHX0cj0xy6GDKrHNNaYqpaFL/yefeuLXqHQazB1XrykjMwQWGFcXESYFgNxQ+Kqj0WN5z5mfbHoiqnpGEElUG7kWH4n3qJNfOjSBb2VD08634XeVS8PD2IR4KLAgMBAAECggEAY8rh3Hb3hcTOutjaLI7ni2uZ18Wy2af68acbWq4jA3833Qy7G0kdFOuCo/xTcJgg1FakjAjBMg0ChpJ/15oA3KQEYsRbH9WpzLYg3VnPF08FRwS/60TirHoLTUsz1t2BBgTZemhxePFtC5tdq2xRVtG9iE99V4epLzVhr1WH/mAk3khs6UqJzd8ka+Cnx9sYv8jqdXdKO+SNkIpDSR6VWVfai1lSEabpSypxYPlRBubI/4KFmMXgrEg3rD5ymPaD0aZvKK5dXcMGR6JPDqUtSsrVmYqCv4lJ/q5lDNJVXRmlEMu1MzfJh7yhRqwF4YlnQwOGZ4OloKEwh6XNDsapkQKBgQDbkZMZ4v5ihn+1+aku8II5qcE6Z70xW4Sc0rTPJS3DstVmcsJUplg1tJ92kAFId1ci1g5bNRqQFtRWH1oslmPP3YXUXMOufDhPy16gy/sND7zqMzfd/wXpscWF776ngU+xRvgVRJF+uGXB4wfyNZtcZx/099IJrGwYBPUbrrrSXQKBgQDPgyzbC2H74Fb4vSc60NcfXH4V6kMzrSzS1DTe4XEgynqeY0zzwyeDOoj1xT99OhXdD2qxS/6mRxFoLTTf9DsWHZN1megO4XvWz7xoPavzObjVbi95iTm+QqhmHreJc5zjgCJO5ugOZGxuoBh9CRR1QFXPcgVI+LxUzRTa88KqBwKBgQDJEXuC9jL8KKzlCTbcDFVE1uZjRMKlY2iCcBYxp5tMHgV8JtU8zYPz0m9BFMiIAvlhpmJJNc0YbD+Qim96a1IF9ZdrjHOJ4qlysQr79y/0mxfl5HdhrPtOMYRvjceq/yjqb9IZL8yJHfXZYr1RGbQnHyzNmO/X+fSW3ltTOWRN5QKBgQDA4KkptEvP5PaR3qb/CSxbDwp27jamarl2AR5fZ+ZR10HfxGa7UFKCrD6vSja3++xke7bssrkv7nCkhxhVbVoaNUVhkrtaUYVc5du2fFQ+EBHX98GS0tTkHmsN+FEaJmbWIrxA4GkjL36F2LLKTU1BqpnX5qA48lGC9NgEp3vxswKBgQCMiR+J+264aQy6UySSmLnjZR1zFAjd17gLa/5lgvtme++kSiEFjed014t7I9IxAdS4tGT+6BOUpCCJrrngmSW0rowdXdZa09odrPPv3Nz/5kyKo2vYBVknN3ConbRgUc3K4Nk4iGpWxJ6l620FoMWVCbTLuuBgr1oaQUM4ZoJiNw==";
+
+module.exports = { SERVER_PUBLIC_KEY, CLIENT_PRIVATE_KEY };

package/src/encrypt.js

@@ -0,0 +1,434 @@
+"use strict";
+
+/**
+ * Response decrypt pipeline (same order as App), when a caller opts in via
+ * {@code http.request(..., { decryptHybridResponse: true, decryptResponsePrivateKey })} (e.g. send-code only):
+ *
+ * 1. {@link com.example.cyymall.nets.Intercepor.CyyEncryptInterceptor#decryptResponse} — read body UTF-8 string
+ *    `encryptedJson`, then `decryptResponseDataFromJson(encryptedJson)`; if result empty, keep original body.
+ * 2. {@link com.example.cyymall.utils.CyyNetworkEncryptManager#decryptResponseDataFromJson} —
+ *    `hybridEncryptResultFromJson(encryptedJson)` → `HybridEncryptResult` (or null) → `decryptResponseData` →
+ *    {@code CyyEncryptUtil.hybridDecrypt}.
+ * 3. {@link com.example.cyymall.utils.CyyEncryptUtil#hybridEncryptResultFromJson} — Gson parses JSON, then
+ *    explicitly copies `encrypteData` / `encrypteParam` / `encrypteParamExt` into a new {@code HybridEncryptResult}.
+ * 4. {@link com.example.cyymall.utils.CyyEncryptUtil#hybridDecrypt} — RSA unwrap AES key+IV, AES-CBC decrypt payload → plain String.
+ *
+ * Request path unchanged: header {@code encrypte: true}, body via {@code hybridEncrypt} with server public key.
+ */
+
+const crypto = require("crypto");
+const embedded = require("./embeddedCyyKeys");
+
+/** Avoid duplicate RSA unwrap debug lines when hybridDecrypt runs twice on the same envelope (e.g. http + auth). */
+let lastHybridDebugRsaCiphertextTag = "";
+
+function encryptDisabledByEnv() {
+  const v = process.env.CYY_ENCRYPT_OFF;
+  return v === "1" || v === "true";
+}
+
+/**
+ * PEM keeps newlines; raw Base64 from cpp / one-line env strips all whitespace (fixes paste + soft line-wrap).
+ * @param {string} raw
+ */
+function normalizeStoredKeyMaterial(raw) {
+  let t = String(raw ?? "").replace(/^\uFEFF/, "").trim();
+  if (!t) return "";
+  if (t.includes("BEGIN")) return t;
+  return t.replace(/\s/g, "");
+}
+
+/**
+ * Always use the bundled RSA key material from `embeddedCyyKeys.js`.
+ * @returns {{ serverPublicKey: string, clientPrivateKey: string }}
+ */
+function resolveEncryptKeys() {
+  return {
+    serverPublicKey: normalizeStoredKeyMaterial(embedded.SERVER_PUBLIC_KEY),
+    clientPrivateKey: normalizeStoredKeyMaterial(embedded.CLIENT_PRIVATE_KEY),
+  };
+}
+
+/**
+ * @param {string} s
+ */
+function normalizeBase64(s) {
+  let t = String(s || "")
+    .trim()
+    .replace(/\s/g, "")
+    .replace(/-/g, "+")
+    .replace(/_/g, "/");
+  const pad = t.length % 4;
+  if (pad) t += "=".repeat(4 - pad);
+  return t;
+}
+
+/**
+ * @param {string} raw
+ */
+function loadPublicKey(raw) {
+  const s = String(raw || "").trim();
+  if (!s) throw new Error("empty RSA public key");
+  if (s.includes("BEGIN")) {
+    return crypto.createPublicKey(s);
+  }
+  return crypto.createPublicKey({
+    key: Buffer.from(normalizeBase64(s), "base64"),
+    format: "der",
+    type: "spki",
+  });
+}
+
+/**
+ * @param {string} raw
+ */
+function loadPrivateKey(raw) {
+  const s = String(raw || "").trim();
+  if (!s) throw new Error("empty RSA private key");
+  if (s.includes("BEGIN")) {
+    return crypto.createPrivateKey(s);
+  }
+  return crypto.createPrivateKey({
+    key: Buffer.from(normalizeBase64(s), "base64"),
+    format: "der",
+    type: "pkcs8",
+  });
+}
+
+function generateAesKey() {
+  return crypto.randomBytes(32).toString("base64");
+}
+
+function generateAesIv() {
+  return crypto.randomBytes(16).toString("base64");
+}
+
+/**
+ * Java/Android `Cipher.getInstance("AES/CBC/...")` infers AES-128/192/256 from key length; Node requires an explicit algorithm name.
+ * @param {number} keyByteLength
+ * @returns {"aes-128-cbc" | "aes-192-cbc" | "aes-256-cbc" | null}
+ */
+function aesCbcAlgorithmForKeyLength(keyByteLength) {
+  if (keyByteLength === 16) return "aes-128-cbc";
+  if (keyByteLength === 24) return "aes-192-cbc";
+  if (keyByteLength === 32) return "aes-256-cbc";
+  return null;
+}
+
+function aesEncryptWithBase64Key(data, keyBase64, ivBase64) {
+  const key = Buffer.from(normalizeBase64(keyBase64), "base64");
+  const iv = Buffer.from(normalizeBase64(ivBase64), "base64");
+  const algo = aesCbcAlgorithmForKeyLength(key.length);
+  if (!algo) {
+    throw new Error(`AES encrypt: unsupported key length ${key.length} (expected 16, 24, or 32 bytes)`);
+  }
+  const cipher = crypto.createCipheriv(algo, key, iv);
+  const enc = Buffer.concat([cipher.update(Buffer.from(data, "utf8")), cipher.final()]);
+  return enc.toString("base64");
+}
+
+/**
+ * @param {string} encryptedData
+ * @param {import('crypto').KeyObject} privateKey
+ * @param {string} [debugLabel] — only used when {@code CYY_ENCRYPT_DEBUG} is set
+ */
+function rsaDecryptToUtf8OrEmpty(encryptedData, privateKey, debugLabel) {
+  const dbg = process.env.CYY_ENCRYPT_DEBUG === "1" || process.env.CYY_ENCRYPT_DEBUG === "true";
+  let raw;
+  try {
+    raw = Buffer.from(normalizeBase64(encryptedData), "base64");
+  } catch {
+    if (dbg) {
+      console.error(
+        `[cyy encrypt debug] RSA base64 decode failed for ${debugLabel || "ciphertext"} (invalid Base64?)`,
+      );
+    }
+    return "";
+  }
+  const modulusBytes =
+    privateKey?.asymmetricKeyDetails?.modulusLength != null
+      ? privateKey.asymmetricKeyDetails.modulusLength / 8
+      : null;
+  if (modulusBytes != null && raw.length !== modulusBytes) {
+    if (dbg) {
+      console.error(
+        `[cyy encrypt debug] RSA ciphertext length mismatch for ${debugLabel || "field"}: got ${raw.length} bytes, private key expects ${modulusBytes} (2048-bit RSA -> 256). Often caused by truncated encrypteParam / encrypteParamExt (logs, terminal width).`,
+      );
+    }
+    return "";
+  }
+  try {
+    const buf = crypto.privateDecrypt(
+      { key: privateKey, padding: crypto.constants.RSA_PKCS1_PADDING },
+      raw,
+    );
+    return buf.toString("utf8");
+  } catch (e) {
+    if (dbg) {
+      const err = /** @type {Error} */ (e);
+      console.error(
+        `[cyy encrypt debug] RSA privateDecrypt failed for ${debugLabel || "field"}: ${err.message}`,
+      );
+    }
+    return "";
+  }
+}
+
+/**
+ * @param {string} encryptedData
+ * @param {string} keyBase64
+ * @param {string} ivBase64
+ */
+function aesDecryptWithBase64KeyOrEmpty(encryptedData, keyBase64, ivBase64) {
+  try {
+    const key = Buffer.from(normalizeBase64(keyBase64), "base64");
+    const iv = Buffer.from(normalizeBase64(ivBase64), "base64");
+    const algo = aesCbcAlgorithmForKeyLength(key.length);
+    if (!algo) return "";
+    const data = Buffer.from(normalizeBase64(encryptedData), "base64");
+    const decipher = crypto.createDecipheriv(algo, key, iv);
+    const dec = Buffer.concat([decipher.update(data), decipher.final()]);
+    return dec.toString("utf8");
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * @param {string} data
+ * @param {import('crypto').KeyObject} publicKey
+ */
+function rsaEncrypt(data, publicKey) {
+  const buf = crypto.publicEncrypt(
+    { key: publicKey, padding: crypto.constants.RSA_PKCS1_PADDING },
+    Buffer.from(data, "utf8"),
+  );
+  return buf.toString("base64");
+}
+
+/**
+ * @typedef {{ encrypteData: string, encrypteParam: string, encrypteParamExt: string }} HybridEncryptResult
+ * Mirrors {@code CyyEncryptUtil.Companion.HybridEncryptResult}.
+ */
+
+/**
+ * From a parsed JSON root object, build a {@code HybridEncryptResult} the same way as
+ * {@code CyyEncryptUtil.hybridEncryptResultFromJson}: read Gson-mapped fields then recombine
+ * (Kotlin lines: `val encryptedData = fromJson.encrypteData`, …, `HybridEncryptResult(...)`).
+ * Extra keys (e.g. `traceId`) are ignored because we only read the three properties.
+ * @param {unknown} parsed — result of {@code JSON.parse} on the response body
+ * @returns {HybridEncryptResult | null}
+ */
+function hybridEncryptResultFromParsedObject(parsed) {
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+  const fromJson = /** @type {Record<string, unknown>} */ (parsed);
+  const encryptedData = fromJson.encrypteData;
+  const encryptedAesKey = fromJson.encrypteParam;
+  const encryptedIv = fromJson.encrypteParamExt;
+  if (
+    typeof encryptedData !== "string" ||
+    typeof encryptedAesKey !== "string" ||
+    typeof encryptedIv !== "string"
+  ) {
+    return null;
+  }
+  return {
+    encrypteData: encryptedData,
+    encrypteParam: encryptedAesKey,
+    encrypteParamExt: encryptedIv,
+  };
+}
+
+/**
+ * Same as {@code CyyEncryptUtil.hybridEncryptResultFromJson}: entire response body string → parse JSON →
+ * {@code HybridEncryptResult} or null.
+ * @param {string} json
+ * @returns {HybridEncryptResult | null}
+ */
+function hybridEncryptResultFromJson(json) {
+  try {
+    return hybridEncryptResultFromParsedObject(JSON.parse(json));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Same as {@code CyyNetworkEncryptManager.decryptResponseData}: {@code HybridEncryptResult} + client private → plain String.
+ * @param {HybridEncryptResult} encryptResult
+ * @param {string} clientPrivateKeyRaw
+ */
+function decryptResponseData(encryptResult, clientPrivateKeyRaw) {
+  return hybridDecrypt(encryptResult, clientPrivateKeyRaw);
+}
+
+/**
+ * Same as {@code CyyNetworkEncryptManager.decryptResponseDataFromJson}.
+ * @param {string} encryptedJson
+ * @param {string} clientPrivateKeyRaw
+ */
+function decryptResponseDataFromJson(encryptedJson, clientPrivateKeyRaw) {
+  const encryptResult = hybridEncryptResultFromJson(encryptedJson);
+  if (encryptResult == null) {
+    return "";
+  }
+  return decryptResponseData(encryptResult, clientPrivateKeyRaw);
+}
+
+/**
+ * Same as {@code CyyEncryptUtil.hybridDecrypt}: never throws; returns "" on failure.
+ * @param {HybridEncryptResult} result
+ * @param {string} clientPrivateKeyRaw
+ */
+function hybridDecrypt(result, clientPrivateKeyRaw) {
+  try {
+    let privateKey;
+    try {
+      privateKey = loadPrivateKey(clientPrivateKeyRaw);
+    } catch {
+      return "";
+    }
+    const aesKey = rsaDecryptToUtf8OrEmpty(result.encrypteParam, privateKey, "encrypteParam");
+    const aesIv = rsaDecryptToUtf8OrEmpty(result.encrypteParamExt, privateKey, "encrypteParamExt");
+
+    const debugEncrypt =
+      process.env.CYY_ENCRYPT_DEBUG === "1" || process.env.CYY_ENCRYPT_DEBUG === "true";
+    if (debugEncrypt) {
+      const tag = `${String(result.encrypteParam || "").slice(0, 48)}|${String(result.encrypteParamExt || "").slice(0, 48)}`;
+      if (tag !== lastHybridDebugRsaCiphertextTag) {
+        lastHybridDebugRsaCiphertextTag = tag;
+        if (!aesKey || !aesIv) {
+          console.error(
+            "[cyy encrypt debug] RSA PKCS#1 decrypt of encrypteParam / encrypteParamExt failed or yielded empty UTF-8 (wrong bundled client private key or ciphertext)",
+          );
+        } else {
+          console.error(
+            "[cyy encrypt debug] RSA decrypted encrypteParam (UTF-8, AES key material, same as App after rsaDecrypt): " +
+              JSON.stringify(aesKey),
+          );
+          console.error(
+            "[cyy encrypt debug] RSA decrypted encrypteParamExt (UTF-8, AES IV material, same as App after rsaDecrypt): " +
+              JSON.stringify(aesIv),
+          );
+        }
+      }
+    }
+    if (!aesKey || !aesIv) return "";
+    const decryptedData = aesDecryptWithBase64KeyOrEmpty(result.encrypteData, aesKey, aesIv);
+    return decryptedData || "";
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * Same as {@code CyyEncryptInterceptor.decryptResponse} for the body string:
+ * `val decryptedContent = encryptManager.decryptResponseDataFromJson(encryptedJson)`;
+ * `if (decryptedContent.isEmpty())` return original `encryptedJson`, else return decrypted UTF-8 string.
+ * @param {string} encryptedJson — {@code originalBody.string()} (UTF-8)
+ * @param {string} [clientPrivateKeyRaw]
+ */
+function decryptResponse(encryptedJson, clientPrivateKeyRaw) {
+  if (!clientPrivateKeyRaw || !encryptedJson) return encryptedJson;
+  const body = String(encryptedJson).replace(/^\uFEFF/, "").trim();
+  const decryptedContent = decryptResponseDataFromJson(body, clientPrivateKeyRaw);
+  if (decryptedContent.length > 0) return decryptedContent;
+  return body;
+}
+
+function tryDecryptResponseBody(text, clientPrivateKeyRaw) {
+  return decryptResponse(text, clientPrivateKeyRaw);
+}
+
+/**
+ * Hybrid-encrypt a JSON object string (same as Kotlin {@code JSONObject(data).put(timestamp).put(nonce)}).
+ * @param {string} jsonObjectString — e.g. '{"phone":"1","objectCode":"3"}'
+ * @param {string} serverPublicKeyRaw — Base64 DER SPKI or PEM
+ */
+function hybridEncrypt(jsonObjectString, serverPublicKeyRaw) {
+  const serverPk = loadPublicKey(serverPublicKeyRaw);
+  const obj = JSON.parse(jsonObjectString);
+  if (!obj || typeof obj !== "object" || Array.isArray(obj)) {
+    throw new Error("hybridEncrypt expects a JSON object string");
+  }
+  obj.timestamp = Date.now();
+  obj.nonce = generateAesKey();
+  const merged = JSON.stringify(obj);
+
+  const aesKey = generateAesKey();
+  const aesIv = generateAesIv();
+  const encryptedData = aesEncryptWithBase64Key(merged, aesKey, aesIv);
+  const encryptedAesKey = rsaEncrypt(aesKey, serverPk);
+  const encryptedIv = rsaEncrypt(aesIv, serverPk);
+
+  return {
+    encrypteData: encryptedData,
+    encrypteParam: encryptedAesKey,
+    encrypteParamExt: encryptedIv,
+  };
+}
+
+/**
+ * @param {{ encrypteData: string, encrypteParam: string, encrypteParamExt: string }} result
+ */
+function hybridEncryptResultToJson(result) {
+  return JSON.stringify({
+    encrypteData: result.encrypteData,
+    encrypteParam: result.encrypteParam,
+    encrypteParamExt: result.encrypteParamExt,
+  });
+}
+
+/**
+ * If `json` is still a root-level hybrid envelope (`encrypteData` / `encrypteParam` / `encrypteParamExt`),
+ * run {@code decryptResponseDataFromJson} → {@code hybridDecrypt} and return the parsed plaintext object.
+ * @param {unknown} json
+ * @param {string} [clientPrivateKeyRaw]
+ * @returns {unknown}
+ */
+function parsedJsonAfterHybridEnvelopeDecrypt(json, clientPrivateKeyRaw) {
+  if (!clientPrivateKeyRaw || json == null || typeof json !== "object" || Array.isArray(json)) {
+    return json;
+  }
+  if (Object.prototype.hasOwnProperty.call(json, "_raw")) return json;
+  if (!hybridEncryptResultFromParsedObject(json)) return json;
+  const plain = decryptResponseDataFromJson(JSON.stringify(json), clientPrivateKeyRaw);
+  if (!plain || !plain.trim()) return json;
+  try {
+    return JSON.parse(plain);
+  } catch {
+    return json;
+  }
+}
+
+/**
+ * @param {unknown} json — parsed JSON object
+ */
+function looksLikeHybridEnvelope(json) {
+  return hybridEncryptResultFromParsedObject(json) != null;
+}
+
+function encryptEnvConfigured() {
+  if (encryptDisabledByEnv()) return false;
+  const { serverPublicKey, clientPrivateKey } = resolveEncryptKeys();
+  return !!(serverPublicKey && clientPrivateKey);
+}
+
+module.exports = {
+  hybridEncrypt,
+  hybridEncryptResultToJson,
+  hybridDecrypt,
+  hybridEncryptResultFromJson,
+  hybridEncryptResultFromParsedObject,
+  decryptResponseDataFromJson,
+  decryptResponseData,
+  decryptResponse,
+  tryDecryptResponseBody,
+  encryptEnvConfigured,
+  encryptDisabledByEnv,
+  resolveEncryptKeys,
+  loadPublicKey,
+  loadPrivateKey,
+  parsedJsonAfterHybridEnvelopeDecrypt,
+  looksLikeHybridEnvelope,
+};

package/src/http.js

@@ -1,6 +1,7 @@
 "use strict";
 
 const config = require("./config");
+const encrypt = require("./encrypt");
 
 const DEFAULT_VERSION =
   process.env.CYY_BOOTSTRAP_VERSION_CODE || "22118";
@@ -55,22 +56,48 @@ function buildDefaultHeaders() {
  * @param {string} options.method
  * @param {Record<string,string>} [options.headers]
  * @param {string|null} [options.body]
+ * @param {boolean} [options.decryptHybridResponse] — when true, treat the response body as optional hybrid envelope (same as App `CyyEncryptInterceptor` after an `encrypte: true` request). Ignored unless {@code decryptResponsePrivateKey} is set.
+ * @param {string} [options.decryptResponsePrivateKey] — client RSA private key (PEM or Base64 PKCS#8)
+ * @param {boolean} [options.includeRawWireText] — when true, also return {@code rawWireText}: response body after BOM/trim, **before** optional hybrid decrypt (so callers can run their own decrypt-then-parse pipeline).
  */
-async function request(url, { method, headers, body }) {
+async function request(
+  url,
+  {
+    method,
+    headers,
+    body,
+    decryptHybridResponse = false,
+    decryptResponsePrivateKey,
+    includeRawWireText = false,
+  },
+) {
   const res = await fetch(url, {
     method,
     headers,
     body: body ?? undefined,
     redirect: "follow",
   });
-  const text = await res.text();
+  let text = await res.text();
+  text = text.replace(/^\uFEFF/, "").trimStart();
+  const rawWireText = text;
+  const doHybridResponseDecrypt = decryptHybridResponse && !!decryptResponsePrivateKey;
+  if (doHybridResponseDecrypt) {
+    text = encrypt.decryptResponse(text, decryptResponsePrivateKey);
+  }
   let json = null;
   try {
     json = text ? JSON.parse(text) : null;
   } catch {
     json = { _raw: text };
   }
-  return { ok: res.ok, status: res.status, json };
+  if (doHybridResponseDecrypt && json != null && typeof json === "object") {
+    json = encrypt.parsedJsonAfterHybridEnvelopeDecrypt(json, decryptResponsePrivateKey);
+  }
+  const out = { ok: res.ok, status: res.status, json };
+  if (includeRawWireText) {
+    out.rawWireText = rawWireText;
+  }
+  return out;
 }
 
 function moduleUrl(moduleKey, pathSuffix) {