LibreChat/api/server/routes/auth.cloudfront.test.js
Danny Avila 9cf33cc8be
🧿 fix: Bind Login Flows to the Browser That Started Them (#15880)
* 🧿 fix: Bind Login Flows to the Browser That Started Them

Social OAuth logins (Google, Facebook, GitHub, Discord, Apple) now store a random state in an HttpOnly cookie scoped to the callback path and only exchange the returned code when the callback carries that state. Apple's form_post callback uses a SameSite=None cookie, and passport-apple's own fixed state no longer bypasses the store.

Local login, temp-token 2FA verification and admin local login reject requests a browser sent from another origin (Sec-Fetch-Site, falling back to Origin vs Host), trusting DOMAIN_CLIENT and DOMAIN_SERVER. Requests without browser fetch metadata, such as server-side callers, pass unchanged.

The sessionless OAuth callbacks drop failureMessage, which wrote to req.session and turned any rejected callback into a 500.

* 🧿 fix: Configure Login State Cookies and Localize Origin Rejections

- OAuth state cookies take secureCookie and maxAgeMs from the caller; registration.oauthStateTtlMs in librechat.yaml sets the lifetime (default 10 minutes).
- Secure deployments use a __Host- cookie at Path=/ so a sibling subdomain cannot plant a state.
- The cookie keeps up to three pending states, so logins started in separate tabs all complete, and an unmatched callback no longer discards them.
- passport-apple's preset state is dropped by deferStateToStore in packages/api.
- The Origin fallback compares scheme and host against the request itself.
- The same-origin rejection carries ErrorTypes.AUTH_CROSS_ORIGIN, which the login and 2FA screens show as a localized message.

* 🧿 refactor: Sign Login State Against a Per-Browser Binding

- The OAuth state store keeps a random per-browser binding in a __Host- cookie (reused across flows) and signs each state as issuedAt.nonce.HMAC(JWT_SECRET, provider, binding, issuedAt, nonce). Nothing is stored per flow, so any number of tabs complete, each state expires on its own clock, and concurrent starts no longer overwrite each other.
- The experimental server entrypoint passes its app config to configureSocialLogins.
- The same-origin guard also trusts an explicitly configured ADMIN_PANEL_URL.

* 🧿 fix: Keep Separate Bindings for Racing First Logins

A browser without a login-state binding now gets one under a cookie name with a random suffix, so two tabs that start their first login at once each keep their own binding. Later starts reuse an existing binding, and a callback is accepted when its state was signed for any binding the browser presents.

* 🧿 fix: Sanitize Request-Derived Values in the Cross-Site Rejection Log

The same-origin guard logged the request Origin and path verbatim. A non-browser client fully controls the Origin header, and the console transport uses a printf format that does not escape control characters, so a crafted value could forge log lines. Strip ASCII control characters (CR, LF, NUL and the rest) before logging, matching the pattern apiNotFound already uses.
2026-09-13 11:47:29 -04:00

159 lines
4.9 KiB
JavaScript

const express = require('express');
const request = require('supertest');
const mockForceRefreshCloudFrontAuthCookies = jest.fn();
jest.mock('@librechat/api', () => ({
createSetBalanceConfig: jest.fn(() => (req, res, next) => next()),
forceRefreshCloudFrontAuthCookies: (...args) => mockForceRefreshCloudFrontAuthCookies(...args),
}));
jest.mock('~/server/controllers/AuthController', () => ({
refreshController: jest.fn((req, res) => res.status(200).end()),
registrationController: jest.fn((req, res) => res.status(200).end()),
resetPasswordController: jest.fn((req, res) => res.status(200).end()),
resetPasswordRequestController: jest.fn((req, res) => res.status(200).end()),
graphTokenController: jest.fn((req, res) => res.status(200).end()),
}));
jest.mock('~/server/controllers/TwoFactorController', () => ({
enable2FA: jest.fn((req, res) => res.status(200).end()),
verify2FA: jest.fn((req, res) => res.status(200).end()),
confirm2FA: jest.fn((req, res) => res.status(200).end()),
disable2FA: jest.fn((req, res) => res.status(200).end()),
regenerateBackupCodes: jest.fn((req, res) => res.status(200).end()),
}));
jest.mock('~/server/controllers/auth/TwoFactorAuthController', () => ({
verify2FAWithTempToken: jest.fn((req, res) => res.status(200).end()),
}));
jest.mock('~/server/controllers/auth/LogoutController', () => ({
logoutController: jest.fn((req, res) => res.status(200).end()),
}));
jest.mock('~/server/controllers/auth/LoginController', () => ({
loginController: jest.fn((req, res) => res.status(200).end()),
}));
jest.mock('~/models', () => ({
findBalanceByUser: jest.fn(),
upsertBalanceFields: jest.fn(),
}));
jest.mock('~/server/services/Config', () => ({
getAppConfig: jest.fn(),
}));
jest.mock('~/server/middleware', () => {
const pass = (req, res, next) => next();
return {
logHeaders: pass,
requireSameOrigin: pass,
loginLimiter: pass,
setTwoFactorTempUser: pass,
twoFactorTempLimiter: pass,
checkBan: pass,
validateEmailLogin: pass,
requireLocalAuth: pass,
requireLdapAuth: pass,
registerLimiter: pass,
checkInviteUser: pass,
validateRegistration: pass,
resetPasswordLimiter: pass,
resetPasswordSubmissionLimiter: pass,
validatePasswordReset: pass,
requireJwtAuth: jest.fn((req, res, next) => {
if (req.headers.authorization !== 'Bearer ok') {
return res.status(401).json({ message: 'Unauthorized' });
}
req.user = { _id: 'user123', tenantId: 'tenantA' };
if (req.headers['x-cloudfront-warmed'] === 'true') {
req.cloudFrontAuthCookieRefreshResult = {
enabled: true,
attempted: true,
refreshed: true,
expiresInSec: 1800,
refreshAfterSec: 1500,
};
}
return next();
}),
};
});
const authRouter = require('./auth');
describe('POST /api/auth/cloudfront/refresh', () => {
let app;
beforeEach(() => {
jest.clearAllMocks();
app = express();
app.use(express.json());
app.use('/api/auth', authRouter);
});
it('requires authentication', async () => {
await request(app).post('/api/auth/cloudfront/refresh').expect(401);
expect(mockForceRefreshCloudFrontAuthCookies).not.toHaveBeenCalled();
});
it('returns 404 when CloudFront cookie mode is disabled', async () => {
mockForceRefreshCloudFrontAuthCookies.mockReturnValue({
enabled: false,
attempted: false,
refreshed: false,
reason: 'cloudfront_disabled',
});
const response = await request(app)
.post('/api/auth/cloudfront/refresh')
.set('Authorization', 'Bearer ok')
.expect(404);
expect(response.status).toBe(404);
});
it('returns cookie refresh timing when CloudFront cookies are refreshed', async () => {
mockForceRefreshCloudFrontAuthCookies.mockReturnValue({
enabled: true,
attempted: true,
refreshed: true,
expiresInSec: 1800,
refreshAfterSec: 1500,
});
const response = await request(app)
.post('/api/auth/cloudfront/refresh')
.set('Authorization', 'Bearer ok')
.expect(200);
expect(response.body).toEqual({
ok: true,
expiresInSec: 1800,
refreshAfterSec: 1500,
});
expect(mockForceRefreshCloudFrontAuthCookies).toHaveBeenCalledWith(
expect.objectContaining({ user: { _id: 'user123', tenantId: 'tenantA' } }),
expect.any(Object),
{ _id: 'user123', tenantId: 'tenantA' },
);
});
it('reuses the auth middleware refresh result instead of minting cookies twice', async () => {
const response = await request(app)
.post('/api/auth/cloudfront/refresh')
.set('Authorization', 'Bearer ok')
.set('x-cloudfront-warmed', 'true')
.expect(200);
expect(response.body).toEqual({
ok: true,
expiresInSec: 1800,
refreshAfterSec: 1500,
});
expect(mockForceRefreshCloudFrontAuthCookies).not.toHaveBeenCalled();
});
});