create-windy 0.5.2 → 0.6.1

package/template/apps/server/src/module-host/module-secret-result.test.ts

@@ -0,0 +1,324 @@
+import { describe, expect, test } from "bun:test";
+import type {
+  ModuleSecretBindingResolution,
+  ModuleSecretSafeValue,
+} from "@southwind-ai/server-sdk";
+import {
+  captureError,
+  secretPortFixture,
+  secretRequest,
+} from "./module-secret-port.test-support.js";
+import { canonicalizeModuleSecretResult } from "./module-secret-result.js";
+
+describe("Module Secret callback canonical snapshot", () => {
+  test("同时扫描 JSON key 与 value 中的原始 Secret", async () => {
+    const marker = "RAW_SECRET_IN_JSON";
+    await expectBlocked({ [marker]: true }, marker);
+    await expectBlocked({ safe: `prefix:${marker}` }, marker);
+  });
+
+  test("拒绝 accessor 且从不执行有状态或抛错 getter", async () => {
+    const marker = "RAW_SECRET_FROM_GETTER";
+    let reads = 0;
+    const stateful = {};
+    Object.defineProperty(stateful, "value", {
+      enumerable: true,
+      get() {
+        reads += 1;
+        return reads === 1 ? "safe" : marker;
+      },
+    });
+    await expectBlocked(stateful, marker);
+    expect(reads).toBe(0);
+
+    const throwing = {};
+    Object.defineProperty(throwing, "value", {
+      enumerable: true,
+      get() {
+        throw new Error(marker);
+      },
+    });
+    await expectBlocked(throwing, marker);
+  });
+
+  test("回调污染 String intrinsic 仍不能把原始 Secret 带出 Port", async () => {
+    const marker = "RAW_MARKER_PATCHED_INTRINSIC";
+    const descriptor = Object.getOwnPropertyDescriptor(
+      String.prototype,
+      "includes",
+    )!;
+    const defineProperty = Object.defineProperty;
+    const setup = await secretPortFixture({ value: marker });
+    let error: unknown;
+    try {
+      error = await captureError(() =>
+        setup.port.resolve(secretRequest, (value) => {
+          defineProperty(String.prototype, "includes", {
+            ...descriptor,
+            value: () => false,
+          });
+          return value;
+        }),
+      );
+    } finally {
+      defineProperty(String.prototype, "includes", descriptor);
+    }
+
+    expect(error).toMatchObject({
+      code: "MODULE_SECRET_EXPOSURE_BLOCKED",
+    });
+    expect(`${String(error)}${JSON.stringify(error)}`).not.toContain(marker);
+  });
+
+  test("canonicalizer 使用捕获的安全关键 intrinsic", () => {
+    const defineProperty = Object.defineProperty;
+    const targets = [
+      [Object, "freeze"],
+      [Object, "defineProperty"],
+      [Object, "setPrototypeOf"],
+      [Array, "isArray"],
+      [Set.prototype, "has"],
+      [TextEncoder.prototype, "encode"],
+    ] as const;
+    const descriptors = targets.map(([target, key]) =>
+      Object.getOwnPropertyDescriptor(target, key),
+    );
+    let result: ReturnType<typeof canonicalizeModuleSecretResult>;
+    try {
+      for (const [target, key] of targets) {
+        defineProperty(target, key, {
+          configurable: true,
+          writable: true,
+          value: () => false,
+        });
+      }
+      const dangerous = {};
+      defineProperty(dangerous, "__proto__", {
+        value: "safe",
+        enumerable: true,
+      });
+      result = canonicalizeModuleSecretResult(dangerous, "RAW_SECRET");
+    } finally {
+      for (let index = 0; index < targets.length; index += 1) {
+        const descriptor = descriptors[index];
+        if (descriptor) {
+          defineProperty(targets[index]![0], targets[index]![1], descriptor);
+        }
+      }
+    }
+    expect(result!.ok).toBe(false);
+  });
+
+  test("拒绝 Proxy、非 plain object、循环与符号属性", async () => {
+    const marker = "RAW_SECRET_NON_JSON";
+    const circular: Record<string, unknown> = {};
+    circular.self = circular;
+    const symbolKey = { safe: true };
+    Object.defineProperty(symbolKey, Symbol("secret"), {
+      value: marker,
+      enumerable: true,
+    });
+    const proxy = new Proxy(
+      { safe: true },
+      {
+        ownKeys() {
+          throw new Error(marker);
+        },
+      },
+    );
+
+    for (const value of [
+      proxy,
+      new Error(marker),
+      new Response(marker),
+      new Map([["secret", marker]]),
+      circular,
+      symbolKey,
+      new Date(),
+    ]) {
+      await expectBlocked(value, marker);
+    }
+  });
+
+  test("拒绝危险 key、非 JSON primitive 和异常数组形状", async () => {
+    const marker = "RAW_SECRET_INVALID_JSON";
+    const dangerous = {};
+    Object.defineProperty(dangerous, "__proto__", {
+      value: "safe",
+      enumerable: true,
+    });
+    const sparse = Array<unknown>(2);
+    sparse[1] = "safe";
+    const customArray = ["safe"];
+    Object.defineProperty(customArray, "extra", {
+      value: true,
+      enumerable: true,
+    });
+
+    for (const value of [
+      dangerous,
+      { value: Number.NaN },
+      { value: Number.POSITIVE_INFINITY },
+      { value: BigInt(1) },
+      { value: () => marker },
+      { value: undefined },
+      sparse,
+      customArray,
+    ]) {
+      await expectBlocked(value, marker);
+    }
+  });
+
+  test("拒绝过深、过宽和过大的返回值", async () => {
+    const marker = "RAW_SECRET_LIMITS";
+    let deep: Record<string, unknown> = {};
+    const root = deep;
+    for (let index = 0; index < 10; index += 1) {
+      const next: Record<string, unknown> = {};
+      deep.next = next;
+      deep = next;
+    }
+
+    await expectBlocked(root, marker);
+    await expectBlocked(
+      Array.from({ length: 1_025 }, () => true),
+      marker,
+    );
+    await expectBlocked("x".repeat(65_537), marker);
+  });
+
+  test("返回深冻结 snapshot，回调原对象后续变更不可见", async () => {
+    const marker = "RAW_SECRET_SNAPSHOT";
+    const setup = await secretPortFixture({ value: marker });
+    const original = {
+      nested: { connected: true },
+      items: ["first"],
+    };
+    const result = await setup.port.resolve(secretRequest, () => original);
+
+    original.nested.connected = false;
+    original.items.push("second");
+    expect(result).toEqual({
+      nested: { connected: true },
+      items: ["first"],
+    });
+    expect(Object.isFrozen(result)).toBe(true);
+    expect(Object.isFrozen(result.nested)).toBe(true);
+    expect(Object.isFrozen(result.items)).toBe(true);
+    expect(result).not.toBe(original);
+  });
+
+  test("snapshot 不继承可变 Object/Array prototype 泄漏钩子", () => {
+    const marker = "RAW_SECRET_FROM_PROTOTYPE";
+    const objectToJson = Object.getOwnPropertyDescriptor(
+      Object.prototype,
+      "toJSON",
+    );
+    const arrayToJson = Object.getOwnPropertyDescriptor(
+      Array.prototype,
+      "toJSON",
+    );
+    const inheritedGetter = Object.getOwnPropertyDescriptor(
+      Object.prototype,
+      "inheritedSecret",
+    );
+    const arrayPrimitive = Object.getOwnPropertyDescriptor(
+      Array.prototype,
+      Symbol.toPrimitive,
+    );
+    try {
+      Object.defineProperty(Object.prototype, "toJSON", {
+        configurable: true,
+        value: () => marker,
+      });
+      Object.defineProperty(Array.prototype, "toJSON", {
+        configurable: true,
+        value: () => marker,
+      });
+      Object.defineProperty(Object.prototype, "inheritedSecret", {
+        configurable: true,
+        get: () => marker,
+      });
+      Object.defineProperty(Array.prototype, Symbol.toPrimitive, {
+        configurable: true,
+        value: () => marker,
+      });
+
+      const result = canonicalizeModuleSecretResult(
+        { safe: true, items: ["first"] },
+        marker,
+      );
+      if (!result.ok) throw new Error("预期 canonical snapshot 成功");
+      const snapshot = result.value;
+      const items = snapshot.items as readonly string[];
+      expect(Object.getPrototypeOf(snapshot)).toBeNull();
+      expect(Array.isArray(items)).toBe(true);
+      expect(Object.getPrototypeOf(items)).not.toBe(Array.prototype);
+      expect(Object.getPrototypeOf(Object.getPrototypeOf(items))).toBeNull();
+      expect(items.map((item) => item.toUpperCase())).toEqual(["FIRST"]);
+      expect("inheritedSecret" in snapshot).toBe(false);
+      expect(Symbol.toPrimitive in items).toBe(false);
+      expect(JSON.stringify(snapshot)).toBe('{"safe":true,"items":["first"]}');
+      expect(JSON.stringify(snapshot)).not.toContain(marker);
+    } finally {
+      restoreDescriptor(Object.prototype, "toJSON", objectToJson);
+      restoreDescriptor(Array.prototype, "toJSON", arrayToJson);
+      restoreDescriptor(Object.prototype, "inheritedSecret", inheritedGetter);
+      restoreDescriptor(Array.prototype, Symbol.toPrimitive, arrayPrimitive);
+    }
+  });
+
+  test("Binding resolution getter 异常也被稳定 unavailable 截断", async () => {
+    const marker = "RAW_SECRET_BINDING_GETTER";
+    const resolution = {};
+    Object.defineProperty(resolution, "status", {
+      enumerable: true,
+      get() {
+        throw new Error(marker);
+      },
+    });
+    const setup = await secretPortFixture({
+      binding: {
+        moduleName: "archive",
+        ...secretRequest,
+        resolve: () => resolution as unknown as ModuleSecretBindingResolution,
+      },
+    });
+
+    const error = await captureError(() =>
+      setup.port.resolve(secretRequest, () => ({ connected: true })),
+    );
+    expect(error).toMatchObject({ code: "MODULE_SECRET_UNAVAILABLE" });
+    expect(`${String(error)}${JSON.stringify(error)}`).not.toContain(marker);
+    expect(JSON.stringify(setup.runtime.auditSink.list())).not.toContain(
+      marker,
+    );
+  });
+});
+
+async function expectBlocked(value: unknown, marker: string): Promise<void> {
+  const setup = await secretPortFixture({ value: marker });
+  const error = await captureError(() =>
+    setup.port.resolve(secretRequest, () => unsafeResult(value)),
+  );
+
+  expect(error).toMatchObject({ code: "MODULE_SECRET_EXPOSURE_BLOCKED" });
+  expect(`${String(error)}${JSON.stringify(error)}`).not.toContain(marker);
+  expect(JSON.stringify(setup.runtime.auditSink.list())).not.toContain(marker);
+}
+
+function unsafeResult(value: unknown): ModuleSecretSafeValue {
+  return value as ModuleSecretSafeValue;
+}
+
+function restoreDescriptor(
+  target: object,
+  key: PropertyKey,
+  descriptor: PropertyDescriptor | undefined,
+): void {
+  if (descriptor) {
+    Object.defineProperty(target, key, descriptor);
+  } else {
+    Reflect.deleteProperty(target, key);
+  }
+}

package/template/apps/server/src/module-host/module-secret-result.ts

@@ -0,0 +1,274 @@
+import { isProxy } from "node:util/types";
+import type { ModuleSecretSafeValue } from "@southwind-ai/server-sdk";
+
+const MAX_DEPTH = 8;
+const MAX_ENTRIES = 1_024;
+const MAX_KEY_BYTES = 128;
+const MAX_STRING_BYTES = 65_536;
+const MAX_TOTAL_BYTES = 131_072;
+const dangerousKeys = new Set(["__proto__", "constructor", "prototype"]);
+const unsafeResult = Symbol("unsafe-module-secret-result");
+const encoder = new TextEncoder();
+const arrayIsArray = Array.isArray;
+const arrayPrototype = Array.prototype;
+const numberIsFinite = Number.isFinite;
+const numberIsSafeInteger = Number.isSafeInteger;
+const objectCreate = Object.create;
+const objectDefineProperty = Object.defineProperty;
+const objectFreeze = Object.freeze;
+const objectGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+const objectGetOwnPropertyDescriptors = Object.getOwnPropertyDescriptors;
+const objectGetPrototypeOf = Object.getPrototypeOf;
+const objectIs = Object.is;
+const objectPrototype = Object.prototype;
+const objectSetPrototypeOf = Object.setPrototypeOf;
+const reflectOwnKeys = Reflect.ownKeys;
+const SetConstructor = Set;
+const setAdd = Function.prototype.call.bind(Set.prototype.add) as <T>(
+  set: Set<T>,
+  value: T,
+) => Set<T>;
+const setDelete = Function.prototype.call.bind(Set.prototype.delete) as <T>(
+  set: Set<T>,
+  value: T,
+) => boolean;
+const setHas = Function.prototype.call.bind(Set.prototype.has) as <T>(
+  set: ReadonlySet<T>,
+  value: T,
+) => boolean;
+const stringIncludes = Function.prototype.call.bind(
+  String.prototype.includes,
+) as (value: string, search: string) => boolean;
+const textEncode = Function.prototype.call.bind(
+  TextEncoder.prototype.encode,
+) as (encoder: TextEncoder, value: string) => Uint8Array;
+const safeArrayPrototype = createSafeArrayPrototype();
+
+type CanonicalResult<TResult> =
+  | { readonly ok: true; readonly value: TResult }
+  | { readonly ok: false };
+
+interface Budget {
+  entries: number;
+  bytes: number;
+  readonly seen: Set<object>;
+}
+
+export function canonicalizeModuleSecretResult<
+  TResult extends ModuleSecretSafeValue | void,
+>(value: TResult, secret: string): CanonicalResult<TResult> {
+  try {
+    const snapshot = snapshotValue(
+      value,
+      secret,
+      { entries: 0, bytes: 0, seen: new SetConstructor<object>() },
+      0,
+    );
+    return { ok: true, value: snapshot as TResult };
+  } catch {
+    return { ok: false };
+  }
+}
+
+function snapshotValue(
+  value: unknown,
+  secret: string,
+  budget: Budget,
+  depth: number,
+): ModuleSecretSafeValue | void {
+  if (depth > MAX_DEPTH) reject();
+  if (value === undefined) {
+    if (depth === 0) return undefined;
+    reject();
+  }
+  if (value === null || typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (!numberIsFinite(value)) reject();
+    return objectIs(value, -0) ? 0 : value;
+  }
+  if (typeof value === "string") {
+    addBytes(budget, value, MAX_STRING_BYTES);
+    if (stringIncludes(value, secret)) reject();
+    return value;
+  }
+  if (typeof value !== "object" || isProxy(value)) reject();
+  if (setHas(budget.seen, value)) reject();
+  setAdd(budget.seen, value);
+  try {
+    return arrayIsArray(value)
+      ? snapshotArray(value, secret, budget, depth)
+      : snapshotObject(value, secret, budget, depth);
+  } finally {
+    setDelete(budget.seen, value);
+  }
+}
+
+function snapshotArray(
+  value: readonly unknown[],
+  secret: string,
+  budget: Budget,
+  depth: number,
+): readonly ModuleSecretSafeValue[] {
+  const length = value.length;
+  if (
+    !numberIsSafeInteger(length) ||
+    length < 0 ||
+    length > MAX_ENTRIES - budget.entries
+  ) {
+    reject();
+  }
+  const descriptors = ownDescriptors(value);
+  const keys = reflectOwnKeys(descriptors);
+  if (hasSymbolKey(keys)) reject();
+  const lengthDescriptor = descriptors.length;
+  if (!lengthDescriptor || !("value" in lengthDescriptor)) reject();
+  if (lengthDescriptor.value !== length || keys.length !== length + 1) {
+    reject();
+  }
+  addEntries(budget, length);
+  const snapshot: ModuleSecretSafeValue[] = [];
+  objectSetPrototypeOf(snapshot, safeArrayPrototype);
+  for (let index = 0; index < length; index += 1) {
+    const descriptor = descriptors[String(index)];
+    if (!isEnumerableDataDescriptor(descriptor)) reject();
+    const child = snapshotValue(descriptor.value, secret, budget, depth + 1);
+    if (child === undefined) reject();
+    snapshot[index] = child;
+  }
+  return objectFreeze(snapshot);
+}
+
+function snapshotObject(
+  value: object,
+  secret: string,
+  budget: Budget,
+  depth: number,
+): Readonly<Record<string, ModuleSecretSafeValue>> {
+  const prototype = objectGetPrototypeOf(value);
+  if (prototype !== objectPrototype && prototype !== null) reject();
+  const descriptors = ownDescriptors(value);
+  const keys = reflectOwnKeys(descriptors);
+  if (hasSymbolKey(keys)) reject();
+  addEntries(budget, keys.length);
+  const snapshot = objectCreate(null) as Record<string, ModuleSecretSafeValue>;
+  for (let index = 0; index < keys.length; index += 1) {
+    const key = keys[index];
+    if (typeof key !== "string") reject();
+    addBytes(budget, key, MAX_KEY_BYTES);
+    if (setHas(dangerousKeys, key) || stringIncludes(key, secret)) reject();
+    const descriptor = descriptors[key];
+    if (!isEnumerableDataDescriptor(descriptor)) reject();
+    const child = snapshotValue(descriptor.value, secret, budget, depth + 1);
+    if (child === undefined) reject();
+    objectDefineProperty(snapshot, key, {
+      value: child,
+      enumerable: true,
+      configurable: false,
+      writable: false,
+    });
+  }
+  return objectFreeze(snapshot);
+}
+
+function hasSymbolKey(keys: readonly PropertyKey[]): boolean {
+  for (let index = 0; index < keys.length; index += 1) {
+    if (typeof keys[index] === "symbol") return true;
+  }
+  return false;
+}
+
+function isEnumerableDataDescriptor(
+  descriptor: PropertyDescriptor | undefined,
+): descriptor is PropertyDescriptor & { value: unknown } {
+  return Boolean(
+    descriptor && descriptor.enumerable === true && "value" in descriptor,
+  );
+}
+
+function ownDescriptors(
+  value: object,
+): Readonly<Record<PropertyKey, PropertyDescriptor | undefined>> {
+  return objectGetOwnPropertyDescriptors(value) as unknown as Readonly<
+    Record<PropertyKey, PropertyDescriptor | undefined>
+  >;
+}
+
+function addEntries(budget: Budget, count: number): void {
+  budget.entries += count;
+  if (budget.entries > MAX_ENTRIES) reject();
+}
+
+function addBytes(budget: Budget, value: string, perValueLimit: number): void {
+  if (value.length > perValueLimit) reject();
+  const bytes = textEncode(encoder, value).byteLength;
+  if (bytes > perValueLimit) reject();
+  budget.bytes += bytes;
+  if (budget.bytes > MAX_TOTAL_BYTES) reject();
+}
+
+function reject(): never {
+  throw unsafeResult;
+}
+
+function createSafeArrayPrototype(): object {
+  const prototype = objectCreate(null) as Record<PropertyKey, unknown>;
+  const descriptors = objectGetOwnPropertyDescriptors(arrayPrototype);
+  const methodNames = [
+    "at",
+    "concat",
+    "entries",
+    "every",
+    "filter",
+    "find",
+    "findIndex",
+    "findLast",
+    "findLastIndex",
+    "flat",
+    "flatMap",
+    "forEach",
+    "includes",
+    "indexOf",
+    "join",
+    "keys",
+    "lastIndexOf",
+    "map",
+    "reduce",
+    "reduceRight",
+    "slice",
+    "some",
+    "toLocaleString",
+    "toReversed",
+    "toSorted",
+    "toSpliced",
+    "toString",
+    "values",
+    "with",
+  ] as const;
+  for (const name of methodNames) {
+    const descriptor = descriptors[name];
+    if (descriptor && "value" in descriptor) {
+      objectDefineProperty(prototype, name, dataMethod(descriptor.value));
+    }
+  }
+  const iterator = objectGetOwnPropertyDescriptor(
+    arrayPrototype,
+    Symbol.iterator,
+  );
+  if (iterator && "value" in iterator) {
+    objectDefineProperty(
+      prototype,
+      Symbol.iterator,
+      dataMethod(iterator.value),
+    );
+  }
+  return objectFreeze(prototype);
+}
+
+function dataMethod(value: unknown): PropertyDescriptor {
+  return {
+    value,
+    enumerable: false,
+    configurable: false,
+    writable: false,
+  };
+}