前端能收到登录接口的成功响应,下一次请求却仍然未登录,这类问题往往不是单个响应头写错,而是把浏览器的来源隔离、Cookie 的发送条件和服务端的请求授权混成了一件事。本文用一个只有两个服务端口的小实验,把匿名会话、登录、修改资料、退出串起来,再主动制造失败请求,检查每层防线是否真的发挥作用。
这里实现的是用于理解协议的本地实验,不是可以直接上线的账号系统。接口只监听回环地址,演示口令从环境变量读取,用户只有一个,资料仅保存在会话内存中。文章会分别说明已经执行的服务端检查,以及仍需要浏览器验收的部分,避免把命令行请求成功误认为跨域登录已经完整通过。
一、先画清边界:跨源不等于跨站
实验页面位于 http://127.0.0.1:3000,接口位于 http://127.0.0.1:4000。端口不同,所以这是跨源请求;两者使用同一协议和主机,因此本实验没有模拟不同可注册域之间的跨站登录。选择这个范围有实际价值:前后端独立开发服务器经常就处于这样的部署关系,我们可以先验证来源授权和会话生命周期,不必把第三方 Cookie 限制同时引入。
需要特别注意,Cookie 不按端口隔离。实验主机上其他端口的服务也属于需要考虑的信任范围,因此不要在共享主机上把这份示例当成隔离良好的生产认证服务。生产环境通常应让接口使用独立主机名,并将 Cookie 限定为仅由该主机接收,而不是为了省事把父域及所有子域一起纳入凭证范围。
浏览器跨源读取响应由 CORS 规则参与控制;Cookie 是否保存、是否随请求发送,还要满足凭证模式及 Cookie 自身属性。前端在每次调用中显式设置 credentials: 'include',服务端只给固定页面来源返回授权,不使用通配符。对于带凭证的请求,允许来源需要是具体值。普通表单形式的请求可能在没有预检的情况下到达服务端,因此不能只靠“浏览器读不到响应”判断修改操作安全。MDN 的 CORS 文档解释了这些差异。
本实验使用同步令牌方案:服务端为会话保存随机令牌,前端通过会话接口拿到令牌,再放入修改请求的自定义头中。登录前也先创建匿名会话,并让登录接口接受相同校验。这样不是只保护登录后的资料修改,也覆盖了把用户浏览器登录到错误账号的风险入口。具体实现同时检查固定 Origin、会话、令牌和正文格式;这些条件在服务端全部满足后才允许修改状态。
二、项目结构和明确的运行条件
实验实际运行版本为 Node.js v24.22.1,使用内置 HTTP、加密、文件读取及断言模块,不安装第三方包。这里不声称该补丁版本是当前最新版本;正式环境应使用仍受支持并及时修补的版本。建一个空目录,按下面的代码保存三个文件:server.mjs、index.html、test.mjs。后端和页面服务由同一个进程启动,避免读者额外配置打包器。
我们的路由契约很小:读取会话返回当前用户和令牌;登录成功更换会话标识及令牌;保存资料需要已登录用户;退出销毁服务端会话并清除 Cookie。任何业务写操作都使用提交方法,读接口不修改用户资料。会话读取在首次访问时分配匿名状态,因此它也消耗服务端容量,不能把它当成毫无成本的静态资源。
三、后端:校验顺序要能解释每一个失败
以下是完整 server.mjs。代码把来源检查放在会话分配之前,避免不可信来源轻易创建状态;预检只检查来源、请求方法和请求头名单,不要求已有会话。真正的业务请求仍重新校验所有条件,不能因为预检曾经成功就直接执行。底层 HTTP 模块不会代替应用解析业务正文,这也是示例显式限制大小并解析 JSON 的原因。Node.js HTTP 官方文档说明了该模块的低层定位。
import http from 'node:http';
import { randomBytes, timingSafeEqual } from 'node:crypto';
import { readFile } from 'node:fs/promises';
const ORIGIN = 'http://127.0.0.1:3000';
const TTL = 15 * 60 * 1000;
const sessions = new Map();
const password = process.env.DEMO_PASSWORD;
if (!password) throw new Error('Set DEMO_PASSWORD before starting');
const random = () => randomBytes(32).toString('hex');
const error = (status, message) => Object.assign(new Error(message), { status });
const send = (res, status, data) => {
res.writeHead(status, { 'Content-Type': 'application/json; charset=utf-8' });
res.end(JSON.stringify(data));
};
function session(req) {
const ids = (req.headers.cookie ?? '').split(';').map(x => x.trim())
.filter(x => x.startsWith('demo_sid=')).map(x => x.slice(9));
if (ids.length !== 1 || !/^[a-f0-9]{64}$/.test(ids[0])) return null;
const value = sessions.get(ids[0]);
if (!value || value.expires <= Date.now()) {
sessions.delete(ids[0]);
return null;
}
return { id: ids[0], value };
}
function issue(res, user = null) {
if (sessions.size >= 1000) throw error(503, 'session capacity');
const id = random();
const value = { csrf: random(), user, name: 'Demo', expires: Date.now() + TTL };
sessions.set(id, value);
res.setHeader('Set-Cookie', `demo_sid=${id}; HttpOnly; SameSite=Lax; Path=/; Max-Age=900`);
return { id, value };
}
function verify(req, current) {
if (!current) throw error(401, 'session required');
const token = req.headers['x-csrf-token'];
if (typeof token !== 'string' || !/^[a-f0-9]{64}$/.test(token) ||
!timingSafeEqual(Buffer.from(token), Buffer.from(current.value.csrf))) {
throw error(403, 'csrf rejected');
}
}
function body(req) {
if (req.headers['content-type']?.split(';')[0].trim() !== 'application/json') {
req.resume();
return Promise.reject(error(415, 'JSON required'));
}
return new Promise((resolve, reject) => {
let size = 0, chunks = [], exceeded = false;
req.on('data', chunk => {
size += chunk.length;
if (size > 4096) {
if (!exceeded) { exceeded = true; chunks = []; reject(error(413, 'body too large')); }
} else if (!exceeded) chunks.push(chunk);
});
req.on('end', () => {
if (exceeded) return;
try { resolve(JSON.parse(Buffer.concat(chunks).toString('utf8'))); }
catch { reject(error(400, 'invalid JSON')); }
});
req.on('error', reject);
req.on('aborted', () => reject(error(400, 'request aborted')));
});
}
const api = http.createServer(async (req, res) => {
res.setHeader('Cache-Control', 'no-store');
res.setHeader('Vary', 'Origin');
const origin = req.headers.origin;
if (origin !== ORIGIN) { req.resume(); return send(res, 403, { error: 'origin rejected' }); }
res.setHeader('Access-Control-Allow-Origin', ORIGIN);
res.setHeader('Access-Control-Allow-Credentials', 'true');
if (req.method === 'OPTIONS') {
const method = req.headers['access-control-request-method'];
const headers = String(req.headers['access-control-request-headers'] ?? '')
.toLowerCase().split(',').map(x => x.trim()).filter(Boolean);
if (!['GET', 'POST'].includes(method) ||
headers.some(x => !['content-type', 'x-csrf-token'].includes(x))) {
return send(res, 403, { error: 'preflight rejected' });
}
res.setHeader('Access-Control-Allow-Methods', 'GET, POST');
res.setHeader('Access-Control-Allow-Headers', 'Content-Type, X-CSRF-Token');
res.writeHead(204); return res.end();
}
try {
let current = session(req);
if (req.method === 'GET' && req.url === '/session') {
current ??= issue(res);
return send(res, 200, { csrf: current.value.csrf, user: current.value.user,
name: current.value.name });
}
if (req.method !== 'POST' || !['/login', '/profile', '/logout'].includes(req.url)) {
req.resume(); return send(res, 404, { error: 'not found' });
}
verify(req, current);
const data = await body(req);
if (!data || typeof data !== 'object' || Array.isArray(data)) throw error(400, 'object required');
if (req.url === '/login') {
if (data.username !== 'demo' || data.password !== password) throw error(401, 'bad credentials');
sessions.delete(current.id);
current = issue(res, 'demo');
return send(res, 200, { csrf: current.value.csrf, user: 'demo' });
}
if (!current.value.user) throw error(401, 'login required');
if (req.url === '/logout') {
sessions.delete(current.id);
res.setHeader('Set-Cookie', 'demo_sid=; HttpOnly; SameSite=Lax; Path=/; Max-Age=0');
return send(res, 200, { ok: true });
}
if (typeof data.name !== 'string' || !data.name.trim() || data.name.length > 80) {
throw error(400, 'invalid name');
}
current.value.name = data.name.trim();
send(res, 200, { name: current.value.name });
} catch (e) {
req.resume();
if (!res.destroyed && !res.headersSent) send(res, e.status ?? 500, { error: e.status ? e.message : 'internal error' });
}
});
api.requestTimeout = 10_000;
api.headersTimeout = 5_000;
api.listen(4000, '127.0.0.1');
setInterval(() => {
for (const [id, value] of sessions) if (value.expires <= Date.now()) sessions.delete(id);
}, 60_000).unref();
const html = await readFile(new URL('./index.html', import.meta.url));
http.createServer((req, res) => {
res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8', 'Cache-Control': 'no-store' });
res.end(html);
}).listen(3000, '127.0.0.1');
console.log('UI http://127.0.0.1:3000; API http://127.0.0.1:4000');
这个校验顺序有两个容易忽略的细节。第一,缺少 Origin 也被拒绝,这是为这个仅供固定浏览器页面调用的接口制定的严格策略,不是所有接口都必须如此。服务间调用、原生客户端和命令行工具应该有自己的认证协议;不要为了让它们方便调用,就把浏览器接口的缺失来源分支默认为可信。攻击者自己运行的客户端可以伪造 Origin,因此它不能替代身份认证。
第二,预检请求通常不携带应用会话凭证。如果把登录校验放在预检之前,浏览器会卡在“询问是否允许”的阶段,真正的业务请求根本不会发出。这里预检允许的方法只是协议层名单,具体路径仍由业务路由处理,所以一个不存在的路径可能预检成功,实际请求却得到找不到路由,这不构成授权绕过。
会话标识与防伪令牌各自生成三十二字节随机值,使用十六进制编码。收到令牌时先检查格式和长度,再进行等长比较,避免比较函数因输入长度不同直接抛异常。Cookie 解析拒绝同名重复项,减少路径或其他服务设置同名 Cookie 时产生的解释歧义。它不是完整的通用 Cookie 解析器,只覆盖本示例自己生成的固定格式,换成框架后应采用维护良好的会话中间件。
登录成功时,旧会话从存储删除,新的会话标识与令牌一起生成。前端必须采用登录响应返回的新令牌,否则下一次保存会被拒绝。这个细节比“登录时设置一个 Cookie”更值得测试:如果标识始终不变,匿名阶段取得的状态会被直接升级;如果只换标识不换前端令牌,又可能让用户看到持续的禁止访问。退出也必须同时处理服务端记录和浏览器 Cookie,单纯清空页面变量不足以撤销凭证。
四、前端:凭证交给浏览器,令牌留在内存
把下面内容保存为 index.html。页面没有框架依赖,结果使用文本内容输出,不把用户输入拼成 HTML。按钮在请求期间禁用,降低同一页面并发登录、保存和退出导致状态交错的机会;这只能改善界面行为,不能作为服务端并发控制。多个标签页仍然共享 Cookie,某个标签页重新登录后,其他标签页的旧令牌应当失败并要求刷新会话。
<!doctype html><meta charset="utf-8"><title>Cookie session lab</title>
<label>演示口令 <input id="password" type="password" autocomplete="off"></label>
<button id="login">登录</button>
<label>显示名称 <input id="name" value="新的名字" maxlength="80"></label>
<button id="save">保存</button><button id="logout">退出</button>
<pre id="output"></pre>
<script type="module">
let csrf;
const output = document.querySelector('#output');
const buttons = [...document.querySelectorAll('button')];
async function api(path, data) {
const res = await fetch('http://127.0.0.1:4000' + path, {
credentials: 'include', method: data ? 'POST' : 'GET',
headers: data ? { 'Content-Type': 'application/json', 'X-CSRF-Token': csrf } : {},
body: data ? JSON.stringify(data) : undefined
});
const json = await res.json();
if (!res.ok) throw new Error(`${res.status}: ${json.error}`);
if (json.csrf) csrf = json.csrf;
return json;
}
async function run(work) {
buttons.forEach(b => b.disabled = true);
try { output.textContent = JSON.stringify(await work(), null, 2); }
catch (e) { output.textContent = e.message + ';会话失效时刷新页面后重新登录。'; }
finally { buttons.forEach(b => b.disabled = false); }
}
document.querySelector('#login').onclick = () => run(() => api('/login', {
username: 'demo', password: document.querySelector('#password').value
}));
document.querySelector('#save').onclick = () => run(() => api('/profile', {
name: document.querySelector('#name').value
}));
document.querySelector('#logout').onclick = () => run(async () => {
await api('/logout', {}); csrf = undefined; return api('/session');
});
run(() => api('/session'));
</script>
浏览器脚本不需要读取会话 Cookie,也不应尝试从响应头中提取 Set-Cookie。会话 Cookie 标记为 HttpOnly,页面只持有用于请求校验的令牌。前端保存令牌在当前页面内存,刷新后重新获取,避免把多份长期副本散落在本地存储里。HttpOnly 并不阻止页面脚本发出携带 Cookie 的请求;如果可信页面存在脚本注入,攻击者仍可能利用页面权限读令牌和执行操作,所以这套机制不能代替输入输出安全处理。OWASP 的 CSRF 防护指南强调了这类防护与脚本注入之间的关系。
示例的 Cookie 使用显式 SameSite=Lax、根路径和十五分钟有效期,没有配置 Domain。因为它只服务本地明文实验,代码没有设置 Secure,也没有使用要求安全传输的前缀。正式 HTTPS 部署应另行配置 Secure,通常采用带 __Host- 前缀、根路径且无 Domain 的主机限定 Cookie。不要把实验中的明文设置照搬到公网。真正跨站的嵌入或登录方案即使设置 SameSite=None; Secure,也仍可能受到浏览器第三方 Cookie 策略限制,不能承诺仅靠响应头就兼容所有浏览器。MDN 的 Set-Cookie 文档列出了属性及前缀约束。
五、启动实验,再区分自动验证与浏览器验证
先在终端进入三个文件所在的目录,再执行以下命令。演示口令只用于本地实验,不要使用真实账号密码。页面输入框中填写同一个演示口令,默认用户名已经固定为 demo。
node --version
DEMO_PASSWORD=local-lab-only node server.mjs
保持该终端运行,在浏览器打开 http://127.0.0.1:3000。不要换成 localhost,也不要双击 HTML 文件打开,因为页面来源必须与服务端白名单逐字匹配。正确顺序是先等待匿名会话返回,再登录,修改显示名称,最后退出。刷新页面应重新读取当前会话;进程重启后会话丢失,这是内存实现的预期结果,并非持久化故障。
下面的 test.mjs 可以在另一终端通过 node test.mjs 执行。它显式传入 Origin 和 Cookie,并手工接收登录响应的 Cookie。这样既能检查后端分支,也清楚地暴露测试边界:Node 的 fetch 不承担浏览器的同源策略,不会替我们证明浏览器接受了 Cookie,更不会自动模拟第三方 Cookie 拦截。
import assert from 'node:assert/strict';
const base = 'http://127.0.0.1:4000';
const origin = 'http://127.0.0.1:3000';
let cookie = '', csrf = '', passed = 0;
async function call(path, { method = 'GET', headers = {}, data } = {}) {
const r = await fetch(base + path, { method, headers: {
Origin: origin, Cookie: cookie, ...headers
}, body: data === undefined ? undefined : typeof data === 'string' ? data : JSON.stringify(data) });
return r;
}
async function expect(label, response, status) {
assert.equal(response.status, status, label); await response.arrayBuffer();
console.log('PASS', ++passed, label);
}
const initial = await call('/session');
assert.equal(initial.status, 200);
assert.equal(initial.headers.get('access-control-allow-origin'), origin);
assert.equal(initial.headers.get('access-control-allow-credentials'), 'true');
cookie = initial.headers.get('set-cookie').split(';')[0];
csrf = (await initial.json()).csrf;
console.log('PASS', ++passed, 'session and CORS headers');
await expect('allowed preflight', await call('/profile', {method:'OPTIONS', headers:{'Access-Control-Request-Method':'POST','Access-Control-Request-Headers':'content-type,x-csrf-token'}}), 204);
await expect('denied preflight', await call('/profile', {method:'OPTIONS', headers:{'Access-Control-Request-Method':'DELETE'}}), 403);
await expect('bad origin', await call('/session', {headers:{Origin:'http://127.0.0.1:3001'}}), 403);
const headers = () => ({'Content-Type':'application/json','X-CSRF-Token':csrf});
await expect('anonymous save', await call('/profile',{method:'POST',headers:headers(),data:{name:'no'}}),401);
await expect('wrong password', await call('/login',{method:'POST',headers:headers(),data:{username:'demo',password:'wrong'}}),401);
const oldCookie = cookie, oldCsrf = csrf;
const login = await call('/login',{method:'POST',headers:headers(),data:{username:'demo',password:'local-lab-only'}});
assert.equal(login.status,200); cookie = login.headers.get('set-cookie').split(';')[0]; csrf=(await login.json()).csrf;
assert.notEqual(cookie,oldCookie); assert.notEqual(csrf,oldCsrf); console.log('PASS',++passed,'login rotates session and token');
await expect('old session rejected',await call('/profile',{method:'POST',headers:{...headers(),Cookie:oldCookie,'X-CSRF-Token':oldCsrf},data:{name:'no'}}),401);
await expect('missing token',await call('/profile',{method:'POST',headers:{'Content-Type':'application/json'},data:{name:'no'}}),403);
await expect('stale token',await call('/profile',{method:'POST',headers:{...headers(),'X-CSRF-Token':oldCsrf},data:{name:'no'}}),403);
await expect('wrong content type',await call('/profile',{method:'POST',headers:{...headers(),'Content-Type':'text/plain'},data:{name:'no'}}),415);
await expect('malformed JSON',await call('/profile',{method:'POST',headers:headers(),data:'{'}),400);
await expect('oversize body',await call('/profile',{method:'POST',headers:headers(),data:{name:'x'.repeat(5000)}}),413);
await expect('invalid name',await call('/profile',{method:'POST',headers:headers(),data:{name:''}}),400);
const save=await call('/profile',{method:'POST',headers:headers(),data:{name:'已保存'}}); assert.equal(save.status,200);assert.equal((await save.json()).name,'已保存');console.log('PASS',++passed,'valid profile save');
await expect('logout',await call('/logout',{method:'POST',headers:headers(),data:{}}),200);
await expect('logged out cookie rejected',await call('/profile',{method:'POST',headers:headers(),data:{name:'no'}}),401);
console.log(`${passed} checks passed; Node transport tests, not browser policy tests`);
本次在 Node.js v24.22.1 下实际执行了上述集成脚本,十七项检查全部通过,末行输出为 17 checks passed; Node transport tests, not browser policy tests。检查包括匿名会话及授权响应头、合法和非法预检、不可信来源、匿名保存、错误口令、登录轮换、旧会话撤销、缺失与过期令牌、错误内容类型、损坏 JSON、超大正文、非法名称、正常保存、退出以及退出后的凭证拒绝。
运行过程中,最初把服务启动和测试拆到不同的执行会话,测试得到连接拒绝;随后在同一终端生命周期中启动服务并执行测试,得到以上通过结果。这说明首先要排除服务是否真的存活,再讨论 CORS。连接拒绝不是浏览器跨源拦截,也不说明认证逻辑有问题。该失败没有被算作安全用例通过。
本次没有实际运行浏览器自动化,也没有执行生产 HTTPS、跨站域名、反向代理和多实例环境验收。读者本地验收时,应打开网络面板确认登录提交之前出现预检,并确认预检不需要会话;随后查看实际提交是否携带 Cookie 和令牌。Cookie 应从浏览器存储面板观察,而不是在页面脚本里读取。禁用凭证模式后,即使读接口返回了匿名令牌,后续请求也不会按本实验预期保留跨源会话,这应成为一个单独的失败演练。
再把页面从不同端口打开,观察来源拒绝;删除令牌头后提交,应该得到禁止访问;改为普通文本内容类型,应该得到格式拒绝;退出后重放旧 Cookie,应该得到需要会话。对于被 CORS 隐藏的错误,前端可能只能看见网络异常,服务端日志和开发者工具中的请求记录才是定位依据。不要为了让界面显示具体错误而把任意 Origin 原样放入允许来源。
六、上线前补齐认证、存储和资源预算
示例把一个演示口令与环境变量直接比较,没有账号数据库、口令散列、登录速率限制、设备管理或二次认证。它展示的是浏览器会话周边的请求边界,不是身份核验方案。正式项目应接入现成的认证系统,在认证成功后才建立业务会话,并针对每个资源检查用户是否有权修改。即使请求带着正确令牌,也不意味着这个用户拥有其他人的资料或管理员权限。
内存 Map 的另一限制是只能在单进程内工作。部署多个副本后,请求可能落到没有该会话的实例,造成间歇性失效。生产需要共享会话存储或者经过完整设计的其他会话机制,并定义退出撤销、空闲过期和绝对过期。这里采用固定十五分钟过期,不会因访问自动续期;清理定时器只是回收资源,真正的有效期检查在每次读取会话时执行,所以清理延迟不会让已过期凭证继续有效。
我们为正文设置四千零九十六字节上限,为会话数量设置一千条上限,并配置请求及请求头超时。这些数值服务于小实验,不是经过容量测试得出的生产建议。正文超限后代码不再保留数据块,但连接仍可能继续占用带宽和处理时间;公网网关还要限制连接数、请求速率和总流量。匿名会话接口同样需要预算,不可信客户端可以伪造来源并重复申请会话,因此来源检查不能承担抗滥用职责。
所有会话响应都设置禁止缓存,避免令牌和用户信息进入共享缓存。正式网关也应确认没有覆盖这些策略,并避免把 Cookie、令牌、口令和完整正文写入日志。日志应保留请求标识、路由、状态码与拒绝原因类别,让团队能区分来源错误、会话失效、令牌不匹配与业务校验失败;记录秘密本身不会使排查更可靠,反而扩大泄露面。
最后要检查请求结果未知的情况。如果保存已在服务端完成,但响应因网络中断没有到达页面,页面不能断言“肯定没保存”,更不应把所有错误统一解释为未登录。本实验只是把显示名称赋为目标值,重复保存同样的值通常不会额外产生副作用;若将示例改成支付、扣库存或发送通知,就必须另行设计业务幂等和结果查询,不能仅复制这里的重试行为。
七、用失败路径判断方案是否完整
一个可维护的跨源会话方案应当能回答四个问题:浏览器什么时候会发送凭证,服务端如何判断来源,修改操作怎样绑定到当前会话的意图,以及会话何时被撤销。本文的可运行代码让这些规则都落在明确分支上,自动检查则证明正常路径和若干拒绝路径确实执行过。
真正的验收还要把代码外的部分加回来:浏览器策略、可信域名、代理设置、共享存储、认证强度和用户权限。先在本地用最小实验辨清故障属于哪一层,再把同一组正常与失败用例迁移到实际部署环境,比在遇到错误时不断放宽允许来源或 Cookie 范围更容易得到可靠结果。
评论
暂无评论。