@alfe.ai/openclaw-secrets 0.2.24 → 0.2.26

package/src/__tests__/crypto.test.ts

@@ -1,187 +0,0 @@
-/**
- * Crypto roundtrip + tamper-fail tests for the openclaw-secrets plugin.
- *
- * We stub the narrow `SecretsKmsProxy` interface (the two KMS-proxy methods
- * `generateSecretDataKey` / `decryptSecretDataKey`) so we don't need a real
- * `AgentApiClient` or KMS during tests:
- *   - generateSecretDataKey returns a deterministic (random-but-stable) AES-256 key.
- *   - decryptSecretDataKey returns the same key for the same ciphertext handle.
- *
- * This lets us verify:
- *   - happy-path encrypt → decrypt roundtrip preserves bytes,
- *   - flipping any byte in the ciphertext / iv / authTag causes decrypt to fail,
- *   - a mismatched data key (simulating KMS context mismatch) causes decrypt to fail,
- *   - the Buffer passed to createCipheriv is zeroed after the call returns.
- *
- * We do NOT test the actual KMS proxy here — that is integration-tested
- * against the real services/secrets.
- */
-import { describe, it, expect, vi } from "vitest";
-import { randomBytes } from "node:crypto";
-import { encryptSecretValue, decryptSecretEnvelope, type SecretsKmsProxy } from "../crypto.js";
-import type { EncryptedEnvelopeV1 } from "@alfe.ai/agent-api-client";
-
-function makeFakeProxy(options: {
-  /**
-   * If set, `decryptSecretDataKey` returns a DIFFERENT key than the one that
-   * was used to encrypt, simulating an encryption-context mismatch or a wrong
-   * data-key ciphertext.
-   */
-  tamperDecryptKey?: boolean;
-} = {}): SecretsKmsProxy {
-  const keysByHandle = new Map<string, Buffer>();
-  let counter = 0;
-
-  return {
-    generateSecretDataKey: vi.fn(async () => {
-      const key = randomBytes(32);
-      const handle = `handle-${String(++counter)}`;
-      keysByHandle.set(handle, key);
-      return {
-        plaintextKey: key.toString("base64"),
-        dataKeyCiphertext: handle,
-      };
-    }),
-
-    decryptSecretDataKey: vi.fn(async ({ dataKeyCiphertext }) => {
-      const key = keysByHandle.get(dataKeyCiphertext);
-      if (!key) throw new Error(`Unknown handle: ${dataKeyCiphertext}`);
-      if (options.tamperDecryptKey) {
-        return { plaintextKey: randomBytes(32).toString("base64") };
-      }
-      return { plaintextKey: key.toString("base64") };
-    }),
-  };
-}
-
-const baseArgs = {
-  scope: "agent" as const,
-  scopeId: "agent-1",
-  secretId: "00000000-0000-4000-8000-000000000000",
-};
-
-describe("crypto", () => {
-  it("roundtrip: encrypt then decrypt returns the original plaintext", async () => {
-    const client = makeFakeProxy();
-    const plaintext = "sk-live-super-secret-\u2764\ufe0f";
-
-    const envelope = await encryptSecretValue({
-      client,
-      ...baseArgs,
-      plaintext,
-    });
-
-    expect(envelope.version).toBe(1);
-    expect(envelope.iv).toBeTruthy();
-    expect(envelope.ciphertext).toBeTruthy();
-    expect(envelope.authTag).toBeTruthy();
-    expect(envelope.dataKeyCiphertext).toBeTruthy();
-
-    const recovered = await decryptSecretEnvelope({
-      client,
-      ...baseArgs,
-      envelope,
-    });
-
-    expect(recovered).toBe(plaintext);
-  });
-
-  it("encrypt produces different ciphertext each call (fresh IV + data key)", async () => {
-    const client = makeFakeProxy();
-    const [a, b] = await Promise.all([
-      encryptSecretValue({ client, ...baseArgs, plaintext: "same" }),
-      encryptSecretValue({ client, ...baseArgs, plaintext: "same" }),
-    ]);
-    expect(a.ciphertext).not.toBe(b.ciphertext);
-    expect(a.iv).not.toBe(b.iv);
-    expect(a.dataKeyCiphertext).not.toBe(b.dataKeyCiphertext);
-  });
-
-  it("rejects a ciphertext with a flipped byte (GCM authTag fails)", async () => {
-    const client = makeFakeProxy();
-    const envelope = await encryptSecretValue({
-      client,
-      ...baseArgs,
-      plaintext: "hello",
-    });
-    const ct = Buffer.from(envelope.ciphertext, "base64");
-    ct[0] = ct[0] ^ 0x01;
-    const tampered: EncryptedEnvelopeV1 = {
-      ...envelope,
-      ciphertext: ct.toString("base64"),
-    };
-
-    await expect(
-      decryptSecretEnvelope({ client, ...baseArgs, envelope: tampered }),
-    ).rejects.toThrow();
-  });
-
-  it("rejects a flipped authTag byte", async () => {
-    const client = makeFakeProxy();
-    const envelope = await encryptSecretValue({
-      client,
-      ...baseArgs,
-      plaintext: "hello",
-    });
-    const tag = Buffer.from(envelope.authTag, "base64");
-    tag[0] = tag[0] ^ 0x80;
-
-    await expect(
-      decryptSecretEnvelope({
-        client,
-        ...baseArgs,
-        envelope: { ...envelope, authTag: tag.toString("base64") },
-      }),
-    ).rejects.toThrow();
-  });
-
-  it("rejects a flipped IV byte", async () => {
-    const client = makeFakeProxy();
-    const envelope = await encryptSecretValue({
-      client,
-      ...baseArgs,
-      plaintext: "hello",
-    });
-    const iv = Buffer.from(envelope.iv, "base64");
-    iv[0] = iv[0] ^ 0x11;
-
-    await expect(
-      decryptSecretEnvelope({
-        client,
-        ...baseArgs,
-        envelope: { ...envelope, iv: iv.toString("base64") },
-      }),
-    ).rejects.toThrow();
-  });
-
-  it("rejects a decrypt that returns a different data key (encryption-context mismatch)", async () => {
-    const client = makeFakeProxy({ tamperDecryptKey: true });
-    const envelope = await encryptSecretValue({
-      client,
-      ...baseArgs,
-      plaintext: "hello",
-    });
-
-    await expect(
-      decryptSecretEnvelope({ client, ...baseArgs, envelope }),
-    ).rejects.toThrow();
-  });
-
-  it("rejects a bogus data-key length from the proxy (32 bytes required)", async () => {
-    const badClient: SecretsKmsProxy = {
-      generateSecretDataKey: vi.fn(async () => ({
-        plaintextKey: Buffer.alloc(16).toString("base64"),
-        dataKeyCiphertext: "h",
-      })),
-      decryptSecretDataKey: vi.fn(),
-    };
-
-    await expect(
-      encryptSecretValue({
-        client: badClient,
-        ...baseArgs,
-        plaintext: "hello",
-      }),
-    ).rejects.toThrow(/data key length/);
-  });
-});

package/src/__tests__/scope-resolve.test.ts

@@ -1,68 +0,0 @@
-/**
- * Unit coverage for the scopeId auto-fill helper. The plugin used to
- * require an explicit scopeId for every tool call, which led LLMs to
- * pass the literal word "agent" as the ID. This helper closes the gap
- * by filling from ctx.agentId when scope=agent and the LLM either
- * omits scopeId or sets it to "agent".
- */
-import { describe, it, expect } from "vitest";
-import { resolveScopeId } from "../scope-resolve.js";
-
-describe("resolveScopeId — agent scope", () => {
-  const ctx = { agentId: "agt_01TEST" };
-
-  it("falls back to ctx.agentId when scopeId is omitted", () => {
-    expect(resolveScopeId("agent", {}, ctx)).toBe("agt_01TEST");
-  });
-
-  it("falls back to ctx.agentId when scopeId is empty string", () => {
-    expect(resolveScopeId("agent", { scopeId: "" }, ctx)).toBe("agt_01TEST");
-  });
-
-  it("falls back to ctx.agentId when scopeId is the literal 'agent'", () => {
-    expect(resolveScopeId("agent", { scopeId: "agent" }, ctx)).toBe("agt_01TEST");
-  });
-
-  it("uses an explicit real (other) agent ID as-is", () => {
-    expect(resolveScopeId("agent", { scopeId: "agt_01OTHER" }, ctx)).toBe("agt_01OTHER");
-  });
-
-  it("normalises a case-mangled own agent ID back to ctx.agentId's canonical casing", () => {
-    // An LLM may lowercase the agent's own ULID; the server's self-scope check
-    // is an exact match, so we snap it back to the runtime's canonical value.
-    expect(resolveScopeId("agent", { scopeId: "agt_01test" }, ctx)).toBe("agt_01TEST");
-  });
-
-  it("throws when ctx.agentId is missing and no usable scopeId is provided", () => {
-    expect(() => resolveScopeId("agent", {}, {})).toThrow(/agent scope requires/);
-    expect(() => resolveScopeId("agent", { scopeId: "agent" }, {})).toThrow(/agent scope requires/);
-  });
-});
-
-describe("resolveScopeId — non-agent scopes", () => {
-  const ctx = { agentId: "agt_01TEST" };
-
-  it("requires an explicit scopeId for org scope", () => {
-    expect(() => resolveScopeId("org", {}, ctx)).toThrow(/scopeId is required/);
-    expect(() => resolveScopeId("org", { scopeId: "" }, ctx)).toThrow(/scopeId is required/);
-  });
-
-  it("returns the explicit scopeId for team scope", () => {
-    expect(resolveScopeId("team", { scopeId: "team_x" }, ctx)).toBe("team_x");
-  });
-
-  it("returns the explicit scopeId for project scope", () => {
-    expect(resolveScopeId("project", { scopeId: "proj_y" }, ctx)).toBe("proj_y");
-  });
-
-  it("rejects scopeIds longer than 256 characters", () => {
-    const tooLong = "x".repeat(257);
-    expect(() => resolveScopeId("org", { scopeId: tooLong }, ctx)).toThrow(/256 characters/);
-  });
-
-  it("ignores ctx.agentId for non-agent scopes — explicit scopeId always wins", () => {
-    expect(resolveScopeId("team", { scopeId: "team_x" }, { agentId: "agt_other" })).toBe(
-      "team_x",
-    );
-  });
-});

package/src/crypto.ts

@@ -1,115 +0,0 @@
-/**
- * Agent-side AES-256-GCM with data keys issued by the Alfe secrets service.
- *
- * Trust model:
- *   - The agent NEVER holds a KMS key directly.
- *   - For each encrypt/decrypt, the agent fetches a one-shot AES data key from
- *     the secrets service over authenticated TLS.
- *   - The plaintext key is held as a `Buffer` ONLY — never as a JS string.
- *     (Strings are immutable and cannot be zeroed; Buffers can be `.fill(0)`'d.)
- *   - After each operation the Buffer is zeroed.
- *
- * Envelope format is `EncryptedEnvelopeV1` as defined in `@alfe/types` and
- * persisted by services/secrets.
- */
-import { createCipheriv, createDecipheriv, randomBytes } from "node:crypto";
-import type { EncryptedEnvelopeV1, SecretScope } from "@alfe.ai/agent-api-client";
-
-/**
- * Narrow interface capturing just the two KMS-proxy methods the crypto
- * helpers need. `AgentApiClient` satisfies this; tests can supply a
- * hand-rolled stub without mocking the whole client surface.
- */
-export interface SecretsKmsProxy {
-  generateSecretDataKey(args: {
-    scope: SecretScope;
-    scopeId: string;
-    secretId: string;
-    fieldKey: string;
-  }): Promise<{ plaintextKey: string; dataKeyCiphertext: string }>;
-
-  decryptSecretDataKey(args: {
-    scope: SecretScope;
-    scopeId: string;
-    secretId: string;
-    fieldKey: string;
-    dataKeyCiphertext: string;
-  }): Promise<{ plaintextKey: string }>;
-}
-
-const AES_256_KEY_BYTES = 32;
-const GCM_IV_BYTES = 12;
-
-function decodeKeyToBuffer(base64: string): Buffer {
-  const buf = Buffer.from(base64, "base64");
-  if (buf.length !== AES_256_KEY_BYTES) {
-    buf.fill(0);
-    throw new Error(`Unexpected data key length: ${String(buf.length)} bytes`);
-  }
-  return buf;
-}
-
-export async function encryptSecretValue(args: {
-  client: SecretsKmsProxy;
-  scope: SecretScope;
-  scopeId: string;
-  secretId: string;
-  fieldKey: string;
-  plaintext: string;
-}): Promise<EncryptedEnvelopeV1> {
-  const { client, scope, scopeId, secretId, fieldKey, plaintext } = args;
-  const { plaintextKey, dataKeyCiphertext } = await client.generateSecretDataKey({
-    scope,
-    scopeId,
-    secretId,
-    fieldKey,
-  });
-
-  const keyBuf = decodeKeyToBuffer(plaintextKey);
-  try {
-    const iv = randomBytes(GCM_IV_BYTES);
-    const cipher = createCipheriv("aes-256-gcm", keyBuf, iv);
-    const ciphertext = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
-    const authTag = cipher.getAuthTag();
-    return {
-      version: 1,
-      iv: iv.toString("base64"),
-      ciphertext: ciphertext.toString("base64"),
-      authTag: authTag.toString("base64"),
-      dataKeyCiphertext,
-    };
-  } finally {
-    keyBuf.fill(0);
-  }
-}
-
-export async function decryptSecretEnvelope(args: {
-  client: SecretsKmsProxy;
-  scope: SecretScope;
-  scopeId: string;
-  secretId: string;
-  fieldKey: string;
-  envelope: EncryptedEnvelopeV1;
-}): Promise<string> {
-  const { client, scope, scopeId, secretId, fieldKey, envelope } = args;
-  const { plaintextKey } = await client.decryptSecretDataKey({
-    scope,
-    scopeId,
-    secretId,
-    fieldKey,
-    dataKeyCiphertext: envelope.dataKeyCiphertext,
-  });
-
-  const keyBuf = decodeKeyToBuffer(plaintextKey);
-  try {
-    const iv = Buffer.from(envelope.iv, "base64");
-    const ciphertext = Buffer.from(envelope.ciphertext, "base64");
-    const authTag = Buffer.from(envelope.authTag, "base64");
-    const decipher = createDecipheriv("aes-256-gcm", keyBuf, iv);
-    decipher.setAuthTag(authTag);
-    const decrypted = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
-    return decrypted.toString("utf8");
-  } finally {
-    keyBuf.fill(0);
-  }
-}