Files
Agent-Workbench/tests/credential-vault.test.mjs
T
2026-11-12 09:01:34 +08:00

124 lines
11 KiB
JavaScript

import test from 'node:test';
import assert from 'node:assert/strict';
import fs from 'node:fs';
import path from 'node:path';
import { randomBytes } from 'node:crypto';
import { fixture } from './helpers.mjs';
import { Store } from '../src/server/store.mjs';
import { Provider } from '../src/server/provider.mjs';
import { ConfigImporter } from '../src/core/models/config-import.mjs';
import { protectCredential, unprotectCredential } from '../src/core/desktop/windows-dpapi.mjs';
const create = f => { const provider = new Provider(); provider.setKey(''); return { provider, hub: provider.modelHub(f.store) }; };
const add = (hub, name, extra = {}) => hub.upsert({ name, model: name, baseUrl: 'http://127.0.0.1:12001/v1', apiKey: 'owned-vault-' + name, ...extra });
const reopen = f => { f.store.close(); const store = new Store(f.data); f.onCleanup(() => store.close()); const provider = new Provider(); provider.setKey(''); return { store, provider, hub: provider.modelHub(store) }; };
test('a Windows virtual data-directory name binds new storage and credentials to its actual physical root', t => {
const f = fixture(t), logical = path.join(f.root, 'virtual-local-data'), physical = path.join(f.root, 'physical-local-data');
fs.mkdirSync(logical); fs.mkdirSync(physical);
const realpath = fs.realpathSync.native;
t.mock.method(fs.realpathSync, 'native', (file, ...options) => path.resolve(file) === logical ? physical : realpath(file, ...options));
const store = new Store(logical); f.onCleanup(() => store.close());
const provider = new Provider(); provider.setKey(''); const hub = provider.modelHub(store);
assert.equal(store.directory, physical); assert.equal(store.storage.filename, path.join(physical, 'workbench.sqlite'));
assert.equal(hub.vault().view(hub).unavailable, false);
assert.equal(fs.existsSync(path.join(physical, 'workbench.sqlite')), true); assert.deepEqual(fs.readdirSync(logical), []);
});
test('physical data-root adoption still rejects explicit junctions at the directory or any ancestor', t => {
const f = fixture(t), direct = path.join(f.root, 'direct-data-link'), parent = path.join(f.root, 'parent-link');
const target = path.join(f.root, 'parent-target'); fs.mkdirSync(path.join(target, 'data'), { recursive: true });
fs.symlinkSync(f.data, direct, 'junction'); fs.symlinkSync(target, parent, 'junction');
const database = f.store.storage.database, original = f.store.directory;
for (const alias of [direct, path.join(parent, 'data')]) {
assert.throws(() => new Store(alias), /符号链接或目录联接/);
f.store.directory = alias; assert.throws(() => f.store.ensureStorage(), /符号链接或目录联接/);
assert.equal(f.store.directory, alias); assert.equal(f.store.storage.database, database);
}
f.store.directory = original; assert.deepEqual(fs.readdirSync(path.join(target, 'data')), []);
});
test('actual Windows CurrentUser DPAPI roundtrips owned UTF-8 and rejects damaged bytes and wrong entropy', () => {
const plain = Buffer.from('自有测试凭据 owned-key-only', 'utf8'), entropy = randomBytes(32), encrypted = protectCredential(plain, entropy);
assert.notDeepEqual(encrypted, plain); assert.deepEqual(unprotectCredential(encrypted, entropy), plain);
assert.throws(() => unprotectCredential(encrypted, randomBytes(32)), /无法处理/);
encrypted[encrypted.length - 1] ^= 255; assert.throws(() => unprotectCredential(encrypted, entropy), /无法处理/);
});
test('explicit temporary keys stay in memory; saved keys restore original revisions without exposure in public views', t => {
const f = fixture(t), { provider, hub } = create(f); provider.setKey('owned-unsaved-legacy');
const volatile = add(hub, 'volatile', { persistKey: false }), saved = add(hub, 'saved', { persistKey: true });
const ledger = f.store.storage.meta('modelCredentials'); assert.deepEqual(Object.keys(ledger.entries), [saved.id]);
assert.equal(hub.credential(saved).revision, ledger.entries[saved.id].credentialRevision);
assert.equal(JSON.stringify(ledger).includes('owned-vault-'), false); assert.equal(JSON.stringify(hub.vault().view(hub)).includes('owned-vault-'), false);
assert.equal(provider.apiKey, 'owned-unsaved-legacy');
const fresh = reopen(f); assert.equal(fresh.provider.hasKey(), false);
assert.equal(fresh.hub.status(fresh.hub.connection(volatile.id)).hasKey, false);
assert.equal(fresh.hub.credential(fresh.hub.connection(saved.id)).key, 'owned-vault-saved');
assert.equal(fresh.hub.credential(fresh.hub.connection(saved.id)).revision, hub.credential(saved).revision);
assert.equal(fresh.hub.vault().status(saved).status, 'saved');
});
test('registry and cipher commit failure restores original routing, keys, block and every database row', t => {
const f = fixture(t), { provider, hub } = create(f), saved = add(hub, 'before', { persistKey: true });
const originalState = structuredClone(hub.state), keyReference = provider.credentials.get(saved.id), block = f.store.storage.meta('modelCredentials');
const snapshot = () => ['metadata', 'projects', 'sessions', 'records', 'events', 'outbox'].map(table => f.store.storage.database.prepare('SELECT * FROM ' + table + ' ORDER BY rowid').all());
const originalRows = snapshot();
f.store.storage.faultInjector = point => { if (point === 'before_commit') throw new Error('owned vault commit failure'); };
assert.throws(() => hub.upsert({ ...saved, model: 'after', apiKey: 'owned-after-key', persistKey: true }), /owned vault commit failure/);
assert.deepEqual(hub.state, originalState); assert.equal(provider.credentials.get(saved.id), keyReference);
assert.deepEqual(hub.vault().state, block); assert.deepEqual(snapshot(), originalRows);
f.store.storage.faultInjector = null;
});
test('a two-key import with a protection failure rolls back all registry and cipher entries and retains its preview', t => {
const f = fixture(t), { hub } = create(f), vault = hub.vault(), importer = new ConfigImporter(hub), filename = path.join(f.root, 'owned-import.json');
fs.writeFileSync(filename, JSON.stringify({ schema: 1, connections: ['one', 'two'].map(name => ({ name, model: name, baseUrl: 'http://127.0.0.1:12002/v1', apiKey: 'owned-import-' + name })) }));
const preview = importer.preview('workbench-json', filename), state = structuredClone(hub.state); let calls = 0;
vault.protect = (bytes, entropy) => { if (++calls === 2) throw new Error('owned second protect failure'); return protectCredential(bytes, entropy); };
assert.throws(() => importer.apply(preview.id, false, true), /owned second protect failure/);
assert.deepEqual(hub.state, state); assert.deepEqual(vault.state.entries, {}); assert.equal(hub.provider.credentials.size, 0); assert.equal(importer.previews.has(preview.id), true);
vault.protect = protectCredential; const accepted = importer.apply(preview.id, false, true);
assert.equal(accepted.imported.length, 2); assert.equal(Object.keys(vault.state.entries).length, 2);
});
test('connection revision changes retain the original saved block and report a source mismatch on restart', t => {
const f = fixture(t), { hub } = create(f), original = add(hub, 'original', { persistKey: true }), block = structuredClone(hub.vault().state.entries[original.id]);
const changed = hub.upsert({ ...original, model: 'changed' }); assert.equal(hub.vault().status(changed).status, 'source_changed');
assert.deepEqual(hub.vault().state.entries[original.id], block);
const fresh = reopen(f); assert.equal(fresh.hub.status(fresh.hub.connection(original.id)).hasKey, false); assert.equal(fresh.hub.vault().status(fresh.hub.connection(original.id)).status, 'source_changed');
});
test('disable skips real restart loading, explicit enable restores, delete preserves memory and forget removes both', t => {
const f = fixture(t), { hub } = create(f), saved = add(hub, 'toggle', { persistKey: true });
hub.manageCredential({ id: saved.id, revision: saved.revision, action: 'disable' }); assert.equal(hub.status(saved).hasKey, true);
const fresh = reopen(f), connection = fresh.hub.connection(saved.id); assert.equal(fresh.hub.status(connection).hasKey, false); assert.equal(fresh.hub.vault().status(connection).status, 'disabled');
fresh.hub.manageCredential({ id: saved.id, revision: saved.revision, action: 'enable' }); assert.equal(fresh.hub.status(connection).hasKey, true);
fresh.hub.manageCredential({ id: saved.id, revision: saved.revision, action: 'delete' }); assert.equal(fresh.hub.status(connection).hasKey, true); assert.equal(fresh.hub.vault().status(connection).status, 'not_saved');
fresh.hub.manageCredential({ id: saved.id, revision: saved.revision, action: 'forget' }); assert.equal(fresh.hub.status(connection).hasKey, false);
});
test('corrupt saved block and another SID do not load; failures are visible without returning ciphertext or plaintext', t => {
const f = fixture(t), { hub } = create(f), saved = add(hub, 'corrupt', { persistKey: true });
const state = f.store.storage.meta('modelCredentials'); state.entries[saved.id].ciphertext = 'AAAA'; f.store.storage.transaction(() => f.store.storage.setMeta('modelCredentials', state));
const fresh = reopen(f), connection = fresh.hub.connection(saved.id); assert.equal(fresh.hub.status(connection).hasKey, false); assert.equal(fresh.hub.vault().status(connection).status, 'decrypt_failed');
const publicView = fresh.hub.vault().view(fresh.hub); assert.equal(JSON.stringify(publicView).includes('AAAA'), false); assert.equal(JSON.stringify(publicView).includes('owned-vault-corrupt'), false);
fresh.hub.vault().state.entries[saved.id].userSid = 'S-1-5-21-1-2-3-1000'; assert.equal(fresh.hub.vault().status(connection).status, 'user_mismatch');
});
test('legacy persistence requires a new explicit key and binds config and credential revisions; stale requests cannot save', t => {
const f = fixture(t), { provider, hub } = create(f), legacy = hub.connection('legacy-default'); provider.setKey('owned-original-memory');
assert.throws(() => hub.manageCredential({ id: legacy.id, revision: legacy.revision, action: 'save' }), /重新填写/); assert.equal(provider.apiKey, 'owned-original-memory');
assert.throws(() => hub.manageCredential({ id: legacy.id, revision: legacy.revision - 1, action: 'save', apiKey: 'owned-explicit' }), /刷新/);
hub.manageCredential({ id: legacy.id, revision: legacy.revision, action: 'save', apiKey: 'owned-explicit' });
const fresh = reopen(f); assert.equal(fresh.provider.apiKey, 'owned-explicit'); assert.equal(fresh.provider.legacyCredentialRevision, 2);
fresh.store.saveConfig({ model: 'new-model' }); assert.equal(fresh.hub.vault().status(fresh.hub.connection(legacy.id)).status, 'source_changed');
});
test('owned plaintext keys never reach SQLite pages, WAL, config or public execution exports', t => {
const f = fixture(t), { hub } = create(f), key = 'OWNED_VAULT_PLAINTEXT_SENTINEL_42fdbedc67b9420f'; add(hub, 'leak-check', { apiKey: key, persistKey: true });
const needles = [Buffer.from(key), Buffer.from(key, 'utf16le'), Buffer.from(Buffer.from(key).toString('base64'))];
for (const file of fs.readdirSync(f.data)) if (fs.statSync(path.join(f.data, file)).isFile()) { const bytes = fs.readFileSync(path.join(f.data, file)); for (const needle of needles) assert.equal(bytes.includes(needle), false, file); }
assert.equal(JSON.stringify(f.store.publicSession(f.session)).includes(key), false); assert.equal(JSON.stringify(hub.view()).includes(key), false);
});