From 7ec1fdad288ab6de6a68bceeeb9ecc2c5b32a7d6 Mon Sep 17 00:00:00 2001 From: Your Name Date: Sat, 7 Nov 2026 18:22:24 +0200 Subject: [PATCH] After improving the security for the files uploaded --- .env.docker.example | 6 + backend/.env.example | 6 +- backend/src/config/index.ts | 8 +- backend/src/controllers/supportController.ts | 119 +++++++----- backend/src/db/schema.sql | 17 ++ backend/src/middleware/supportUpload.ts | 7 +- backend/src/repositories/supportRepository.ts | 73 +++++++ backend/src/routes/index.ts | 6 +- backend/src/services/supportService.ts | 182 +++++++++++++++++- .../src/tests/supportUploadHardening.test.ts | 59 ++++++ backend/src/utils/fileMagic.ts | 59 +++++- backend/src/utils/uploadValidation.ts | 10 +- deploy/PRODUCTION_SENTRY_CLAMAV.md | 35 ++-- docker-compose.yml | 3 +- package.json | 16 +- .../data/repositories/support_repository.dart | 12 ++ .../support/presentation/support_widget.dart | 21 +- .../src/features/support/api/supportApi.ts | 16 +- 18 files changed, 561 insertions(+), 94 deletions(-) create mode 100644 backend/src/tests/supportUploadHardening.test.ts diff --git a/.env.docker.example b/.env.docker.example index 5d833cad..429a7a1a 100644 --- a/.env.docker.example +++ b/.env.docker.example @@ -84,3 +84,9 @@ EMAIL_TRANSPORT=console # Local Docker: skip mandatory admin 2FA (production should leave this unset or true) REQUIRE_ADMIN_2FA=false + +# ClamAV (optional locally). Production VPS: CLAMAV_ENABLED=true + docker compose --profile clamav +# CLAMAV_ENABLED=false +# CLAMAV_HOST=clamav +# CLAMAV_PORT=3310 +# CLAMAV_TIMEOUT_MS=30000 diff --git a/backend/.env.example b/backend/.env.example index 81ce623b..83e490dc 100644 --- a/backend/.env.example +++ b/backend/.env.example @@ -107,8 +107,10 @@ WORKER_ID=worker-1 # SENTRY_DSN=https://...@sentry.io/... # SENTRY_TRACES_SAMPLE_RATE=0.1 -# ClamAV virus scan on uploads (optional — requires clamd) -# CLAMAV_ENABLED=false +# ClamAV virus scan on uploads (requires clamd). +# Production (NODE_ENV=production): enabled by default unless CLAMAV_ENABLED=false. +# Development: disabled unless CLAMAV_ENABLED=true. +# CLAMAV_ENABLED=true # CLAMAV_HOST=127.0.0.1 # CLAMAV_PORT=3310 # CLAMAV_TIMEOUT_MS=30000 diff --git a/backend/src/config/index.ts b/backend/src/config/index.ts index 6fe210b2..5ed58f56 100644 --- a/backend/src/config/index.ts +++ b/backend/src/config/index.ts @@ -297,7 +297,13 @@ export const config = { ), }, clamav: { - enabled: process.env.CLAMAV_ENABLED === 'true', + // Production: on by default. Explicit CLAMAV_ENABLED=false disables; =true forces on in any env. + enabled: (() => { + const raw = (process.env.CLAMAV_ENABLED || '').trim().toLowerCase(); + if (raw === 'true' || raw === '1' || raw === 'yes') return true; + if (raw === 'false' || raw === '0' || raw === 'no') return false; + return (process.env.NODE_ENV || 'development') === 'production'; + })(), host: process.env.CLAMAV_HOST || '127.0.0.1', port: parseInt(process.env.CLAMAV_PORT || '3310', 10), timeoutMs: readEnvInt('CLAMAV_TIMEOUT_MS', 30_000, 5000, 120_000), diff --git a/backend/src/controllers/supportController.ts b/backend/src/controllers/supportController.ts index c2103999..b545d92a 100644 --- a/backend/src/controllers/supportController.ts +++ b/backend/src/controllers/supportController.ts @@ -1,13 +1,9 @@ import { Response } from 'express'; -import fs from 'fs'; -import path from 'path'; import { AuthRequest } from '../middleware/auth'; import { readVisitorToken } from '../middleware/optionalAuth'; -import { SUPPORT_ALLOWED_MIMES } from '../middleware/supportUpload'; import { removeUploadedFile } from '../utils/fileMagic'; -import { validateUploadedFile } from '../utils/uploadValidation'; +import { verifyToken } from '../services/authService'; import * as supportService from '../services/supportService'; -import { recordUploadedFile, FILE_INTEGRITY_ROOTS } from '../services/fileIntegrityService'; function buildCtx(req: AuthRequest) { return { @@ -155,22 +151,23 @@ export async function uploadCurrentAttachment(req: AuthRequest, res: Response): res.status(400).json({ error: 'No file uploaded' }); return; } - const filePath = supportService.resolveUploadPath(req.file.filename); + const ctx = buildCtx(req); try { - await validateUploadedFile(filePath, SUPPORT_ALLOWED_MIMES); + const saved = await supportService.finalizeSupportUpload({ + tempFilename: req.file.filename, + originalName: req.file.originalname, + ctx, + }); + res.status(201).json({ + attachmentUrl: saved.url, + attachmentName: saved.originalName, + attachmentMime: saved.mime, + }); } catch (e) { - removeUploadedFile(filePath); + removeUploadedFile(supportService.resolveUploadPath(req.file.filename)); const msg = e instanceof Error ? e.message : 'File validation failed'; - res.status(msg.includes('virus') ? 422 : 400).json({ error: msg }); - return; + res.status(msg.toLowerCase().includes('virus') ? 422 : 400).json({ error: msg }); } - const url = supportService.publicAttachmentUrl(req.file.filename); - await recordUploadedFile(FILE_INTEGRITY_ROOTS.support, req.file.filename); - res.status(201).json({ - attachmentUrl: url, - attachmentName: req.file.originalname, - attachmentMime: req.file.mimetype, - }); } catch (e) { handleError(res, e); } @@ -182,23 +179,29 @@ export async function uploadAttachment(req: AuthRequest, res: Response): Promise res.status(400).json({ error: 'No file uploaded' }); return; } - const filePath = supportService.resolveUploadPath(req.file.filename); + const ctx = buildCtx(req); try { - await validateUploadedFile(filePath, SUPPORT_ALLOWED_MIMES); + await supportService.assertConversationAccess(req.params.id, ctx); + const saved = await supportService.finalizeSupportUpload({ + tempFilename: req.file.filename, + originalName: req.file.originalname, + conversationId: req.params.id, + ctx, + }); + res.status(201).json({ + attachmentUrl: saved.url, + attachmentName: saved.originalName, + attachmentMime: saved.mime, + }); } catch (e) { - removeUploadedFile(filePath); + removeUploadedFile(supportService.resolveUploadPath(req.file.filename)); const msg = e instanceof Error ? e.message : 'File validation failed'; - res.status(msg.includes('virus') ? 422 : 400).json({ error: msg }); - return; + if (msg === 'Forbidden' || msg === 'Conversation not found') { + handleError(res, e); + return; + } + res.status(msg.toLowerCase().includes('virus') ? 422 : 400).json({ error: msg }); } - await supportService.assertConversationAccess(req.params.id, buildCtx(req)); - const url = supportService.publicAttachmentUrl(req.file.filename); - await recordUploadedFile(FILE_INTEGRITY_ROOTS.support, req.file.filename); - res.status(201).json({ - attachmentUrl: url, - attachmentName: req.file.originalname, - attachmentMime: req.file.mimetype, - }); } catch (e) { handleError(res, e); } @@ -206,14 +209,36 @@ export async function uploadAttachment(req: AuthRequest, res: Response): Promise export async function getAttachment(req: AuthRequest, res: Response): Promise { try { - const filePath = supportService.resolveUploadPath(req.params.filename); - if (!fs.existsSync(filePath)) { - res.status(404).json({ error: 'File not found' }); + // cannot send Authorization — accept accessToken query as fallback. + if (!req.user) { + const q = req.query.accessToken; + if (typeof q === 'string' && q.trim()) { + try { + req.user = await verifyToken(q.trim()); + } catch { + res.status(401).json({ error: 'Invalid or expired token' }); + return; + } + } + } + + const ctx = buildCtx(req); + if (!ctx.userId && !ctx.visitorToken && !supportService.isStaffRole(ctx.role)) { + res.status(401).json({ error: 'Authentication required' }); return; } + + const access = await supportService.assertSupportFileDownloadAccess( + req.params.filename, + ctx + ); + const downloadName = access.originalName || req.params.filename; + res.setHeader('Content-Type', access.mime); + res.setHeader('Content-Disposition', supportService.attachmentContentDisposition(downloadName)); + res.setHeader('X-Content-Type-Options', 'nosniff'); // Helmet defaults to CORP same-origin; the web app is on another port/origin. res.setHeader('Cross-Origin-Resource-Policy', 'cross-origin'); - res.sendFile(filePath); + res.sendFile(access.filePath); } catch (e) { handleError(res, e); } @@ -315,22 +340,24 @@ export async function adminUploadAttachment(req: AuthRequest, res: Response): Pr res.status(400).json({ error: 'No file uploaded' }); return; } - const filePath = supportService.resolveUploadPath(req.file.filename); + const ctx = buildCtx(req); try { - await validateUploadedFile(filePath, SUPPORT_ALLOWED_MIMES); + const saved = await supportService.finalizeSupportUpload({ + tempFilename: req.file.filename, + originalName: req.file.originalname, + conversationId: req.params.id, + ctx, + }); + res.status(201).json({ + attachmentUrl: saved.url, + attachmentName: saved.originalName, + attachmentMime: saved.mime, + }); } catch (e) { - removeUploadedFile(filePath); + removeUploadedFile(supportService.resolveUploadPath(req.file.filename)); const msg = e instanceof Error ? e.message : 'File validation failed'; - res.status(msg.includes('virus') ? 422 : 400).json({ error: msg }); - return; + res.status(msg.toLowerCase().includes('virus') ? 422 : 400).json({ error: msg }); } - const url = supportService.publicAttachmentUrl(req.file.filename); - await recordUploadedFile(FILE_INTEGRITY_ROOTS.support, req.file.filename); - res.status(201).json({ - attachmentUrl: url, - attachmentName: req.file.originalname, - attachmentMime: req.file.mimetype, - }); } catch (e) { handleError(res, e); } diff --git a/backend/src/db/schema.sql b/backend/src/db/schema.sql index 1fb13746..4f2bba8a 100644 --- a/backend/src/db/schema.sql +++ b/backend/src/db/schema.sql @@ -2928,6 +2928,23 @@ CREATE INDEX IF NOT EXISTS idx_support_msg_unread ON support_messages (conversat WHERE read_at IS NULL; +-- ACL registry for support chat uploads (authz on download) +CREATE TABLE IF NOT EXISTS support_uploaded_files ( + filename VARCHAR(255) PRIMARY KEY, + mime VARCHAR(128) NOT NULL, + original_name VARCHAR(255), + conversation_id UUID REFERENCES support_conversations (id) ON DELETE SET NULL, + uploaded_by_user_id UUID REFERENCES users (id) ON DELETE SET NULL, + visitor_token VARCHAR(128), + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +CREATE INDEX IF NOT EXISTS idx_support_uploaded_files_conv ON support_uploaded_files (conversation_id); + +CREATE INDEX IF NOT EXISTS idx_support_uploaded_files_user ON support_uploaded_files (uploaded_by_user_id); + +CREATE INDEX IF NOT EXISTS idx_support_uploaded_files_visitor ON support_uploaded_files (visitor_token); + -- FAQ (categories + entries, staff-managed) CREATE TABLE IF NOT EXISTS faq_categories ( id SERIAL PRIMARY KEY, diff --git a/backend/src/middleware/supportUpload.ts b/backend/src/middleware/supportUpload.ts index 28b5016e..4e8f9f5e 100644 --- a/backend/src/middleware/supportUpload.ts +++ b/backend/src/middleware/supportUpload.ts @@ -1,5 +1,4 @@ import multer from 'multer'; -import path from 'path'; import { v4 as uuidv4 } from 'uuid'; import { ensureUploadDir } from '../services/supportService'; @@ -19,9 +18,9 @@ const storage = multer.diskStorage({ destination(_req, _file, cb) { cb(null, ensureUploadDir()); }, - filename(_req, file, cb) { - const ext = path.extname(file.originalname).slice(0, 20); - cb(null, `${uuidv4()}${ext}`); + filename(_req, _file, cb) { + // Temporary name only — controller renames to uuid + extension from detected MIME. + cb(null, `${uuidv4()}.upload`); }, }); diff --git a/backend/src/repositories/supportRepository.ts b/backend/src/repositories/supportRepository.ts index b1da426b..c80f4a97 100644 --- a/backend/src/repositories/supportRepository.ts +++ b/backend/src/repositories/supportRepository.ts @@ -422,3 +422,76 @@ export async function mergeAllVisitorConversationsToUser( ); return rows.length; } + +export type SupportUploadedFileRow = { + filename: string; + mime: string; + original_name: string | null; + conversation_id: string | null; + uploaded_by_user_id: string | null; + visitor_token: string | null; + created_at: Date; +}; + +export async function insertUploadedFile(input: { + filename: string; + mime: string; + originalName?: string | null; + conversationId?: string | null; + uploadedByUserId?: string | null; + visitorToken?: string | null; +}): Promise { + const rows = await query( + `INSERT INTO support_uploaded_files ( + filename, mime, original_name, conversation_id, uploaded_by_user_id, visitor_token + ) VALUES ($1, $2, $3, $4, $5, $6) + RETURNING *`, + [ + input.filename, + input.mime, + input.originalName ?? null, + input.conversationId ?? null, + input.uploadedByUserId ?? null, + input.visitorToken ?? null, + ] + ); + return rows[0]!; +} + +export async function findUploadedFile(filename: string): Promise { + const rows = await query( + `SELECT * FROM support_uploaded_files WHERE filename = $1`, + [filename] + ); + return rows[0] ?? null; +} + +export async function bindUploadedFileConversation( + filename: string, + conversationId: string +): Promise { + await query( + `UPDATE support_uploaded_files + SET conversation_id = COALESCE(conversation_id, $2) + WHERE filename = $1`, + [filename, conversationId] + ); +} + +export async function findMessageByAttachmentFilename( + filename: string +): Promise<{ conversation_id: string } | null> { + const suffix = `%/support/files/${filename}`; + const rows = await query<{ conversation_id: string }[]>( + `SELECT conversation_id FROM support_messages + WHERE attachment_url IS NOT NULL + AND ( + attachment_url = $1 + OR attachment_url LIKE $2 + ) + ORDER BY created_at DESC + LIMIT 1`, + [`/api/v1/support/files/${filename}`, suffix] + ); + return rows[0] ?? null; +} diff --git a/backend/src/routes/index.ts b/backend/src/routes/index.ts index e15fc4ac..2efb539e 100644 --- a/backend/src/routes/index.ts +++ b/backend/src/routes/index.ts @@ -222,7 +222,11 @@ router.post( ); /** Support messaging — guests (visitor token) and optional authenticated users. */ -router.get('/support/files/:filename', supportController.getAttachment); +router.get( + '/support/files/:filename', + optionalAuthMiddleware, + supportController.getAttachment +); router.post('/support/conversations/current', optionalAuthMiddleware, supportController.getOrCreateConversation); router.post( '/support/conversations/current/messages', diff --git a/backend/src/services/supportService.ts b/backend/src/services/supportService.ts index 9f12cfd7..8ae8ec8c 100644 --- a/backend/src/services/supportService.ts +++ b/backend/src/services/supportService.ts @@ -1,5 +1,6 @@ import path from 'path'; import fs from 'fs'; +import { v4 as uuidv4 } from 'uuid'; import { decrypt } from '../utils/crypto'; import * as repo from '../repositories/supportRepository'; import { @@ -19,6 +20,10 @@ import { resolveSupportMessageActions, type SupportMessageActionFlags, } from './supportMessagePolicy'; +import { extensionForMime, removeUploadedFile } from '../utils/fileMagic'; +import { validateUploadedFile } from '../utils/uploadValidation'; +import { SUPPORT_ALLOWED_MIMES } from '../middleware/supportUpload'; +import { recordUploadedFile, FILE_INTEGRITY_ROOTS } from './fileIntegrityService'; const STAFF_ROLES = new Set(['admin', 'moderator', 'super_admin']); @@ -273,6 +278,17 @@ export async function sendMessage( throw new Error('Message body or attachment is required'); } + let attachmentUrl = input.attachmentUrl ?? null; + let attachmentName = input.attachmentName ?? null; + let attachmentMime = input.attachmentMime ?? null; + if (attachmentUrl) { + const meta = await assertOwnedSupportAttachment(attachmentUrl, ctx); + attachmentUrl = publicAttachmentUrl(meta.filename); + attachmentName = attachmentName || meta.original_name || meta.filename; + attachmentMime = meta.mime; + await repo.bindUploadedFileConversation(meta.filename, conversationId); + } + let senderType: SupportSenderType; let senderUserId: string | null = null; @@ -291,12 +307,12 @@ export async function sendMessage( senderType, senderUserId, body, - attachmentUrl: input.attachmentUrl ?? null, - attachmentName: input.attachmentName ?? null, - attachmentMime: input.attachmentMime ?? null, + attachmentUrl, + attachmentName, + attachmentMime, }); - const preview = previewForMessage(body, input.attachmentName ?? null); + const preview = previewForMessage(body, attachmentName); const staffSent = senderType === 'staff'; await repo.touchConversationLastMessage( conversationId, @@ -513,6 +529,164 @@ export function publicAttachmentUrl(storedName: string): string { return `/api/v1/support/files/${encodeURIComponent(storedName)}`; } +const SUPPORT_FILE_RE = /^\/api\/v1\/support\/files\/([^/?#]+)$/i; + +/** Extract basename from a support attachment URL (relative or absolute). */ +export function parseSupportAttachmentFilename(url: string): string | null { + try { + const pathOnly = url.startsWith('http') ? new URL(url).pathname : url.split('?')[0] ?? url; + const m = pathOnly.match(SUPPORT_FILE_RE); + if (!m?.[1]) return null; + const name = path.basename(decodeURIComponent(m[1])); + if (!name || name === '.' || name === '..') return null; + return name; + } catch { + return null; + } +} + +function safeDisplayName(originalName: string | undefined, mime: string): string { + const base = path.basename(originalName || 'attachment').replace(/[^\w.\-()+ ]+/g, '_').slice(0, 180); + const ext = extensionForMime(mime); + const withoutExt = base.replace(/\.[^.]+$/, '') || 'attachment'; + return `${withoutExt}${ext}`; +} + +/** + * Validate magic/ClamAV, rename to uuid+safeExt, register ACL row. + */ +export async function finalizeSupportUpload(input: { + tempFilename: string; + originalName?: string; + conversationId?: string | null; + ctx: SupportAccessContext; +}): Promise<{ filename: string; mime: string; originalName: string; url: string }> { + const tempPath = resolveUploadPath(input.tempFilename); + let detected: string; + try { + detected = await validateUploadedFile(tempPath, SUPPORT_ALLOWED_MIMES); + } catch (e) { + removeUploadedFile(tempPath); + throw e; + } + + const ext = extensionForMime(detected); + const finalName = `${uuidv4()}${ext}`; + const finalPath = resolveUploadPath(finalName); + fs.renameSync(tempPath, finalPath); + + const originalName = safeDisplayName(input.originalName, detected); + await repo.insertUploadedFile({ + filename: finalName, + mime: detected, + originalName, + conversationId: input.conversationId ?? null, + uploadedByUserId: input.ctx.userId ?? null, + visitorToken: input.ctx.visitorToken ?? null, + }); + await recordUploadedFile(FILE_INTEGRITY_ROOTS.support, finalName); + + return { + filename: finalName, + mime: detected, + originalName, + url: publicAttachmentUrl(finalName), + }; +} + +async function assertOwnedSupportAttachment(url: string, ctx: SupportAccessContext) { + const filename = parseSupportAttachmentFilename(url); + if (!filename) throw new Error('Invalid attachment URL'); + const row = await repo.findUploadedFile(filename); + if (!row) throw new Error('Attachment not found'); + if (isStaffRole(ctx.role)) return row; + if (ctx.userId && row.uploaded_by_user_id === ctx.userId) return row; + if (ctx.visitorToken && row.visitor_token === ctx.visitorToken) return row; + if (row.conversation_id) { + await assertConversationAccess(row.conversation_id, ctx); + return row; + } + throw new Error('Forbidden'); +} + +/** Authorize download of a stored support file. */ +export async function assertSupportFileDownloadAccess( + filename: string, + ctx: SupportAccessContext +): Promise<{ mime: string; originalName: string | null; filePath: string }> { + const safe = path.basename(filename); + const filePath = resolveUploadPath(safe); + if (!fs.existsSync(filePath)) throw new Error('Not found'); + + if (isStaffRole(ctx.role)) { + const row = await repo.findUploadedFile(safe); + return { + mime: row?.mime || mimeFromFilename(safe), + originalName: row?.original_name ?? null, + filePath, + }; + } + + const row = await repo.findUploadedFile(safe); + if (row) { + if (ctx.userId && row.uploaded_by_user_id === ctx.userId) { + return { mime: row.mime, originalName: row.original_name, filePath }; + } + if (ctx.visitorToken && row.visitor_token === ctx.visitorToken) { + return { mime: row.mime, originalName: row.original_name, filePath }; + } + if (row.conversation_id) { + await assertConversationAccess(row.conversation_id, ctx); + return { mime: row.mime, originalName: row.original_name, filePath }; + } + } + + // Legacy files uploaded before ACL registry: allow if referenced by an accessible message. + const msg = await repo.findMessageByAttachmentFilename(safe); + if (msg) { + await assertConversationAccess(msg.conversation_id, ctx); + return { + mime: mimeFromFilename(safe), + originalName: null, + filePath, + }; + } + + throw new Error('Forbidden'); +} + +function mimeFromFilename(filename: string): string { + const ext = path.extname(filename).toLowerCase(); + switch (ext) { + case '.jpg': + case '.jpeg': + return 'image/jpeg'; + case '.png': + return 'image/png'; + case '.gif': + return 'image/gif'; + case '.webp': + return 'image/webp'; + case '.pdf': + return 'application/pdf'; + case '.txt': + return 'text/plain'; + case '.doc': + return 'application/msword'; + case '.docx': + return 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'; + default: + return 'application/octet-stream'; + } +} + +/** Content-Disposition filename* / filename header value. */ +export function attachmentContentDisposition(downloadName: string): string { + const ascii = downloadName.replace(/[^\x20-\x7E]/g, '_').replace(/"/g, ''); + const encoded = encodeURIComponent(downloadName); + return `attachment; filename="${ascii}"; filename*=UTF-8''${encoded}`; +} + /** Links all anonymous visitor conversations to a newly registered or logged-in user. */ export async function mergeVisitorSupportForUser( userId: string, diff --git a/backend/src/tests/supportUploadHardening.test.ts b/backend/src/tests/supportUploadHardening.test.ts new file mode 100644 index 00000000..588bf152 --- /dev/null +++ b/backend/src/tests/supportUploadHardening.test.ts @@ -0,0 +1,59 @@ +import assert from 'node:assert/strict'; +import fs from 'fs'; +import os from 'os'; +import path from 'path'; +import test from 'node:test'; +import { + assertAllowedFileMagic, + detectMimeFromBuffer, + extensionForMime, +} from '../utils/fileMagic'; +import { + attachmentContentDisposition, + parseSupportAttachmentFilename, +} from '../services/supportService'; + +test('extensionForMime maps detected types to safe extensions', () => { + assert.equal(extensionForMime('image/jpeg'), '.jpg'); + assert.equal(extensionForMime('application/pdf'), '.pdf'); + assert.equal(extensionForMime('text/plain'), '.txt'); + assert.equal( + extensionForMime('application/vnd.openxmlformats-officedocument.wordprocessingml.document'), + '.docx' + ); +}); + +test('text/plain magic rejects HTML/SVG looking content', () => { + assert.equal(detectMimeFromBuffer(Buffer.from('hello world')), 'text/plain'); + assert.equal(detectMimeFromBuffer(Buffer.from('')), null); + assert.equal(detectMimeFromBuffer(Buffer.from('')), null); + assert.equal(detectMimeFromBuffer(Buffer.from('note\n')), null); +}); + +test('assertAllowedFileMagic returns detected mime', () => { + const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'support-magic-')); + const filePath = path.join(dir, 'x.upload'); + fs.writeFileSync(filePath, Buffer.from('%PDF-1.4\n')); + const mime = assertAllowedFileMagic(filePath, new Set(['application/pdf'])); + assert.equal(mime, 'application/pdf'); + fs.rmSync(dir, { recursive: true, force: true }); +}); + +test('parseSupportAttachmentFilename accepts only support file URLs', () => { + assert.equal( + parseSupportAttachmentFilename('/api/v1/support/files/abc-123.pdf'), + 'abc-123.pdf' + ); + assert.equal( + parseSupportAttachmentFilename('https://tloto.net/api/v1/support/files/abc-123.pdf?x=1'), + 'abc-123.pdf' + ); + assert.equal(parseSupportAttachmentFilename('/api/v1/faq/files/abc.pdf'), null); + assert.equal(parseSupportAttachmentFilename('https://evil.test/steal.pdf'), null); +}); + +test('attachmentContentDisposition forces download', () => { + const v = attachmentContentDisposition('guide compte.pdf'); + assert.match(v, /^attachment;/); + assert.match(v, /filename=/); +}); diff --git a/backend/src/utils/fileMagic.ts b/backend/src/utils/fileMagic.ts index d45d5aaf..1a7f0c9c 100644 --- a/backend/src/utils/fileMagic.ts +++ b/backend/src/utils/fileMagic.ts @@ -24,7 +24,18 @@ const RULES: MagicRule[] = [ if (byte === 0) return false; if (byte < 9 || (byte > 13 && byte < 32 && byte !== 27)) return false; } - return sample.length > 0; + if (sample.length === 0) return false; + // Reject HTML/SVG-looking payloads that could be served as active content. + const text = sample.toString('utf8').trimStart().toLowerCase(); + if ( + text.startsWith('): void { +/** Safe file extension for a detected MIME (never trust the client filename). */ +export function extensionForMime(mime: string): string { + switch (mime) { + case 'image/jpeg': + return '.jpg'; + case 'image/png': + return '.png'; + case 'image/gif': + return '.gif'; + case 'image/webp': + return '.webp'; + case 'application/pdf': + return '.pdf'; + case 'text/plain': + return '.txt'; + case 'application/msword': + return '.doc'; + case 'application/vnd.openxmlformats-officedocument.wordprocessingml.document': + return '.docx'; + case 'video/mp4': + return '.mp4'; + case 'video/webm': + return '.webm'; + default: + return '.bin'; + } +} + +/** Detect MIME from an on-disk file header. */ +export function detectMimeFromFile(filePath: string): string | null { const fd = fs.openSync(filePath, 'r'); try { const buf = Buffer.alloc(512); const read = fs.readSync(fd, buf, 0, buf.length, 0); - const detected = detectMimeFromBuffer(buf.subarray(0, read)); - if (!detected || !allowedMimes.has(detected)) { - throw new Error('File content does not match an allowed type'); - } + return detectMimeFromBuffer(buf.subarray(0, read)); } finally { fs.closeSync(fd); } } +/** Ensures on-disk upload content matches an allowed MIME (magic bytes, not client header). */ +export function assertAllowedFileMagic(filePath: string, allowedMimes: Set): string { + const detected = detectMimeFromFile(filePath); + if (!detected || !allowedMimes.has(detected)) { + throw new Error('File content does not match an allowed type'); + } + return detected; +} + /** Removes an uploaded file after failed validation. */ export function removeUploadedFile(filePath: string): void { try { diff --git a/backend/src/utils/uploadValidation.ts b/backend/src/utils/uploadValidation.ts index 9c2f525a..81fd59d0 100644 --- a/backend/src/utils/uploadValidation.ts +++ b/backend/src/utils/uploadValidation.ts @@ -1,8 +1,12 @@ import { assertAllowedFileMagic } from './fileMagic'; import { scanUploadedFile } from '../services/virusScanService'; -/** Validates upload magic bytes and optional ClamAV scan. */ -export async function validateUploadedFile(filePath: string, allowedMimes: Set): Promise { - assertAllowedFileMagic(filePath, allowedMimes); +/** Validates upload magic bytes and optional ClamAV scan. Returns detected MIME. */ +export async function validateUploadedFile( + filePath: string, + allowedMimes: Set +): Promise { + const detected = assertAllowedFileMagic(filePath, allowedMimes); await scanUploadedFile(filePath); + return detected; } diff --git a/deploy/PRODUCTION_SENTRY_CLAMAV.md b/deploy/PRODUCTION_SENTRY_CLAMAV.md index 948dcad6..8a68f538 100644 --- a/deploy/PRODUCTION_SENTRY_CLAMAV.md +++ b/deploy/PRODUCTION_SENTRY_CLAMAV.md @@ -94,36 +94,49 @@ Le backend scanne les uploads **FAQ** et **Support** via le protocole **INSTREAM ### 2.1 Activer le service Docker -Le service `clamav` est défini dans `docker-compose.yml` avec le profil **`clamav`** (opt-in). +Le service `clamav` est défini dans `docker-compose.yml` avec le profil **`clamav`**. + +Les commandes VPS Phase B démarrent **déjà** ClamAV avec la stack : ```bash -# Démarrer ClamAV + mettre à jour le backend -docker compose --profile clamav up -d clamav -docker compose up -d backend +sudo npm run phase-b:up:https # HTTPS + clamav +sudo npm run phase-b:up # HTTP + clamav +sudo npm run phase-b:up:ssl # SSL + clamav +sudo npm run phase-b:init:https # migrate + HTTPS + clamav ``` +Pas besoin d’une commande ClamAV séparée. + Le conteneur `clamav` : - Télécharge les signatures virales au premier démarrage (`freshclam`) — **2 à 10 minutes** - Expose le port **3310** uniquement sur le réseau interne `prediqo-net` (pas exposé sur l’hôte) -### 2.2 Variables d’environnement +> Au premier boot, attendez que clamd soit prêt avant de tester les uploads (`docker compose logs -f clamav`). -Dans le `.env` racine : +### 2.2 Variables d’environnement (`.env` VPS) + +À ajouter / vérifier dans le `.env` **racine** du VPS (même fichier que `DATABASE_URL`, `JWT_SECRET`, etc.) : ```env +# ClamAV — scan antivirus des uploads Support / FAQ CLAMAV_ENABLED=true CLAMAV_HOST=clamav CLAMAV_PORT=3310 CLAMAV_TIMEOUT_MS=60000 ``` -`CLAMAV_HOST=clamav` correspond au **nom du service** Docker sur `prediqo-net`. +| Variable | Valeur VPS | Pourquoi | +|----------|------------|----------| +| `CLAMAV_ENABLED` | `true` | Force le scan (sinon déjà on si `NODE_ENV=production`) | +| `CLAMAV_HOST` | `clamav` | Nom du **service Docker** sur `prediqo-net` (pas `127.0.0.1`) | +| `CLAMAV_PORT` | `3310` | Port clamd interne | +| `CLAMAV_TIMEOUT_MS` | `60000` | Délai confortable pendant le 1er `freshclam` | -Puis redémarrez l’API : +Puis un seul redémarrage de stack : ```bash -docker compose up -d backend +sudo npm run phase-b:up:https ``` ### 2.3 Vérification @@ -197,8 +210,8 @@ Le canal sécurité fonctionne dès que Redis et `backend-ws` tournent — indé [ ] VITE_SENTRY_DSN dans .env racine [ ] Rebuild prediqo-web après ajout VITE_SENTRY_DSN [ ] Test issue Sentry backend (5xx) -[ ] docker compose --profile clamav up -d clamav -[ ] CLAMAV_ENABLED=true, CLAMAV_HOST=clamav +[ ] `.env` VPS : CLAMAV_ENABLED=true, CLAMAV_HOST=clamav, CLAMAV_PORT=3310, CLAMAV_TIMEOUT_MS=60000 +[ ] `sudo npm run phase-b:up:https` (démarre aussi le profil clamav) [ ] Redémarrage backend [ ] Test upload EICAR → 422 [ ] npm run db:migrate (si pas fait depuis P4/P5) diff --git a/docker-compose.yml b/docker-compose.yml index 9e85cef5..c5b593c5 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -89,7 +89,8 @@ x-backend-common: &backend-common SENTRY_DSN: ${SENTRY_DSN:-} SENTRY_TRACES_SAMPLE_RATE: ${SENTRY_TRACES_SAMPLE_RATE:-0.1} SENTRY_RELEASE: ${SENTRY_RELEASE:-} - CLAMAV_ENABLED: ${CLAMAV_ENABLED:-false} + # Empty = auto (on in production NODE_ENV). Set true/false to force. + CLAMAV_ENABLED: ${CLAMAV_ENABLED:-} CLAMAV_HOST: ${CLAMAV_HOST:-clamav} CLAMAV_PORT: ${CLAMAV_PORT:-3310} CLAMAV_TIMEOUT_MS: ${CLAMAV_TIMEOUT_MS:-30000} diff --git a/package.json b/package.json index 9b1c91a0..8558b36f 100644 --- a/package.json +++ b/package.json @@ -3,20 +3,20 @@ "private": true, "description": "Tloto monorepo — Phase B Docker Compose helpers", "scripts": { - "phase-b:init": "docker compose run --rm --no-deps --build backend node dist/db/migrate.js && docker compose --profile http up -d --build", - "phase-b:init:https": "docker compose run --rm --no-deps --build backend node dist/db/migrate.js && docker compose --profile https-dns up -d --build", - "phase-b:up": "docker compose --profile http up -d --build && docker restart vps_gateway_nginx >/dev/null 2>&1 || true", + "phase-b:init": "docker compose run --rm --no-deps --build backend node dist/db/migrate.js && docker compose --profile http --profile clamav up -d --build", + "phase-b:init:https": "docker compose run --rm --no-deps --build backend node dist/db/migrate.js && docker compose --profile https-dns --profile clamav up -d --build", + "phase-b:up": "docker compose --profile http --profile clamav up -d --build && docker restart vps_gateway_nginx >/dev/null 2>&1 || true", "docker:local:up": "docker compose --env-file .env.docker --profile http up -d --build", "docker:local:init": "docker compose --env-file .env.docker run --rm --no-deps --build backend node dist/db/migrate.js && docker compose --env-file .env.docker --profile http up -d --build", "docker:local:down": "docker compose --env-file .env.docker --profile http down", "docker:local:migrate": "docker compose --env-file .env.docker run --rm --no-deps backend node dist/db/migrate.js", "docker:local:logs": "docker compose --env-file .env.docker logs -f nginx backend backend-engine backend-ws backend-worker-bets redis prediqo-web", "docker:local:status": "docker compose --env-file .env.docker ps", - "phase-b:up:https": "docker compose --profile https-dns up -d --build && docker restart vps_gateway_nginx >/dev/null 2>&1 || true", - "phase-b:up:ssl": "docker compose --profile ssl up -d --build && docker restart vps_gateway_nginx >/dev/null 2>&1 || true", - "phase-b:down": "docker compose down", - "phase-b:logs": "docker compose logs -f nginx-https-dns nginx backend backend-engine backend-ws backend-worker-bets redis prediqo-web", - "phase-b:restart": "docker compose --profile https-dns restart nginx-https-dns backend backend-engine backend-ws backend-worker-bets prediqo-web", + "phase-b:up:https": "docker compose --profile https-dns --profile clamav up -d --build && docker restart vps_gateway_nginx >/dev/null 2>&1 || true", + "phase-b:up:ssl": "docker compose --profile ssl --profile clamav up -d --build && docker restart vps_gateway_nginx >/dev/null 2>&1 || true", + "phase-b:down": "docker compose --profile clamav down", + "phase-b:logs": "docker compose logs -f nginx-https-dns nginx backend backend-engine backend-ws backend-worker-bets redis prediqo-web clamav", + "phase-b:restart": "docker compose --profile https-dns --profile clamav restart nginx-https-dns backend backend-engine backend-ws backend-worker-bets prediqo-web clamav", "phase-b:status": "docker compose ps", "gateway:reload": "docker restart vps_gateway_nginx", "monitoring:up": "docker compose --profile monitoring up -d", diff --git a/prediqo_mobile/lib/data/repositories/support_repository.dart b/prediqo_mobile/lib/data/repositories/support_repository.dart index d4f48d0b..0417b5ca 100644 --- a/prediqo_mobile/lib/data/repositories/support_repository.dart +++ b/prediqo_mobile/lib/data/repositories/support_repository.dart @@ -185,4 +185,16 @@ class SupportRepository { final base = _api.baseUrl.replaceAll(RegExp(r'/$'), ''); return '$base$relativeUrl'; } + + /// Headers so [Image.network] / download requests pass support auth. + Future> attachmentRequestHeaders() async { + final headers = { + 'X-Support-Visitor-Token': await visitorToken(), + }; + final token = await _api.readAccessToken(); + if (token != null && token.isNotEmpty) { + headers['Authorization'] = 'Bearer $token'; + } + return headers; + } } diff --git a/prediqo_mobile/lib/features/support/presentation/support_widget.dart b/prediqo_mobile/lib/features/support/presentation/support_widget.dart index 62608424..81197974 100644 --- a/prediqo_mobile/lib/features/support/presentation/support_widget.dart +++ b/prediqo_mobile/lib/features/support/presentation/support_widget.dart @@ -745,10 +745,23 @@ class _MessageBubble extends StatelessWidget { errorBuilder: (_, __, ___) => errorChild, ); } - return Image.network( - repo.attachmentFullUrl(url), - fit: BoxFit.cover, - errorBuilder: (_, __, ___) => errorChild, + return FutureBuilder>( + future: repo.attachmentRequestHeaders(), + builder: (context, snap) { + if (!snap.hasData) { + return const SizedBox( + width: 24, + height: 24, + child: CircularProgressIndicator(strokeWidth: 2), + ); + } + return Image.network( + repo.attachmentFullUrl(url), + headers: snap.data, + fit: BoxFit.cover, + errorBuilder: (_, __, ___) => errorChild, + ); + }, ); } diff --git a/prediqo_web/src/features/support/api/supportApi.ts b/prediqo_web/src/features/support/api/supportApi.ts index b03c14f2..af7ca157 100644 --- a/prediqo_web/src/features/support/api/supportApi.ts +++ b/prediqo_web/src/features/support/api/supportApi.ts @@ -177,10 +177,22 @@ export async function adminSupportUnreadCount() { return res.data.unreadCount; } +/** Absolute support attachment URL with auth query params (needed for /). */ export function attachmentFullUrl(relativeUrl: string): string { const base = api.defaults.baseURL ?? ''; - if (relativeUrl.startsWith('http')) return relativeUrl; - return `${base.replace(/\/$/, '')}${relativeUrl}`; + const raw = relativeUrl.startsWith('http') + ? relativeUrl + : `${base.replace(/\/$/, '')}${relativeUrl}`; + try { + const url = new URL(raw, typeof window !== 'undefined' ? window.location.origin : 'http://localhost'); + const visitor = supportVisitorHeaders()['X-Support-Visitor-Token']; + if (visitor) url.searchParams.set('visitorToken', visitor); + const accessToken = readAuth().accessToken; + if (accessToken) url.searchParams.set('accessToken', accessToken); + return url.toString(); + } catch { + return raw; + } } const IMAGE_EXT = /\.(jpe?g|png|gif|webp|bmp|heic)$/i;