482 lines
19 KiB
TypeScript
482 lines
19 KiB
TypeScript
import { vi, describe, it, expect, beforeEach } from 'vitest';
|
||
import crypto from 'crypto';
|
||
|
||
const mockStorage = vi.hoisted(() => ({
|
||
getUserByEmail: vi.fn(),
|
||
getUserByEmailAndSlug: vi.fn(),
|
||
getUserWithOrganization: vi.fn(),
|
||
getUser: vi.fn(),
|
||
updateUser: vi.fn(),
|
||
createUserSession: vi.fn(),
|
||
getUserSessionByToken: vi.fn(),
|
||
getUserSessionByParentToken: vi.fn(),
|
||
getActiveSessionInFamily: vi.fn(),
|
||
rotateUserSession: vi.fn(),
|
||
markSessionReplaced: vi.fn(),
|
||
revokeSession: vi.fn(),
|
||
revokeSessionFamily: vi.fn(),
|
||
revokeAllUserSessions: vi.fn(),
|
||
getAppRolePermissions: vi.fn(),
|
||
getOrganization: vi.fn(),
|
||
getUserByResetPasswordToken: vi.fn(),
|
||
}));
|
||
|
||
const mockEmailService = vi.hoisted(() => ({
|
||
sendPasswordResetEmail: vi.fn().mockResolvedValue(undefined),
|
||
}));
|
||
|
||
vi.mock('../server/db', () => ({
|
||
db: {},
|
||
pool: { query: vi.fn().mockResolvedValue({ rows: [] }) },
|
||
withTenant: (_orgId: number, fn: () => unknown) => fn(),
|
||
withSuperAdmin: (fn: (db: unknown) => unknown) => fn({}),
|
||
openTenantCtx: vi.fn().mockResolvedValue({
|
||
run: (fn: () => void) => fn(),
|
||
release: vi.fn(),
|
||
}),
|
||
openSuperAdminCtx: vi.fn().mockResolvedValue(undefined),
|
||
_tenantCtx: { getStore: vi.fn().mockReturnValue(null) },
|
||
}));
|
||
|
||
vi.mock('../server/storage', () => ({ storage: mockStorage }));
|
||
|
||
// bcrypt замокан ради скорости тестов: хэш = 'hash:<пароль>'.
|
||
vi.mock('../server/utils/password', () => ({
|
||
hashPassword: vi.fn(async (p: string) => `hash:${p}`),
|
||
verifyPassword: vi.fn(async (p: string, h: string) => h === `hash:${p}`),
|
||
generateTempPassword: vi.fn(() => 'Temp1234!'),
|
||
}));
|
||
|
||
vi.mock('../server/services/email.service', () => ({
|
||
emailService: mockEmailService,
|
||
EmailService: class {},
|
||
}));
|
||
|
||
vi.mock('../server/services/notification.service', () => ({
|
||
notificationService: {
|
||
emit: vi.fn(),
|
||
on: vi.fn(),
|
||
sendNotification: vi.fn().mockResolvedValue(undefined),
|
||
createDefaultSubscriptions: vi.fn().mockResolvedValue(undefined),
|
||
processEvent: vi.fn(),
|
||
},
|
||
EVENT_TYPES: {},
|
||
}));
|
||
|
||
vi.mock('../server/routes/shared', () => ({
|
||
authLimiter: (_req: unknown, _res: unknown, next: () => void) => next(),
|
||
refreshLimiter: (_req: unknown, _res: unknown, next: () => void) => next(),
|
||
}));
|
||
|
||
vi.mock('../server/utils/audit', () => ({
|
||
logAudit: vi.fn().mockResolvedValue(undefined),
|
||
getClientIp: vi.fn().mockReturnValue('127.0.0.1'),
|
||
}));
|
||
|
||
import express from 'express';
|
||
import request from 'supertest';
|
||
import { Router } from 'express';
|
||
import { registerAuthCoreRoutes } from '../server/routes/auth.core.routes';
|
||
import { authService } from '../server/services/auth.service';
|
||
import { generateTokens, hashToken } from '../server/utils/jwt';
|
||
import { clearLoginAttempts } from '../server/utils/login-attempts';
|
||
|
||
const PASSWORD = 'Secret123!';
|
||
|
||
function makeUser(overrides: Record<string, unknown> = {}) {
|
||
return {
|
||
id: 1,
|
||
organizationId: 1,
|
||
email: 'user@example.com',
|
||
passwordHash: `hash:${PASSWORD}`,
|
||
firstName: 'Иван',
|
||
lastName: 'Иванов',
|
||
middleName: null,
|
||
position: null,
|
||
appRole: 'user',
|
||
isActive: true,
|
||
organization: {
|
||
id: 1,
|
||
name: 'Тест',
|
||
slug: 'test',
|
||
displayName: 'Тест',
|
||
isActive: true,
|
||
},
|
||
...overrides,
|
||
};
|
||
}
|
||
|
||
function setupExistingUser(user = makeUser()) {
|
||
mockStorage.getUserByEmail.mockResolvedValue(user);
|
||
mockStorage.getUserWithOrganization.mockResolvedValue(user);
|
||
mockStorage.getAppRolePermissions.mockResolvedValue([]);
|
||
mockStorage.updateUser.mockResolvedValue(user);
|
||
mockStorage.createUserSession.mockResolvedValue({});
|
||
return user;
|
||
}
|
||
|
||
function makeSession(plainRefreshToken: string, overrides: Record<string, unknown> = {}) {
|
||
return {
|
||
id: 10,
|
||
userId: 1,
|
||
refreshToken: null,
|
||
refreshTokenHash: hashToken(plainRefreshToken),
|
||
familyId: 'family-1',
|
||
familyCreatedAt: new Date(),
|
||
parentRefreshToken: null,
|
||
parentRefreshTokenHash: null,
|
||
isReplaced: false,
|
||
isRevoked: false,
|
||
expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1000),
|
||
remember: false,
|
||
createdAt: new Date(),
|
||
...overrides,
|
||
};
|
||
}
|
||
|
||
function buildApp() {
|
||
const app = express();
|
||
app.use(express.json());
|
||
const router = Router();
|
||
registerAuthCoreRoutes(router);
|
||
app.use(router);
|
||
return app;
|
||
}
|
||
|
||
describe('hashToken', () => {
|
||
it('возвращает детерминированный sha256-хэш в hex (64 символа)', () => {
|
||
const token = 'some-refresh-token';
|
||
const expected = crypto.createHash('sha256').update(token).digest('hex');
|
||
expect(hashToken(token)).toBe(expected);
|
||
expect(hashToken(token)).toMatch(/^[0-9a-f]{64}$/);
|
||
expect(hashToken(token)).toBe(hashToken(token));
|
||
expect(hashToken(token)).not.toBe(hashToken(token + 'x'));
|
||
});
|
||
});
|
||
|
||
describe('refresh-токены: выпуск по хэшу (plain не сохраняется)', () => {
|
||
beforeEach(() => {
|
||
vi.clearAllMocks();
|
||
clearLoginAttempts();
|
||
});
|
||
|
||
it('при логине в БД уходит только refreshTokenHash, plain refreshToken не передаётся', async () => {
|
||
const app = buildApp();
|
||
setupExistingUser();
|
||
|
||
const res = await request(app)
|
||
.post('/api/auth/login')
|
||
.send({ email: 'user@example.com', password: PASSWORD });
|
||
|
||
expect(res.status).toBe(200);
|
||
const plainRefresh: string = res.body.tokens.refreshToken;
|
||
expect(plainRefresh).toBeTruthy();
|
||
|
||
const sessionArg = mockStorage.createUserSession.mock.calls[0][0];
|
||
expect(sessionArg.refreshTokenHash).toBe(hashToken(plainRefresh));
|
||
expect(sessionArg.refreshToken).toBeUndefined();
|
||
});
|
||
|
||
it('refresh по валидному токену: ротация с хэшами, plain в createUserSession не уходит', async () => {
|
||
const user = setupExistingUser();
|
||
const { refreshToken: oldPlain } = generateTokens({ userId: 1, organizationId: 1, appRole: 'user' }, false, 'family-1');
|
||
const session = makeSession(oldPlain);
|
||
|
||
mockStorage.getUserSessionByToken.mockResolvedValue(session);
|
||
mockStorage.rotateUserSession.mockResolvedValue({ id: 2 });
|
||
|
||
const result = await authService.refreshToken(oldPlain);
|
||
|
||
expect(result.success).toBe(true);
|
||
expect(result.tokens?.refreshToken).toBeTruthy();
|
||
// jti в payload: токены уникальны всегда, даже при ротации в ту же секунду
|
||
|
||
// Поиск сессии шёл по переданному plain-токену (хэширование — внутри storage)
|
||
expect(mockStorage.getUserSessionByToken).toHaveBeenCalledWith(oldPlain);
|
||
|
||
// Атомарная ротация: replaced + insert в одной транзакции (storage.rotateUserSession)
|
||
const newPlain = result.tokens!.refreshToken;
|
||
expect(mockStorage.rotateUserSession).toHaveBeenCalledWith(session.id, expect.objectContaining({
|
||
refreshTokenHash: hashToken(newPlain),
|
||
parentRefreshTokenHash: hashToken(oldPlain),
|
||
familyId: 'family-1',
|
||
}));
|
||
const newSessionArg = mockStorage.rotateUserSession.mock.calls[0][1];
|
||
expect(newSessionArg.refreshToken).toBeUndefined();
|
||
expect(newSessionArg.parentRefreshToken).toBeUndefined();
|
||
expect(user.id).toBe(1);
|
||
});
|
||
|
||
it('невалидный токен не находится: ни как текущий, ни как родительский', async () => {
|
||
setupExistingUser();
|
||
mockStorage.getUserSessionByToken.mockResolvedValue(undefined);
|
||
mockStorage.getUserSessionByParentToken.mockResolvedValue(undefined);
|
||
|
||
const result = await authService.refreshToken('forged-token');
|
||
|
||
expect(result.success).toBe(false);
|
||
expect(result.error).toContain('Недействительный');
|
||
expect(mockStorage.markSessionReplaced).not.toHaveBeenCalled();
|
||
expect(mockStorage.createUserSession).not.toHaveBeenCalled();
|
||
});
|
||
|
||
it('reuse detection: отозванная/старая rotated-сессия → отзыв всей family', async () => {
|
||
setupExistingUser();
|
||
mockStorage.getUserSessionByToken.mockResolvedValue(undefined);
|
||
// Rotated-сессия старая (grace period 5 минут истёк) или отозванная
|
||
const rotated = makeSession('old-plain', {
|
||
isRevoked: false,
|
||
createdAt: new Date(Date.now() - 10 * 60 * 1000),
|
||
});
|
||
mockStorage.getUserSessionByParentToken.mockResolvedValue(rotated);
|
||
mockStorage.revokeSessionFamily.mockResolvedValue(undefined);
|
||
|
||
const result = await authService.refreshToken('old-plain');
|
||
|
||
expect(result.success).toBe(false);
|
||
expect(mockStorage.revokeSessionFamily).toHaveBeenCalledWith('family-1');
|
||
});
|
||
|
||
it('grace period: свежая rotated-сессия → активная сессия family ротируется, клиент получает новую пару', async () => {
|
||
setupExistingUser();
|
||
const { refreshToken: activePlain } = generateTokens({ userId: 1, organizationId: 1, appRole: 'user' }, false, 'family-1');
|
||
const activeSession = makeSession(activePlain, { id: 11 });
|
||
|
||
mockStorage.getUserSessionByToken.mockResolvedValue(undefined);
|
||
mockStorage.getUserSessionByParentToken.mockResolvedValue(
|
||
makeSession('stale-plain', { createdAt: new Date() }),
|
||
);
|
||
mockStorage.getActiveSessionInFamily.mockResolvedValue(activeSession);
|
||
mockStorage.rotateUserSession.mockResolvedValue({ id: 12 });
|
||
|
||
const result = await authService.refreshToken('stale-plain');
|
||
|
||
expect(result.success).toBe(true);
|
||
// Plain-токен активной сессии в БД не хранится — выдаётся пара через ротацию
|
||
expect(result.tokens?.refreshToken).toBeTruthy();
|
||
expect(mockStorage.rotateUserSession).toHaveBeenCalledWith(activeSession.id, expect.objectContaining({
|
||
refreshTokenHash: hashToken(result.tokens!.refreshToken),
|
||
}));
|
||
});
|
||
|
||
it('grace period: повтор СТАРОГО токена, replaced-сессия найдена по hash → successor ротируется, новая пара, без revoke', async () => {
|
||
setupExistingUser();
|
||
const oldPlain = 'old-plain-race';
|
||
// Старая сессия всё ещё находится по refreshTokenHash (markSessionReplaced
|
||
// hash не очищает) и помечена isReplaced
|
||
const replaced = makeSession(oldPlain, { id: 10, isReplaced: true });
|
||
// Successor-сессия, созданная winner-запросом чуть раньше (в пределах окна)
|
||
const successor = makeSession('new-plain-race', { id: 11, createdAt: new Date() });
|
||
|
||
mockStorage.getUserSessionByToken.mockResolvedValue(replaced);
|
||
mockStorage.getUserSessionByParentToken.mockResolvedValue(successor);
|
||
mockStorage.getActiveSessionInFamily.mockResolvedValue(successor);
|
||
mockStorage.rotateUserSession.mockResolvedValue({ id: 12 });
|
||
|
||
const result = await authService.refreshToken(oldPlain);
|
||
|
||
expect(result.success).toBe(true);
|
||
expect(result.tokens?.refreshToken).toBeTruthy();
|
||
// Ротируется successor (активная сессия family), family НЕ отзывается
|
||
expect(mockStorage.rotateUserSession).toHaveBeenCalledWith(successor.id, expect.objectContaining({
|
||
refreshTokenHash: hashToken(result.tokens!.refreshToken),
|
||
}));
|
||
expect(mockStorage.revokeSessionFamily).not.toHaveBeenCalled();
|
||
expect(result.clearCookies).toBeUndefined();
|
||
});
|
||
|
||
it('replaced-сессия без successor: 401 БЕЗ стирания cookie и БЕЗ revoke family', async () => {
|
||
setupExistingUser();
|
||
const oldPlain = 'old-plain-no-successor';
|
||
const replaced = makeSession(oldPlain, { id: 10, isReplaced: true });
|
||
|
||
mockStorage.getUserSessionByToken.mockResolvedValue(replaced);
|
||
mockStorage.getUserSessionByParentToken.mockResolvedValue(undefined);
|
||
|
||
const result = await authService.refreshToken(oldPlain);
|
||
|
||
expect(result.success).toBe(false);
|
||
expect(result.clearCookies).toBe(false);
|
||
expect(mockStorage.revokeSessionFamily).not.toHaveBeenCalled();
|
||
expect(mockStorage.markSessionReplaced).not.toHaveBeenCalled();
|
||
});
|
||
|
||
it('reuse attack: повтор старого токена ПОСЛЕ grace-окна → revoke family (isReplaced-ветка)', async () => {
|
||
setupExistingUser();
|
||
const oldPlain = 'old-plain-after-window';
|
||
const replaced = makeSession(oldPlain, { id: 10, isReplaced: true });
|
||
const successor = makeSession('new-plain-after-window', {
|
||
id: 11,
|
||
createdAt: new Date(Date.now() - 10 * 60 * 1000), // 10 минут назад — окно истекло
|
||
});
|
||
|
||
mockStorage.getUserSessionByToken.mockResolvedValue(replaced);
|
||
mockStorage.getUserSessionByParentToken.mockResolvedValue(successor);
|
||
mockStorage.revokeSessionFamily.mockResolvedValue(undefined);
|
||
|
||
const result = await authService.refreshToken(oldPlain);
|
||
|
||
expect(result.success).toBe(false);
|
||
expect(mockStorage.revokeSessionFamily).toHaveBeenCalledWith('family-1');
|
||
expect(mockStorage.markSessionReplaced).not.toHaveBeenCalled();
|
||
});
|
||
|
||
it('route: повтор в grace-окне → 200 и новая пара токенов + cookie', async () => {
|
||
const app = buildApp();
|
||
setupExistingUser();
|
||
const oldPlain = 'old-plain-route';
|
||
const replaced = makeSession(oldPlain, { id: 10, isReplaced: true });
|
||
const successor = makeSession('new-plain-route', { id: 11, createdAt: new Date() });
|
||
|
||
mockStorage.getUserSessionByToken.mockResolvedValue(replaced);
|
||
mockStorage.getUserSessionByParentToken.mockResolvedValue(successor);
|
||
mockStorage.getActiveSessionInFamily.mockResolvedValue(successor);
|
||
mockStorage.markSessionReplaced.mockResolvedValue(undefined);
|
||
|
||
const res = await request(app)
|
||
.post('/api/auth/refresh')
|
||
.send({ refreshToken: oldPlain });
|
||
|
||
expect(res.status).toBe(200);
|
||
expect(res.body.success).toBe(true);
|
||
expect(res.body.tokens?.refreshToken).toBeTruthy();
|
||
// Сервер выставил новые auth-cookie
|
||
const setCookie = res.headers['set-cookie'];
|
||
expect(setCookie).toBeTruthy();
|
||
expect(String(setCookie)).toContain('access_token=');
|
||
expect(String(setCookie)).toContain('refresh_token=');
|
||
expect(mockStorage.revokeSessionFamily).not.toHaveBeenCalled();
|
||
});
|
||
|
||
it('route: отказ без successor не стирает cookie, при revoked-сессии — стирает', async () => {
|
||
const app = buildApp();
|
||
setupExistingUser();
|
||
|
||
// Случай 1: replaced без successor → 401 без set-cookie (cookie не трогаем)
|
||
mockStorage.getUserSessionByToken.mockResolvedValue(
|
||
makeSession('p1', { id: 10, isReplaced: true }),
|
||
);
|
||
mockStorage.getUserSessionByParentToken.mockResolvedValue(undefined);
|
||
|
||
const res1 = await request(app)
|
||
.post('/api/auth/refresh')
|
||
.send({ refreshToken: 'p1' });
|
||
|
||
expect(res1.status).toBe(401);
|
||
expect(res1.headers['set-cookie']).toBeUndefined();
|
||
expect(mockStorage.revokeSessionFamily).not.toHaveBeenCalled();
|
||
|
||
// Случай 2: revoked-сессия → 401 со стиранием cookie
|
||
mockStorage.getUserSessionByToken.mockResolvedValue(
|
||
makeSession('p2', { id: 12, isRevoked: true }),
|
||
);
|
||
|
||
const res2 = await request(app)
|
||
.post('/api/auth/refresh')
|
||
.send({ refreshToken: 'p2' });
|
||
|
||
expect(res2.status).toBe(401);
|
||
const cleared = String(res2.headers['set-cookie']);
|
||
expect(cleared).toContain('access_token=;');
|
||
expect(cleared).toContain('refresh_token=;');
|
||
});
|
||
|
||
it('отзыв сессии при logout: revokeSession вызывается с plain-токеном (хэширует storage)', async () => {
|
||
mockStorage.revokeSession.mockResolvedValue(undefined);
|
||
|
||
await authService.logout('some-refresh-token');
|
||
|
||
expect(mockStorage.revokeSession).toHaveBeenCalledWith('some-refresh-token');
|
||
});
|
||
});
|
||
|
||
describe('reset-токены по хэшу', () => {
|
||
beforeEach(() => {
|
||
vi.clearAllMocks();
|
||
clearLoginAttempts();
|
||
});
|
||
|
||
it('forgot-password: в БД уходит resetPasswordTokenHash и resetPasswordToken=null, plain — только в письмо', async () => {
|
||
const app = buildApp();
|
||
setupExistingUser();
|
||
mockStorage.getOrganization.mockResolvedValue({ id: 1, name: 'Тест', displayName: 'Тест' });
|
||
|
||
const res = await request(app)
|
||
.post('/api/auth/forgot-password')
|
||
.send({ email: 'user@example.com' });
|
||
|
||
expect(res.status).toBe(200);
|
||
|
||
// Plain-токен ушёл в письмо
|
||
const emailedToken: string = mockEmailService.sendPasswordResetEmail.mock.calls[0][2];
|
||
expect(emailedToken).toMatch(/^[0-9a-f]{64}$/);
|
||
|
||
// В БД — только хэш, plain-колонка явно обнулена
|
||
const updateArg = mockStorage.updateUser.mock.calls.find(
|
||
(c) => c[1].resetPasswordTokenHash,
|
||
)?.[1];
|
||
expect(updateArg).toBeTruthy();
|
||
expect(updateArg.resetPasswordTokenHash).toBe(hashToken(emailedToken));
|
||
expect(updateArg.resetPasswordToken).toBeNull();
|
||
expect(updateArg.resetPasswordExpires).toBeInstanceOf(Date);
|
||
});
|
||
|
||
it('reset-password: поиск пользователя по токену из ссылки, после сброса хэш очищается', async () => {
|
||
const app = buildApp();
|
||
const user = makeUser({ resetPasswordExpires: new Date(Date.now() + 60 * 60 * 1000) });
|
||
mockStorage.getUserByResetPasswordToken.mockResolvedValue(user);
|
||
mockStorage.revokeAllUserSessions.mockResolvedValue(undefined);
|
||
|
||
const res = await request(app)
|
||
.post('/api/auth/reset-password')
|
||
.send({ token: 'a'.repeat(64), password: 'NewSecret123!' });
|
||
|
||
expect(res.status).toBe(200);
|
||
expect(res.body.success).toBe(true);
|
||
|
||
// Токен из ссылки передан в storage как есть — поиск по хэшу внутри storage
|
||
expect(mockStorage.getUserByResetPasswordToken).toHaveBeenCalledWith('a'.repeat(64));
|
||
|
||
const updateArg = mockStorage.updateUser.mock.calls.find(
|
||
(c) => c[1].passwordHash,
|
||
)?.[1];
|
||
expect(updateArg.passwordHash).toBe('hash:NewSecret123!');
|
||
expect(updateArg.resetPasswordToken).toBeNull();
|
||
expect(updateArg.resetPasswordTokenHash).toBeNull();
|
||
expect(updateArg.resetPasswordExpires).toBeNull();
|
||
|
||
// Все сессии пользователя инвалидируются
|
||
expect(mockStorage.revokeAllUserSessions).toHaveBeenCalledWith(user.id);
|
||
});
|
||
|
||
it('reset-password: невалидный токен не находится → 400', async () => {
|
||
const app = buildApp();
|
||
mockStorage.getUserByResetPasswordToken.mockResolvedValue(undefined);
|
||
|
||
const res = await request(app)
|
||
.post('/api/auth/reset-password')
|
||
.send({ token: 'b'.repeat(64), password: 'NewSecret123!' });
|
||
|
||
expect(res.status).toBe(400);
|
||
expect(res.body.error).toContain('Неверная или устаревшая ссылка');
|
||
expect(mockStorage.updateUser).not.toHaveBeenCalled();
|
||
});
|
||
|
||
it('reset-password: истёкший токен → 400, хэш очищается', async () => {
|
||
const app = buildApp();
|
||
const user = makeUser({ resetPasswordExpires: new Date(Date.now() - 1000) });
|
||
mockStorage.getUserByResetPasswordToken.mockResolvedValue(user);
|
||
|
||
const res = await request(app)
|
||
.post('/api/auth/reset-password')
|
||
.send({ token: 'c'.repeat(64), password: 'NewSecret123!' });
|
||
|
||
expect(res.status).toBe(400);
|
||
expect(res.body.error).toContain('истёк');
|
||
|
||
const updateArg = mockStorage.updateUser.mock.calls[0][1];
|
||
expect(updateArg.resetPasswordTokenHash).toBeNull();
|
||
expect(updateArg.resetPasswordToken).toBeNull();
|
||
});
|
||
});
|