mirror of
https://github.com/mauriceboe/TREK.git
synced 2026-11-20 19:16:08 +00:00
11013711d6
They reset through resetDatabase and seed through the ORM factories on the booted app's ORM instead of the SQLite snapshot mock, so they run in the Postgres lane as well.
187 lines
7.2 KiB
TypeScript
187 lines
7.2 KiB
TypeScript
/**
|
|
* Security integration tests.
|
|
* Covers SEC-001 to SEC-015.
|
|
*
|
|
* Notes:
|
|
* - SSRF tests (SEC-001 to SEC-004) are unit-level tests on ssrfGuard — see tests/unit/utils/ssrfGuard.test.ts
|
|
* - SEC-015 (MFA backup codes) is covered in auth.test.ts
|
|
* - These tests focus on HTTP-level security: headers, auth, injection protection, etc.
|
|
*/
|
|
import { buildApp } from '../../src/bootstrap';
|
|
import { AuditLog } from '../../src/db/entities/AuditLog.entity';
|
|
import { TripFiles } from '../../src/db/entities/TripFiles.entity';
|
|
import { authCookie, authHeader, generateToken } from '../helpers/auth';
|
|
import type { FactoryOrm } from '../helpers/factories/context';
|
|
import { findRows, updateRows } from '../helpers/factories/rows';
|
|
import { setAppSetting } from '../helpers/factories/settings';
|
|
import { makeTrip } from '../helpers/factories/trips';
|
|
import { makeUser } from '../helpers/factories/users';
|
|
import { readUser } from '../helpers/factories/users';
|
|
import { resetDatabase } from '../helpers/reset-database';
|
|
import { resetTestDb, resetRateLimits } from '../helpers/test-db';
|
|
import { MikroORM } from '@mikro-orm/core';
|
|
import type { INestApplication } from '@nestjs/common';
|
|
|
|
import type { Application } from 'express';
|
|
import fs from 'fs';
|
|
import path from 'path';
|
|
import request from 'supertest';
|
|
import { describe, it, expect, beforeAll, beforeEach, afterAll } from 'vitest';
|
|
|
|
let nestApp: INestApplication;
|
|
let app: Application;
|
|
/** The app's own ORM, which the factories seed and read through. */
|
|
let orm: FactoryOrm;
|
|
const FIXTURE_IMG = path.join(__dirname, '../fixtures/small-image.jpg');
|
|
const uploadsDir = path.join(__dirname, '../../uploads/files');
|
|
|
|
beforeAll(async () => {
|
|
nestApp = await buildApp();
|
|
orm = nestApp.get(MikroORM);
|
|
app = nestApp.getHttpAdapter().getInstance();
|
|
if (!fs.existsSync(uploadsDir)) fs.mkdirSync(uploadsDir, { recursive: true });
|
|
await setAppSetting(orm, 'allowed_file_types', '*');
|
|
});
|
|
|
|
beforeEach(async () => {
|
|
await resetDatabase(orm);
|
|
await resetRateLimits(nestApp);
|
|
await setAppSetting(orm, 'allowed_file_types', '*');
|
|
});
|
|
|
|
afterAll(async () => {
|
|
await nestApp.close();
|
|
fs.rmSync(uploadsDir, { recursive: true, force: true });
|
|
});
|
|
|
|
describe('Authentication security', () => {
|
|
it('SEC-007 — invalid JWT in Authorization Bearer header is rejected', async () => {
|
|
const { user } = await makeUser(orm);
|
|
const token = generateToken(user.id);
|
|
|
|
// The file download endpoint accepts bearer auth
|
|
// Other endpoints use cookie auth — but /api/auth/me works with cookie auth
|
|
// Test that a forged/invalid JWT is rejected
|
|
const res = await request(app).get('/api/auth/me').set('Authorization', 'Bearer invalid.token.here');
|
|
// Should return 401 (auth fails)
|
|
expect(res.status).toBe(401);
|
|
});
|
|
|
|
it('unauthenticated request to protected endpoint returns 401', async () => {
|
|
const res = await request(app).get('/api/trips');
|
|
expect(res.status).toBe(401);
|
|
});
|
|
|
|
it('expired/invalid JWT cookie returns 401', async () => {
|
|
const res = await request(app).get('/api/trips').set('Cookie', 'trek_session=invalid.jwt.token');
|
|
expect(res.status).toBe(401);
|
|
});
|
|
});
|
|
|
|
describe('Security headers', () => {
|
|
it('SEC-011 — Helmet sets X-Content-Type-Options header', async () => {
|
|
const res = await request(app).get('/api/health');
|
|
expect(res.headers['x-content-type-options']).toBe('nosniff');
|
|
});
|
|
|
|
it('SEC-011 — Helmet sets X-Frame-Options header', async () => {
|
|
const res = await request(app).get('/api/health');
|
|
expect(res.headers['x-frame-options']).toBe('SAMEORIGIN');
|
|
});
|
|
});
|
|
|
|
describe('API key encryption', () => {
|
|
it('SEC-008 — encrypted API keys are stored with enc:v1: prefix', async () => {
|
|
const { user } = await makeUser(orm);
|
|
|
|
await request(app)
|
|
.put('/api/auth/me/api-keys')
|
|
.set('Cookie', authCookie(user.id))
|
|
.send({ openweather_api_key: 'test-api-key-12345' });
|
|
|
|
const row = await readUser(orm, user.id);
|
|
expect(row.openweather_api_key).toMatch(/^enc:v1:/);
|
|
});
|
|
|
|
it('SEC-008 — saving keys audits the names and never the values (#1939)', async () => {
|
|
const { user } = await makeUser(orm);
|
|
|
|
const save = () =>
|
|
request(app)
|
|
.put('/api/auth/me/api-keys')
|
|
.set('Cookie', authCookie(user.id))
|
|
.send({ openweather_api_key: 'test-api-key-12345' });
|
|
|
|
const first = await save();
|
|
expect(first.status).toBe(200);
|
|
// changedKeys is internal: the client body is what it always was.
|
|
expect(first.body).not.toHaveProperty('changedKeys');
|
|
|
|
const rows = () => findRows(orm, AuditLog, { action: 'settings.api_keys_update' });
|
|
expect(await rows()).toHaveLength(1);
|
|
expect((await rows())[0].details).toContain('openweather_api_key');
|
|
expect((await rows())[0].details).not.toContain('test-api-key-12345');
|
|
|
|
// The same value again writes no second row. This is the real test of the
|
|
// cleartext comparison: encryption uses a random IV, so the stored blob
|
|
// differs on every save even when the key does not.
|
|
await save();
|
|
expect(await rows()).toHaveLength(1);
|
|
});
|
|
|
|
it('SEC-008 — GET /api/auth/me does not return plaintext API key', async () => {
|
|
const { user } = await makeUser(orm);
|
|
await request(app)
|
|
.put('/api/auth/me/api-keys')
|
|
.set('Cookie', authCookie(user.id))
|
|
.send({ openweather_api_key: 'secret-key' });
|
|
|
|
const me = await request(app).get('/api/auth/me').set('Cookie', authCookie(user.id));
|
|
expect(me.body.user.openweather_api_key).not.toBe('secret-key');
|
|
});
|
|
});
|
|
|
|
describe('MFA secret protection', () => {
|
|
it('SEC-009 — GET /api/auth/me does not expose mfa_secret', async () => {
|
|
const { user } = await makeUser(orm);
|
|
|
|
const res = await request(app).get('/api/auth/me').set('Cookie', authCookie(user.id));
|
|
expect(res.body.user.mfa_secret).toBeUndefined();
|
|
expect(res.body.user.password_hash).toBeUndefined();
|
|
});
|
|
});
|
|
|
|
describe('Request body size limit', () => {
|
|
it('SEC-013 — oversized JSON body is rejected', async () => {
|
|
// Send a large body (2MB+) to exceed the default limit
|
|
const bigData = { data: 'x'.repeat(2 * 1024 * 1024) };
|
|
|
|
const res = await request(app).post('/api/auth/login').send(bigData);
|
|
// body-parser rejects oversized payloads with 413
|
|
expect(res.status).toBe(413);
|
|
});
|
|
});
|
|
|
|
describe('File download path traversal', () => {
|
|
it('SEC-005 — path traversal in file download is blocked', async () => {
|
|
const { user } = await makeUser(orm);
|
|
const trip = await makeTrip(orm, user.id);
|
|
|
|
const upload = await request(app)
|
|
.post(`/api/trips/${trip.id}/files`)
|
|
.set('Cookie', authCookie(user.id))
|
|
.attach('file', FIXTURE_IMG);
|
|
expect(upload.status).toBe(201);
|
|
const fileId = upload.body.file.id;
|
|
|
|
await updateRows(orm, TripFiles, { id: fileId }, { filename: '../../etc/passwd' });
|
|
|
|
const res = await request(app).get(`/api/trips/${trip.id}/files/${fileId}/download`).set(authHeader(user.id));
|
|
// path.basename() strips traversal in the download controller; the normalized
|
|
// name does not exist in uploads, so the answer is the same 404 a missing file
|
|
// gets. Pinned exactly: a 500 from a thrown guard would also be "not 200".
|
|
expect(res.status).toBe(404);
|
|
expect(res.body).toEqual({ error: 'File not found' });
|
|
});
|
|
});
|