184 lines
18 KiB
JavaScript
184 lines
18 KiB
JavaScript
'use strict';
|
|
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');
|
|
const http=require('node:http');
|
|
const {BpmSessionManager}=require('../../src/modules/bpm/session-manager.cjs');
|
|
const {loadPlaywright,browserOptions}=require('../../src/platform/browser.cjs');
|
|
const principal={user:{username:'owner',role:'operator'},sessionId:'session-one'};
|
|
const connection={id:'account-test',owner:'owner',status:'disconnected'};
|
|
const credentials={username:'Fixture User',password:' Fixture-password-123 '};
|
|
const empty={configured:false,username:'',updatedAt:null};
|
|
test('account availability enforces scope and duplicate saves preserve old credentials and cookies',async t=>{
|
|
const {manager}=await fixture(t);const other={...connection,id:'other'};
|
|
await manager.saveAccount(connection,principal,credentials);
|
|
await manager.saveAccount(other,principal,{username:'different',password:'original-password'});
|
|
await manager.vault().write(other.id,{storageState:{cookies:[{name:'keep',value:'unchanged'}],origins:[]}});
|
|
assert.deepEqual(await manager.checkAccount(other,principal,{username:' fixture USER '}),{available:false});
|
|
await assert.rejects(manager.saveAccount(other,principal,{username:'fixture user',password:'replacement'}),e=>e.status===409&&e.code==='BPM_ACCOUNT_DUPLICATE');
|
|
assert.equal((await manager.account(other,principal)).username,'different');assert.ok(await manager.vault().read(other.id));
|
|
for(const user of [{username:'unrelated',role:'operator'},{username:'owner',role:'viewer'}])await assert.rejects(manager.checkAccount(other,{...principal,user},{username:'anything'}),e=>e.status===403);
|
|
for(const body of [null,{},[],{username:' '},{username:'x',password:'secret'}])await assert.rejects(manager.checkAccount(other,principal,body),e=>e.status===400);
|
|
});
|
|
async function fixture(t,{browser=false,known=true}={}){
|
|
const dir=await fs.mkdtemp(path.join(os.tmpdir(),'bpm-account-'));
|
|
const server=http.createServer((req,res)=>{
|
|
const type=req.url==='/malicious'?'text':'password';
|
|
const hidden=req.url==='/hidden'?'style="display:none"':'';
|
|
res.setHeader('content-type','text/html');
|
|
res.end(`<form onsubmit="event.preventDefault();window.submitted++"><input id="username" type="text"><input id="password" type="${type}" ${hidden}><button type="submit">Login</button><input id="captcha"></form><script>window.submitted=0</script>`);
|
|
});
|
|
await new Promise(resolve=>server.listen(0,'127.0.0.1',resolve));
|
|
const origin='http://127.0.0.1:'+server.address().port;
|
|
const options={stateDir:dir,urls:{main:origin+'/login'},allowedOrigins:[origin],...(known?{loginForms:{[origin]:{username:'#username',password:'#password'}}}:{})};
|
|
if(browser)options.browserFactory=async()=>loadPlaywright().chromium.launch(browserOptions());
|
|
else options.browserFactory=async()=>{throw new Error('browser must not launch for account CRUD');};
|
|
const manager=new BpmSessionManager(options);
|
|
const managers=[manager],make=()=>{const next=new BpmSessionManager(options);managers.push(next);return next;};
|
|
t.after(async()=>{for(const item of managers)await item.shutdown();server.closeAllConnections();await new Promise(resolve=>server.close(resolve));await fs.rm(dir,{recursive:true,force:true});});
|
|
return {manager,dir,options,origin,make};
|
|
}
|
|
test('account saves encrypted credentials without browser, returns safe metadata and survives restart',async t=>{
|
|
const {manager,dir,make}=await fixture(t);
|
|
assert.deepEqual(await manager.account(connection,principal),empty);
|
|
const saved=await manager.saveAccount(connection,principal,credentials);
|
|
assert.equal(saved.configured,true);assert.equal(saved.username,'Fixture User');assert.ok(Date.parse(saved.updatedAt));
|
|
assert.deepEqual(Object.keys(saved).sort(),['configured','updatedAt','username']);
|
|
assert.equal((await manager.vault().read('account:account-test')).password,credentials.password);
|
|
assert.equal(await manager.vault().read(connection.id),null);
|
|
for(const filename of await fs.readdir(dir))if(filename.endsWith('.enc')||filename.includes('.sqlite')){
|
|
const bytes=await fs.readFile(path.join(dir,filename));
|
|
assert.equal(bytes.includes(Buffer.from(credentials.username)),false);assert.equal(bytes.includes(Buffer.from(credentials.password)),false);
|
|
}
|
|
await manager.shutdown();const restarted=make();
|
|
assert.deepEqual(await restarted.account(connection,principal),saved);
|
|
assert.deepEqual(await restarted.clearAccount(connection,principal),empty);
|
|
assert.equal(await restarted.vault().read('account:account-test'),null);
|
|
});
|
|
test('account enforces owner and admin, strict payload bounds and disabled deletion',async t=>{
|
|
const {manager}=await fixture(t);
|
|
for(const user of [{username:'other',role:'operator'},{username:'owner',role:'viewer'}])for(const method of ['account','saveAccount','clearAccount','fillAccount'])await assert.rejects(manager[method](connection,{...principal,user},credentials),e=>e.status===403);
|
|
for(const body of [null,[],{}, {...credentials,extra:true},{...credentials,username:' '},{...credentials,username:'x'.repeat(151)},{...credentials,password:''},{...credentials,password:'x'.repeat(257)}])await assert.rejects(manager.saveAccount(connection,principal,body),e=>e.status===400);
|
|
const admin={...principal,user:{username:'admin',role:'admin'}};
|
|
await manager.saveAccount(connection,admin,credentials);assert.equal((await manager.account(connection,principal)).configured,true);
|
|
await manager.vault().write(connection.id,{storageState:{cookies:[],origins:[]}});
|
|
await manager.disable(connection.id);
|
|
assert.equal(await manager.vault().read(connection.id),null);assert.equal(await manager.vault().read('account:account-test'),null);
|
|
await assert.rejects(manager.account(connection,principal),e=>e.status===409);
|
|
});
|
|
test('saved account fills real known form on open and navigate without submission, captcha changes or field writeback',async t=>{
|
|
const {manager,make}=await fixture(t,{browser:true});
|
|
await manager.saveAccount(connection,principal,credentials);await manager.shutdown();
|
|
const restarted=make();
|
|
await restarted.open(connection,principal);const page=restarted.sessions.get(connection.id).page;
|
|
assert.equal(await page.locator('#username').inputValue(),credentials.username);assert.equal(await page.locator('#password').inputValue(),credentials.password);
|
|
assert.equal(await page.locator('#captcha').inputValue(),'');assert.equal(await page.evaluate(()=>window.submitted),0);
|
|
await page.locator('#password').fill('Browser edit');assert.equal((await restarted.vault().read('account:account-test')).password,credentials.password);
|
|
await restarted.navigate(connection.id,principal,{target:'main'});assert.equal(await page.locator('#password').inputValue(),credentials.password);
|
|
assert.equal((await restarted.fillAccount(connection,principal)).filled,true);
|
|
assert.equal(await page.evaluate(()=>window.submitted),0);
|
|
await assert.rejects(restarted.fillAccount(connection,{...principal,sessionId:'second-session'}),e=>e.status===409);
|
|
await restarted.clearAccount(connection,principal);const absent=await restarted.fillAccount(connection,principal);assert.equal(absent.filled,false);assert.match(absent.message,/托管|保存/);
|
|
});
|
|
test('unknown origins and unsafe or hidden form fields never receive any saved credentials',async t=>{
|
|
const unknown=await fixture(t,{browser:true,known:false});await unknown.manager.saveAccount(connection,principal,credentials);await unknown.manager.open(connection,principal);
|
|
const unknownPage=unknown.manager.sessions.get(connection.id).page;assert.equal(await unknownPage.locator('#username').inputValue(),'');assert.equal(await unknownPage.locator('#password').inputValue(),'');
|
|
assert.equal((await unknown.manager.fillAccount(connection,principal)).filled,false);assert.equal(await unknownPage.evaluate(()=>window.submitted),0);
|
|
const known=await fixture(t,{browser:true});await known.manager.saveAccount(connection,principal,credentials);await known.manager.open(connection,principal);const page=known.manager.sessions.get(connection.id).page;
|
|
for(const target of ['/malicious','/hidden']){await page.goto(known.origin+target);assert.equal((await known.manager.fillAccount(connection,principal)).filled,false);assert.equal(await page.locator('#username').inputValue(),'');assert.equal(await page.locator('#password').inputValue(),'');assert.equal(await page.evaluate(()=>window.submitted),0);}
|
|
await assert.rejects(known.manager.fillAccount({...connection,id:'unopened'},principal),e=>e.status===410);
|
|
});
|
|
|
|
test('saving a managed account invalidates previous authentication and refuses another dashboard lease',async t=>{
|
|
const {manager}=await fixture(t,{browser:true});
|
|
await manager.saveAccount(connection,principal,credentials);
|
|
await manager.vault().write(connection.id,{storageState:{cookies:[],origins:[]},sessionStorage:{old:'authentication'}});
|
|
await manager.open(connection,principal);
|
|
await manager.saveAccount(connection,principal,{...credentials,password:'Updated password'});
|
|
assert.ok(await manager.vault().read(connection.id));assert.equal(manager.sessions.has(connection.id),true);
|
|
await assert.rejects(manager.saveAccount(connection,{...principal,sessionId:'other-session'},{username:'New User',password:'New password'}),e=>e.status===409);
|
|
assert.equal((await manager.account(connection,principal)).username,credentials.username);
|
|
assert.ok(await manager.vault().read(connection.id));
|
|
await assert.rejects(manager.saveAccount(connection,principal,{username:'New User',password:''}),e=>e.status===400);
|
|
assert.ok(await manager.vault().read(connection.id));assert.equal(manager.sessions.has(connection.id),true);
|
|
await manager.saveAccount(connection,principal,{username:'New User',password:'New password'});
|
|
assert.equal(await manager.vault().read(connection.id),null);assert.equal(manager.sessions.has(connection.id),false);
|
|
assert.equal((await manager.account(connection,principal)).username,'New User');
|
|
});
|
|
|
|
async function automaticFixture(t,{challenge=false,wrong=false,unknown=false,unsafe=false,portalFailure=false,getSubmit=false}={}){
|
|
const dir=await fs.mkdtemp(path.join(os.tmpdir(),'bpm-automatic-'));let submissions=0,verificationMode='';
|
|
const server=http.createServer((req,res)=>{
|
|
res.setHeader('content-type','text/html');
|
|
if(req.url.startsWith('/authenticate') && req.method!=='POST'){submissions++;res.end('Unsafe GET submission');return;}
|
|
if(req.url==='/authenticate' && req.method==='POST'){
|
|
submissions++;let body='';req.on('data',chunk=>body+=chunk);req.on('end',()=>{
|
|
const params=new URLSearchParams(body);if(!wrong && params.get('username')===credentials.username && params.get('password')===credentials.password)res.setHeader('Set-Cookie','auth=valid; HttpOnly; Path=/');
|
|
res.writeHead(302,{Location:'/main'});res.end();
|
|
});return;
|
|
}
|
|
if((req.headers.cookie||'').includes('auth=valid'))res.end('<div id="identity">Fixture User</div>');
|
|
else res.end(`<form method="POST" action="/authenticate"><input id="username" name="username" type="text"><input id="password" name="password" type="${unsafe?'text':'password'}">${challenge?'<input id="otp" name="otp" type="text" placeholder="One time code">':''}<button id="kc-login" type="submit" ${getSubmit?'formmethod="GET"':''}>Sign In</button></form>`);
|
|
});
|
|
await new Promise(resolve=>server.listen(0,'127.0.0.1',resolve));const origin='http://127.0.0.1:'+server.address().port;
|
|
const options={stateDir:dir,urls:{main:origin+'/main'},allowedOrigins:[origin],...(!unknown?{loginForms:{[origin]:{username:'#username',password:'#password',submit:'#kc-login'}}}:{}),browserFactory:async()=>loadPlaywright().chromium.launch(browserOptions())};
|
|
// Avoid a locator timeout when no identity exists; positive evidence remains required.
|
|
options.probe=async(page,kind)=>{assert.equal(kind,'portal');if(portalFailure || verificationMode==='network')throw new Error('fixture connection interrupted');const marker=page.locator('#identity');return {ok:await marker.count()===1,identity:await marker.count()?await marker.textContent():''};};
|
|
const managers=[];const make=()=>{const manager=new BpmSessionManager(options);managers.push(manager);return manager;};
|
|
t.after(async()=>{for(const manager of managers)await manager.shutdown();server.closeAllConnections();await new Promise(resolve=>server.close(resolve));await fs.rm(dir,{recursive:true,force:true});});
|
|
return {manager:make(),make,origin,submissions:()=>submissions,setVerificationMode:mode=>verificationMode=mode};
|
|
}
|
|
test('automatic custody authenticates once, restores cookies after restart and renews expired authentication',async t=>{
|
|
const {manager,make,submissions}=await automaticFixture(t);
|
|
assert.equal(typeof manager.ensure,'function');await manager.saveAccount(connection,principal,credentials);
|
|
assert.equal((await manager.ensure(connection,principal)).status,'connected');assert.equal(submissions(),1);assert.equal(manager.sessions.size,0);assert.ok(await manager.vault().read(connection.id));
|
|
await manager.shutdown();const restarted=make();
|
|
assert.equal((await restarted.ensure(connection,principal)).status,'connected');assert.equal(submissions(),1);
|
|
await restarted.saveAccount(connection,principal,credentials);assert.equal((await restarted.ensure(connection,principal)).status,'connected');assert.equal(submissions(),1);
|
|
await restarted.vault().remove(connection.id);assert.equal((await restarted.ensure(connection,principal)).status,'connected');assert.equal(submissions(),2);
|
|
await restarted.clearAccount(connection,principal);await restarted.saveAccount(connection,principal,credentials);assert.equal((await restarted.ensure(connection,principal)).status,'connected');assert.equal(submissions(),2);
|
|
});
|
|
test('automatic custody defers CAPTCHA or unsafe and unknown forms without submitting',async t=>{
|
|
for(const options of [{challenge:true},{unknown:true},{unsafe:true}]){
|
|
const {manager,submissions}=await automaticFixture(t,options);assert.equal(typeof manager.ensure,'function');await manager.saveAccount(connection,principal,credentials);
|
|
const checked=await manager.ensure(connection,principal);assert.equal(checked.status,'login_required');assert.match(checked.checks.portal.message,/人工|验证|登录/);assert.equal(submissions(),0);assert.equal(manager.sessions.size,0);
|
|
}
|
|
});
|
|
test('failed automatic credentials use persisted cooldown and background ensure never takes over an active lease',async t=>{
|
|
const {manager,make,submissions}=await automaticFixture(t,{wrong:true});assert.equal(typeof manager.ensure,'function');await manager.saveAccount(connection,principal,credentials);
|
|
assert.equal((await manager.ensure(connection,principal)).status,'login_required');assert.equal(submissions(),1);
|
|
const cooldown=await manager.ensure(connection,principal);assert.equal(cooldown.status,'login_required');assert.match(cooldown.checks.portal.message,/稍后|更新|重试/);assert.equal(submissions(),1);
|
|
await manager.shutdown();const restarted=make();assert.equal((await restarted.ensure(connection,principal)).status,'login_required');assert.equal(submissions(),1);
|
|
await restarted.open(connection,principal);await assert.rejects(restarted.ensure(connection,{...principal,sessionId:'background'}),e=>e.status===409);assert.equal(restarted.sessions.size,1);assert.equal(submissions(),1);
|
|
});
|
|
test('portal network failure never triggers another credential submission',async t=>{
|
|
const {manager,submissions}=await automaticFixture(t,{portalFailure:true});await manager.saveAccount(connection,principal,credentials);
|
|
const checked=await manager.ensure(connection,principal);assert.equal(checked.status,'error');assert.equal(checked.checks.portal.ok,false);assert.deepEqual(Object.keys(checked.checks),['portal']);assert.equal(submissions(),0);
|
|
});
|
|
test('positive check persists refreshed authenticated cookies instead of discarding them',async t=>{
|
|
const {manager,origin,submissions}=await automaticFixture(t);await manager.saveAccount(connection,principal,credentials);await manager.ensure(connection,principal);
|
|
await manager.open(connection,principal);await manager.sessions.get(connection.id).context.addCookies([{name:'rotated',value:'refresh-value',url:origin}]);
|
|
assert.equal((await manager.check(connection,principal)).status,'connected');assert.equal(submissions(),1);
|
|
const state=await manager.vault().read(connection.id);assert.equal(state.storageState.cookies.find(cookie=>cookie.name==='rotated')?.value,'refresh-value');
|
|
});
|
|
test('a submit control cannot override POST and leak managed credentials into a GET URL',async t=>{
|
|
const {manager,submissions}=await automaticFixture(t,{getSubmit:true});await manager.saveAccount(connection,principal,credentials);
|
|
assert.equal((await manager.ensure(connection,principal)).status,'login_required');assert.equal(submissions(),0);
|
|
});
|
|
test('new portal authentication is sufficient for connected checks and cookie reuse across restart',async t=>{
|
|
const {manager,make,submissions}=await automaticFixture(t);await manager.saveAccount(connection,principal,credentials);
|
|
const checked=await manager.ensure(connection,principal);assert.equal(checked.status,'connected');assert.equal(checked.checks.portal.ok,true);assert.deepEqual(Object.keys(checked.checks),['portal']);assert.equal(submissions(),1);
|
|
assert.ok(await manager.vault().read(connection.id));
|
|
const account=await manager.vault().read('account:'+connection.id);account.nextAttemptAt='2020-01-01T00:00:00.000Z';await manager.vault().write('account:'+connection.id,account);
|
|
assert.equal((await manager.check(connection,principal)).status,'connected');assert.equal((await manager.ensure(connection,principal)).status,'connected');assert.equal(submissions(),1);
|
|
await manager.shutdown();const restarted=make();assert.equal((await restarted.ensure(connection,principal)).status,'connected');assert.equal(submissions(),1);
|
|
});
|
|
test('network uncertainty preserves the prior good encrypted snapshot without another login attempt',async t=>{
|
|
const {manager,submissions,setVerificationMode}=await automaticFixture(t);await manager.saveAccount(connection,principal,credentials);await manager.ensure(connection,principal);
|
|
const payload=()=>Buffer.from(manager.vault().accounts().prepare('SELECT payload FROM sessions WHERE connection_id=?').get(connection.id).payload),lastGood=payload();
|
|
setVerificationMode('network');const checked=await manager.ensure(connection,principal);assert.equal(checked.status,'error');assert.equal(checked.checks.portal.ok,false);
|
|
assert.deepEqual(payload(),lastGood);assert.equal(submissions(),1);
|
|
});
|