109 lines
9.7 KiB
JavaScript
109 lines
9.7 KiB
JavaScript
const test = require('node:test');
|
|
const assert = require('node:assert/strict');
|
|
const fs = require('node:fs/promises');
|
|
const os = require('node:os');
|
|
const path = require('node:path');
|
|
|
|
test('session updates remain atomic when the state directory rejects file renames',async t=>{
|
|
const {BpmVault}=require('../../src/platform/security/vault.cjs');
|
|
const dir=await fs.mkdtemp(path.join(os.tmpdir(),'bpm-session-rename-'));
|
|
const vault=new BpmVault({stateDir:dir});
|
|
t.after(async()=>{vault.destroy();await fs.rm(dir,{recursive:true,force:true});});
|
|
t.mock.method(fs,'rename',async()=>{throw Object.assign(new Error('cross device rename'),{code:'EXDEV'});});
|
|
await vault.write('session',{storageState:{cookies:[]},sessionStorage:{test:{value:'private-session-state'}}});
|
|
await vault.write('session',{storageState:{cookies:[]},sessionStorage:{test:{value:'updated-session-state'}}});
|
|
vault.destroy();const restarted=new BpmVault({stateDir:dir});
|
|
try{assert.equal((await restarted.read('session')).sessionStorage.test.value,'updated-session-state');}finally{restarted.destroy();}
|
|
for(const filename of await fs.readdir(dir)){const bytes=await fs.readFile(path.join(dir,filename));assert.equal(bytes.includes(Buffer.from('updated-session-state')),false);assert.equal(filename.endsWith('.tmp'),false);}
|
|
});
|
|
|
|
test('managed accounts use an encrypted SQLite registry with uniqueness across connections and restarts',async t=>{
|
|
const {BpmVault}=require('../../src/platform/security/vault.cjs');
|
|
const dir=await fs.mkdtemp(path.join(os.tmpdir(),'bpm-accounts-db-'));
|
|
const vault=new BpmVault({stateDir:dir}),second=new BpmVault({stateDir:dir});
|
|
t.after(async()=>{vault.destroy();second.destroy();await fs.rm(dir,{recursive:true,force:true});});
|
|
await vault.write('account:a',{username:' Fixture.User ',password:'Secret-first-value',updatedAt:'2026-10-16T00:00:00Z'});
|
|
await assert.rejects(second.write('account:b',{username:'fixture.USER',password:'Secret-second-value'}),e=>e.status===409&&e.code==='BPM_ACCOUNT_DUPLICATE');
|
|
assert.equal(await second.read('account:b'),null);
|
|
assert.equal((await second.read('account:a')).password,'Secret-first-value');
|
|
const {DatabaseSync}=require('node:sqlite');const db=new DatabaseSync(path.join(dir,'accounts.sqlite'),{readOnly:true});
|
|
try{assert.equal(db.prepare('SELECT count(*) AS n FROM accounts').get().n,1);}finally{db.close();}
|
|
for(const file of await fs.readdir(dir))if(/sqlite/.test(file)){const bytes=await fs.readFile(path.join(dir,file));assert.equal(bytes.includes(Buffer.from('Secret-first-value')),false);assert.equal(bytes.includes(Buffer.from('Fixture.User')),false);}
|
|
await vault.write('account:a',{username:'fixture.user',password:'Updated-secret'});
|
|
assert.deepEqual(await second.accountAvailability('b',' FIXTURE.USER '),{available:false});
|
|
assert.deepEqual(await second.accountAvailability('a','FIXTURE.USER'),{available:true});
|
|
await vault.remove('account:a');await second.write('account:b',{username:'fixture.user',password:'Now-available'});
|
|
second.destroy();const restarted=new BpmVault({stateDir:dir});
|
|
try{assert.equal((await restarted.read('account:b')).password,'Now-available');await assert.rejects(restarted.write('account:c',{username:'Fixture.User',password:'Duplicate'}),e=>e.status===409);}finally{restarted.destroy();}
|
|
});
|
|
|
|
test('simultaneous account saves admit only one normalized username and preserve other records',async t=>{
|
|
const {BpmVault}=require('../../src/platform/security/vault.cjs');const dir=await fs.mkdtemp(path.join(os.tmpdir(),'bpm-unique-'));
|
|
const vault=new BpmVault({stateDir:dir}),other=new BpmVault({stateDir:dir});
|
|
t.after(async()=>{vault.destroy();other.destroy();await fs.rm(dir,{recursive:true,force:true});});
|
|
await vault.write('account:existing',{username:'different',password:'keep-this'});
|
|
const results=await Promise.allSettled([vault.write('account:a',{username:'Same.User',password:'one'}),other.write('account:b',{username:' same.user ',password:'two'})]);
|
|
assert.equal(results.filter(r=>r.status==='fulfilled').length,1);assert.equal(results.find(r=>r.status==='rejected').reason.status,409);
|
|
await assert.rejects(vault.write('account:existing',{username:'SAME.USER',password:'replacement'}),e=>e.status===409);
|
|
assert.equal((await vault.read('account:existing')).password,'keep-this');
|
|
});
|
|
|
|
test('legacy encrypted account files migrate atomically and conflicting legacy files are retained',async t=>{
|
|
const {BpmVault}=require('../../src/platform/security/vault.cjs'),crypto=require('node:crypto');const dir=await fs.mkdtemp(path.join(os.tmpdir(),'bpm-legacy-'));
|
|
const vault=new BpmVault({stateDir:dir});t.after(async()=>{vault.destroy();await fs.rm(dir,{recursive:true,force:true});});
|
|
const legacy=async(id,username)=>{const key='account:'+id,iv=crypto.randomBytes(12),cipher=crypto.createCipheriv('aes-256-gcm',vault.ensureKey(),iv);cipher.setAAD(Buffer.from(key));const data=Buffer.concat([cipher.update(JSON.stringify({username,password:'legacy-secret',nextAttemptAt:'2030-01-01T00:00:00Z'})),cipher.final()]);await fs.writeFile(vault.filename(key),Buffer.concat([Buffer.from('BPM1'),iv,cipher.getAuthTag(),data]));};
|
|
await legacy('one','First.User');await legacy('two','first.user');
|
|
await assert.rejects(vault.migrateAccounts(['one','two']),e=>e.status===409);
|
|
assert.equal((await fs.stat(vault.filename('account:one'))).isFile(),true);assert.equal((await fs.stat(vault.filename('account:two'))).isFile(),true);
|
|
assert.deepEqual(await vault.accountAvailability('other','FIRST.USER'),{available:true},'failed batch must not partially claim the account');
|
|
await legacy('two','Second.User');await vault.migrateAccounts(['one','two']);
|
|
assert.equal((await vault.read('account:one')).nextAttemptAt,'2030-01-01T00:00:00Z');assert.equal((await vault.read('account:two')).password,'legacy-secret');
|
|
await assert.rejects(fs.stat(vault.filename('account:one')),e=>e.code==='ENOENT');
|
|
assert.deepEqual(await vault.accountAvailability('third','second.user'),{available:false});
|
|
});
|
|
|
|
test('vault encrypts state, survives restart, rejects corruption and keeps connection isolation', async t => {
|
|
const { BpmVault } = require('../../src/platform/security/vault.cjs');
|
|
const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'bpm-vault-'));
|
|
const vault = new BpmVault({ stateDir: dir });
|
|
t.after(async()=>{vault.destroy();await fs.rm(dir,{recursive:true,force:true});});
|
|
const state = { cookies: [{ name: 'session', value: 'private-cookie-value' }], sessionStorage: { 'https://bpm.example': { account: 'secret-user' } } };
|
|
await vault.write('connection-a', state);
|
|
const restored=new BpmVault({stateDir:dir});try{assert.deepEqual(await restored.read('connection-a'),state);}finally{restored.destroy();}
|
|
assert.equal(await vault.read('connection-b'), null);
|
|
const encrypted=Buffer.from(vault.accounts().prepare('SELECT payload FROM sessions WHERE connection_id=?').get('connection-a').payload);
|
|
assert.equal(encrypted.includes(Buffer.from('private-cookie-value')), false);
|
|
assert.equal(encrypted.includes(Buffer.from('secret-user')), false);
|
|
encrypted[encrypted.length - 1] ^= 1;
|
|
vault.accounts().prepare('UPDATE sessions SET payload=? WHERE connection_id=?').run(encrypted,'connection-a');
|
|
await assert.rejects(vault.read('connection-a'), error => error.status === 503 && !error.message.includes('private-cookie'));
|
|
await vault.remove('connection-a');
|
|
assert.equal(await vault.read('connection-a'), null);
|
|
});
|
|
|
|
test('vault binds ciphertext to connection identity and never leaves plaintext temporary files', async t => {
|
|
const { BpmVault } = require('../../src/platform/security/vault.cjs');
|
|
const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'bpm-vault-'));
|
|
const vault = new BpmVault({ stateDir: dir });
|
|
t.after(async()=>{vault.destroy();await fs.rm(dir,{recursive:true,force:true});});
|
|
await vault.write('a', { secret: 'alpha' });
|
|
await vault.write('b', { secret: 'bravo' });
|
|
const encrypted=vault.accounts().prepare('SELECT payload FROM sessions WHERE connection_id=?').get('a').payload;
|
|
vault.accounts().prepare('UPDATE sessions SET payload=? WHERE connection_id=?').run(encrypted,'b');
|
|
await assert.rejects(vault.read('b'), error => error.status === 503);
|
|
assert.equal((await fs.readdir(dir)).some(file => file.endsWith('.tmp')), false);
|
|
});
|
|
|
|
test('legacy session ciphertext migrates, database state wins, and removal cannot restore a stale file',async t=>{
|
|
const {BpmVault}=require('../../src/platform/security/vault.cjs'),dir=await fs.mkdtemp(path.join(os.tmpdir(),'bpm-legacy-session-')),vault=new BpmVault({stateDir:dir});
|
|
t.after(async()=>{vault.destroy();await fs.rm(dir,{recursive:true,force:true});});
|
|
const old={storageState:{cookies:[]},sessionStorage:{portal:{token:'legacy-private-token'}}};
|
|
await fs.writeFile(vault.filename('legacy'),vault.encode('legacy',old));
|
|
assert.deepEqual(await vault.read('legacy'),old);await assert.rejects(fs.stat(vault.filename('legacy')),e=>e.code==='ENOENT');
|
|
const restarted=new BpmVault({stateDir:dir});try{assert.deepEqual(await restarted.read('legacy'),old);}finally{restarted.destroy();}
|
|
const current={storageState:{cookies:[]},sessionStorage:{portal:{token:'current-private-token'}}};await vault.write('legacy',current);
|
|
await fs.writeFile(vault.filename('legacy'),vault.encode('legacy',old));assert.deepEqual(await vault.read('legacy'),current);
|
|
await vault.remove('legacy');assert.equal(await vault.read('legacy'),null);await assert.rejects(fs.stat(vault.filename('legacy')),e=>e.code==='ENOENT');
|
|
await fs.writeFile(vault.filename('broken'),Buffer.from('corrupted legacy ciphertext'));await assert.rejects(vault.read('broken'),e=>e.status===503);assert.equal(vault.accounts().prepare('SELECT count(*) AS n FROM sessions WHERE connection_id=?').get('broken').n,0);assert.equal((await fs.stat(vault.filename('broken'))).isFile(),true);
|
|
});
|