@claude-flow/security 3.0.0-alpha.1 → 3.0.0-alpha.11

package/__tests__/plugin-integrity-verifier.test.ts

@@ -0,0 +1,199 @@
+/**
+ * Tests for PluginIntegrityVerifier (ADR-145 P1, ruvnet/ruflo#2254).
+ *
+ * Covers:
+ *  - canonicalize is deterministic (key order doesn't change the digest)
+ *  - findAnchor matches by exact key, by exact-id scope, and by glob scope
+ *  - findAnchor rejects expired anchors
+ *  - verify reports `signature-missing` for unsigned manifests
+ *  - verify reports `manifest-hash-mismatch` when the manifest is tampered
+ *  - verify reports `unknown-signer` when the key isn't in trust anchors
+ *  - verify reports `pass` on a valid round-trip sign → verify
+ *  - verify reports `signature-invalid` on a flipped signature byte
+ */
+
+import { describe, it, expect, beforeAll } from 'vitest';
+import { createHash } from 'node:crypto';
+import {
+  PluginIntegrityVerifier,
+  canonicalize,
+  hashManifest,
+  findAnchor,
+  type PluginManifest,
+  type SignedPluginManifest,
+  type TrustAnchor,
+  type TrustAnchors,
+} from '../src/plugins/integrity-verifier.js';
+
+// ─── helpers ────────────────────────────────────────────────────────────
+
+let ed: typeof import('@noble/ed25519') | null = null;
+beforeAll(async () => {
+  try {
+    ed = await import('@noble/ed25519');
+    if (!ed.etc.sha512Sync) {
+      ed.etc.sha512Sync = (...m: Uint8Array[]) => {
+        const h = createHash('sha512');
+        for (const x of m) h.update(x);
+        return h.digest();
+      };
+    }
+  } catch {
+    ed = null;
+  }
+});
+
+function hex(b: Uint8Array): string {
+  return Array.from(b, x => x.toString(16).padStart(2, '0')).join('');
+}
+
+async function makeSigner(): Promise<{ priv: Uint8Array; pub: string }> {
+  if (!ed) throw new Error('ed25519 not available');
+  const priv = ed.utils.randomPrivateKey();
+  const pub = hex(await ed.getPublicKey(priv));
+  return { priv, pub };
+}
+
+async function sign(
+  manifest: PluginManifest,
+  priv: Uint8Array,
+  pub: string,
+): Promise<SignedPluginManifest> {
+  if (!ed) throw new Error('ed25519 not available');
+  const manifestHash = hashManifest(manifest);
+  const sig = await ed.sign(hexBytes(manifestHash), priv);
+  return { manifest, manifestHash, signature: hex(sig), publicKey: pub };
+}
+
+function hexBytes(h: string): Uint8Array {
+  const out = new Uint8Array(h.length / 2);
+  for (let i = 0; i < out.length; i++) out[i] = parseInt(h.substr(i * 2, 2), 16);
+  return out;
+}
+
+function anchorsFor(pub: string, scope = '*'): TrustAnchors {
+  return {
+    version: 1,
+    anchors: [{ publicKey: pub, owner: 'test', scope }],
+  };
+}
+
+// ─── canonicalize ──────────────────────────────────────────────────────
+
+describe('canonicalize — deterministic JSON for hashing', () => {
+  it('orders keys deterministically at every level', () => {
+    const a = canonicalize({ b: 1, a: 2, c: { y: 1, x: 2 } });
+    const b = canonicalize({ a: 2, c: { x: 2, y: 1 }, b: 1 });
+    expect(a).toBe(b);
+  });
+
+  it('arrays preserve order', () => {
+    expect(canonicalize({ k: [3, 1, 2] })).toBe('{"k":[3,1,2]}');
+  });
+
+  it('different content yields different output', () => {
+    expect(canonicalize({ a: 1 })).not.toBe(canonicalize({ a: 2 }));
+  });
+});
+
+// ─── findAnchor ────────────────────────────────────────────────────────
+
+describe('findAnchor — trust resolution', () => {
+  const NOW = Date.now();
+
+  it('matches by exact key + matching exact scope', () => {
+    const anchors: TrustAnchor[] = [
+      { publicKey: 'PK', owner: 'o', scope: '@claude-flow/memory' },
+    ];
+    expect(findAnchor(anchors, '@claude-flow/memory', 'PK', NOW)).not.toBeNull();
+  });
+
+  it('matches by exact key + wildcard scope', () => {
+    const anchors: TrustAnchor[] = [{ publicKey: 'PK', owner: 'o', scope: '@claude-flow/*' }];
+    expect(findAnchor(anchors, '@claude-flow/anything', 'PK', NOW)).not.toBeNull();
+  });
+
+  it('rejects exact-key with out-of-scope plugin id', () => {
+    const anchors: TrustAnchor[] = [
+      { publicKey: 'PK', owner: 'o', scope: '@claude-flow/*' },
+    ];
+    expect(findAnchor(anchors, '@third-party/x', 'PK', NOW)).toBeNull();
+  });
+
+  it('rejects wrong key even if scope matches', () => {
+    const anchors: TrustAnchor[] = [{ publicKey: 'PK', owner: 'o', scope: '*' }];
+    expect(findAnchor(anchors, 'anything', 'OTHER', NOW)).toBeNull();
+  });
+
+  it('rejects expired anchor', () => {
+    const anchors: TrustAnchor[] = [
+      { publicKey: 'PK', owner: 'o', scope: '*', expiresAt: '2020-01-01' },
+    ];
+    expect(findAnchor(anchors, 'x', 'PK', NOW)).toBeNull();
+  });
+});
+
+// ─── verify ────────────────────────────────────────────────────────────
+
+describe('PluginIntegrityVerifier.verify', () => {
+  const skipMsg = '@noble/ed25519 unavailable — skipping signature round-trip tests';
+
+  it('returns signature-missing when signature is empty', async () => {
+    const v = new PluginIntegrityVerifier({ trustAnchors: anchorsFor('PK') });
+    const r = await v.verify({
+      manifest: { id: 'p', version: '1.0.0' },
+      manifestHash: 'abc',
+      signature: '',
+      publicKey: 'PK',
+    });
+    expect(r.status).toBe('signature-missing');
+    expect(r.pluginId).toBe('p');
+  });
+
+  it('returns manifest-hash-mismatch when the manifest is tampered', async () => {
+    if (!ed) { console.warn(skipMsg); return; }
+    const { priv, pub } = await makeSigner();
+    const signed = await sign({ id: 'p', version: '1.0.0' }, priv, pub);
+    // Tamper: change the manifest after signing
+    const tampered: SignedPluginManifest = {
+      ...signed,
+      manifest: { id: 'p', version: '1.0.0', extra: 'sneaky' },
+    };
+    const v = new PluginIntegrityVerifier({ trustAnchors: anchorsFor(pub) });
+    const r = await v.verify(tampered);
+    expect(r.status).toBe('manifest-hash-mismatch');
+  });
+
+  it('returns unknown-signer when the publicKey is not in trust anchors', async () => {
+    if (!ed) { console.warn(skipMsg); return; }
+    const { priv, pub } = await makeSigner();
+    const signed = await sign({ id: 'p', version: '1.0.0' }, priv, pub);
+    const v = new PluginIntegrityVerifier({
+      trustAnchors: anchorsFor('OTHER-PUBLIC-KEY'),
+    });
+    const r = await v.verify(signed);
+    expect(r.status).toBe('unknown-signer');
+  });
+
+  it('passes a valid round-trip sign → verify', async () => {
+    if (!ed) { console.warn(skipMsg); return; }
+    const { priv, pub } = await makeSigner();
+    const signed = await sign({ id: 'p', version: '1.0.0' }, priv, pub);
+    const v = new PluginIntegrityVerifier({ trustAnchors: anchorsFor(pub) });
+    const r = await v.verify(signed);
+    expect(r.status).toBe('pass');
+    expect(r.signerFingerprint).toBe(pub.slice(0, 16));
+  });
+
+  it('returns signature-invalid when a signature byte is flipped', async () => {
+    if (!ed) { console.warn(skipMsg); return; }
+    const { priv, pub } = await makeSigner();
+    const signed = await sign({ id: 'p', version: '1.0.0' }, priv, pub);
+    // Flip the first byte of the signature
+    const flipped = signed.signature.slice(0, 2) === 'ff' ? '00' : 'ff';
+    const tampered = { ...signed, signature: flipped + signed.signature.slice(2) };
+    const v = new PluginIntegrityVerifier({ trustAnchors: anchorsFor(pub) });
+    const r = await v.verify(tampered);
+    expect(r.status).toBe('signature-invalid');
+  });
+});