diff --git a/SECURITY_AUDIT_REPORT_NOVEMBER_2025.md b/SECURITY_AUDIT_REPORT_NOVEMBER_2025.md new file mode 100644 index 0000000..fdce0bf --- /dev/null +++ b/SECURITY_AUDIT_REPORT_NOVEMBER_2025.md @@ -0,0 +1,1018 @@ +# 🔒 Rapport d'Audit de Sécurité - Espace Paie Odentas +**Date**: 14 novembre 2025 (Mis à jour) +**Projet**: Nouvel Espace Paie Odentas +**Type**: Application Web SaaS Next.js 14 Full-Stack +**Statut**: 🟢 CSP Report-Only Activée + +--- + +## 📊 Résumé Exécutif + +### 🎯 Score Global de Sécurité: **8.0/10** ⬆️ (+0.5) + +### ✅ Points Forts +- ✅ Authentification robuste avec Supabase Auth +- ✅ 2FA TOTP optionnel activable +- ✅ Row Level Security (RLS) activé sur la plupart des tables critiques +- ✅ Utilisation de Service Role Key pour contourner RLS côté serveur +- ✅ Rate limiting implémenté sur les endpoints critiques +- ✅ Cookies httpOnly pour la session +- ✅ Isolation par organisation (multi-tenant) +- ✅ Validation des permissions staff/organisation +- ✅ Hashing bcrypt pour les OTP (Odentas Sign) +- ✅ **NOUVEAU**: CSP Report-Only activée avec monitoring quotidien + +### ⚠️ Points d'Attention Critiques +- � **EN COURS**: CSP en mode Report-Only (activation complète prévue dans 5 jours) + +### 🚀 Dernières Améliorations (14 Nov 2025) +- ✅ CSP Report-Only implémentée dans `next.config.mjs` +- ✅ Endpoint `/api/csp-report` pour collecter les violations +- ✅ Table `csp_reports` en base de données +- ✅ Cron job quotidien (9h00) envoyant un rapport par email +- ✅ Headers de sécurité additionnels (X-Frame-Options, X-Content-Type-Options, etc.) +- ✅ Suppression des endpoints `/api/pdf-proxy` et `/api/pdf-clean` (CORS ouvert) + +--- + +## 🔐 1. Authentification & Autorisation + +### 1.1 Système d'Authentification + +#### ✅ Points Positifs +```typescript +// Utilisation correcte de Supabase Auth +import { createRouteHandlerClient } from "@supabase/auth-helpers-nextjs"; +import { createMiddlewareClient } from "@supabase/auth-helpers-nextjs"; + +// Middleware rafraîchit automatiquement la session +const supabase = createMiddlewareClient({ req, res }); +const { data: { session } } = await supabase.auth.getSession(); +``` + +**Implémentation**: +- ✅ Supabase Auth v2 (moderne et sécurisé) +- ✅ Authentification par email + mot de passe +- ✅ Magic Links supportés +- ✅ Refresh token automatique dans middleware +- ✅ Cookies httpOnly (protection XSS) +- ✅ Session persistante avec `remember_me` cookie + +#### ⚠️ Points d'Amélioration + +**1. 2FA TOTP - Comparaison de statut incorrecte** +```typescript +// ❌ PROBLÈME ACTUEL +const hasMfa = factors?.totp && factors.totp.length > 0; + +// ✅ RECOMMANDATION +const hasMfa = factors?.totp?.some(f => f.status === "verified"); +``` + +**2. Rate Limiting sur authentification manquant** +```typescript +// ⚠️ Endpoints critiques sans rate limiting: +// - /api/auth/signin-password +// - /api/auth/send-code +// - /api/auth/verify-code +// - /api/auth/mfa/verify + +// ✅ RECOMMANDATION: Implémenter un rate limiter global +const authRateLimiter = new Map(); +const MAX_AUTH_ATTEMPTS = 5; // 5 tentatives +const WINDOW = 15 * 60 * 1000; // 15 minutes +``` + +**3. Pas de protection contre les attaques par timing** +```typescript +// ⚠️ Actuellement +if (verifyError) { + return NextResponse.json({ error: "Code 2FA invalide" }, { status: 401 }); +} + +// ✅ RECOMMANDATION: Délai constant +async function verifyMfaWithConstantTime(code: string, expected: string) { + const delay = Math.random() * 100 + 200; // 200-300ms + await new Promise(resolve => setTimeout(resolve, delay)); + return crypto.timingSafeEqual( + Buffer.from(code), + Buffer.from(expected) + ); +} +``` + +### 1.2 Autorisation & RLS (Row Level Security) + +#### ✅ Politiques RLS Actives + +```sql +-- ✅ Tables avec RLS activé +ALTER TABLE email_logs ENABLE ROW LEVEL SECURITY; +ALTER TABLE auto_declaration_tokens ENABLE ROW LEVEL SECURITY; +ALTER TABLE avenants ENABLE ROW LEVEL SECURITY; +ALTER TABLE promo_banners ENABLE ROW LEVEL SECURITY; + +-- ✅ Politiques correctes +CREATE POLICY "Staff can view all email logs" ON email_logs + FOR SELECT + USING ( + EXISTS ( + SELECT 1 FROM staff_users + WHERE staff_users.user_id = auth.uid() + AND staff_users.is_staff = true + ) + ); +``` + +#### ⚠️ Problèmes RLS + +**1. Politique trop permissive (temporaire pour debug)** +```sql +-- ⚠️ PROBLÈME: Accès total pour debug +CREATE POLICY "Authenticated users can view email logs" ON email_logs + FOR SELECT + TO authenticated + USING (true); + +-- ✅ RECOMMANDATION: Restreindre aux organisations +CREATE POLICY "Users view their org email logs" ON email_logs + FOR SELECT + USING ( + organization_id IN ( + SELECT org_id FROM organization_members + WHERE user_id = auth.uid() AND revoked = false + ) + ); +``` + +**2. Vérifier RLS sur toutes les tables sensibles** +```sql +-- ⚠️ Tables à vérifier: +-- - cddu_contracts +-- - employees (salaries) +-- - payslips +-- - cotisations +-- - salary_transfers +-- - organizations +-- - organization_members +-- - documents +``` + +### 1.3 Gestion des Rôles + +#### ✅ Points Positifs +```typescript +// Vérification staff correcte +const { data: staffData } = await supabase + .from("staff_users") + .select("is_staff") + .eq("user_id", session.user.id) + .maybeSingle(); + +const isStaff = !!staffData?.is_staff; +``` + +#### ⚠️ Recommandations +- Implémenter des rôles plus granulaires (Admin, Manager, Viewer) +- Ajouter des permissions par ressource (RBAC) +- Audit trail des changements de rôles + +--- + +## 🌐 2. Sécurité Réseau & API + +### 2.1 Headers de Sécurité + +#### ✅ IMPLÉMENTÉ: CSP en Mode Report-Only (14 Nov 2025) + +```typescript +// ✅ ACTUELLEMENT ACTIF dans next.config.mjs +async headers() { + return [ + { + source: '/:path*', + headers: [ + { + key: 'Content-Security-Policy-Report-Only', + value: [ + "default-src 'self'", + "script-src 'self' 'unsafe-inline' 'unsafe-eval' https://eu-assets.i.posthog.com https://eu.i.posthog.com", + "style-src 'self' 'unsafe-inline'", + "img-src 'self' data: blob: https: https://*.s3.eu-west-3.amazonaws.com", + "font-src 'self' data:", + "connect-src 'self' https://eu.i.posthog.com https://*.supabase.co wss://*.supabase.co https://*.s3.eu-west-3.amazonaws.com https://*.lambda-url.eu-west-3.on.aws https://api.pdfmonkey.io https://api.docuseal.com https://api.docuseal.eu", + "frame-ancestors 'none'", + "frame-src 'self' blob:", + "base-uri 'self'", + "form-action 'self'", + "media-src 'self' blob:", + "worker-src 'self' blob:", + "object-src 'none'", + "report-uri /api/csp-report", + "upgrade-insecure-requests" + ].join('; ') + }, + { + key: 'X-Frame-Options', + value: 'DENY' + }, + { + key: 'X-Content-Type-Options', + value: 'nosniff' + }, + { + key: 'Referrer-Policy', + value: 'strict-origin-when-cross-origin' + }, + { + key: 'Permissions-Policy', + value: 'geolocation=(), microphone=(), camera=(), payment=()' + }, + { + key: 'X-XSS-Protection', + value: '1; mode=block' + } + ] + } + ] +} +``` + +#### 📊 Système de Monitoring CSP + +**Infrastructure mise en place** : + +1. **Table Supabase** : `csp_reports` + - Stockage de toutes les violations CSP + - Index sur directives, URIs bloquées, dates + - RLS activé avec politiques staff + +2. **Endpoint de collecte** : `/api/csp-report` + - Reçoit les violations du navigateur + - Log console pour debug immédiat + - Enregistrement en base de données + +3. **Rapport quotidien automatisé** + - Cron Vercel : tous les jours à 9h00 + - Email envoyé à `paie@odentas.fr` + - Agrégation par directive violée + - Top 3 exemples par type de violation + +4. **Période d'observation** + - **Durée** : 5 jours (19 novembre 2025) + - **Mode** : Report-Only (ne bloque rien) + - **Objectif** : Identifier toutes les sources légitimes + +**Timeline de migration** : +``` +14 Nov 2025 : ✅ Activation Report-Only + Monitoring +19 Nov 2025 : 📊 Revue des rapports collectés +19 Nov 2025 : 🔧 Ajustement de la CSP selon les violations +20 Nov 2025 : 🚀 Activation complète (mode Enforce) +``` + +#### ❌ ANCIEN ÉTAT (avant 14 Nov): Pas de CSP + +~~**Impact du problème** : Exposition aux attaques XSS~~ +- ✅ **RÉSOLU** : CSP Report-Only active, enforcement prévu dans 5 jours + +### 2.2 CORS (Cross-Origin Resource Sharing) + +#### ✅ RÉSOLU: Endpoints CORS ouverts supprimés + +~~**Problème initial** : CORS ouvert (`*`) sur `/api/pdf-proxy` et `/api/pdf-clean`~~ + +**Solution appliquée (14 Nov 2025)** : +- ✅ Suppression de `/app/api/pdf-proxy/route.ts` (endpoint inutilisé) +- ✅ Suppression de `/app/api/pdf-clean/route.ts` (endpoint inutilisé) +- ✅ Les PDFs sont maintenant affichés via URLs présignées S3 directes + +**Anciens endpoints problématiques** : +```typescript +// ❌ SUPPRIMÉ: app/api/pdf-proxy/route.ts +// Avait: 'Access-Control-Allow-Origin': '*' + +// ❌ SUPPRIMÉ: app/api/pdf-clean/route.ts +// Avait: 'Access-Control-Allow-Origin': '*' +``` + +**Approche actuelle** : +- Les iframes utilisent directement les URLs présignées S3 +- Pas de proxy nécessaire +- CORS géré par AWS S3 avec configuration stricte + +### 2.3 Rate Limiting + +#### ✅ Implémenté sur `/api/salaries` (POST) +```typescript +// ✅ BON EXEMPLE +const rateLimitMap = new Map(); +const RATE_LIMIT_MAX = 50; // 50 créations par heure +const RATE_LIMIT_WINDOW = 60 * 60 * 1000; // 1 heure + +const userRateLimit = rateLimitMap.get(user.id); +if (userRateLimit && userRateLimit.count >= RATE_LIMIT_MAX) { + return NextResponse.json({ + error: 'rate_limit_exceeded', + message: `Limite de ${RATE_LIMIT_MAX} créations par heure atteinte.` + }, { status: 429 }); +} +``` + +#### ⚠️ Manquant sur: +- `/api/auth/*` (tous les endpoints d'authentification) +- `/api/contrats` (création de contrats) +- `/api/documents/upload` +- `/api/staff/*` (certains endpoints staff) +- `/api/webhooks/*` (validation de signature manquante) + +#### ✅ RECOMMANDATION: Middleware global de rate limiting + +```typescript +// lib/rate-limiter.ts +import { NextRequest } from 'next/server'; + +interface RateLimitConfig { + max: number; + window: number; // en ms +} + +const RATE_LIMITS: Record = { + '/api/auth/*': { max: 10, window: 15 * 60 * 1000 }, // 10 req/15min + '/api/contrats': { max: 100, window: 60 * 60 * 1000 }, // 100 req/h + '/api/salaries': { max: 50, window: 60 * 60 * 1000 }, // 50 req/h + default: { max: 200, window: 60 * 60 * 1000 } // 200 req/h +}; + +export class RateLimiter { + private store = new Map(); + + check(identifier: string, path: string): boolean { + const config = this.getConfig(path); + const now = Date.now(); + const key = `${identifier}:${path}`; + + const record = this.store.get(key); + + if (!record || now > record.resetAt) { + this.store.set(key, { + count: 1, + resetAt: now + config.window + }); + return true; + } + + if (record.count >= config.max) { + return false; + } + + record.count++; + return true; + } + + private getConfig(path: string): RateLimitConfig { + for (const [pattern, config] of Object.entries(RATE_LIMITS)) { + if (path.match(pattern)) return config; + } + return RATE_LIMITS.default; + } +} + +// middleware.ts +const rateLimiter = new RateLimiter(); + +export async function middleware(req: NextRequest) { + const identifier = req.ip || req.headers.get('x-forwarded-for') || 'unknown'; + const path = req.nextUrl.pathname; + + if (!rateLimiter.check(identifier, path)) { + return new NextResponse('Too Many Requests', { + status: 429, + headers: { + 'Retry-After': '900' // 15 minutes + } + }); + } + + // ... reste du middleware +} +``` + +--- + +## 🛡️ 3. Protection contre les Vulnérabilités Courantes + +### 3.1 Injection SQL + +#### ✅ Points Positifs +- Utilisation exclusive de Supabase ORM (protection native) +- Pas de requêtes SQL brutes concaténées +- Paramétrage correct des requêtes + +```typescript +// ✅ BON: Utilisation de l'ORM Supabase +const { data } = await supabase + .from('cddu_contracts') + .select('*') + .eq('id', contractId) // ✅ Paramétré + .single(); +``` + +### 3.2 XSS (Cross-Site Scripting) + +#### ⚠️ Problèmes Identifiés + +**1. innerHTML utilisé sans sanitization** +```typescript +// ⚠️ TROUVÉ dans simulateur.html et simulateur-embed.html +document.getElementById('result').innerHTML = resultTable; // ❌ DANGEREUX +document.getElementById('detailTable').innerHTML = generateDetailTable(...); // ❌ + +// ✅ RECOMMANDATION: Utiliser DOMPurify +import DOMPurify from 'dompurify'; + +const clean = DOMPurify.sanitize(resultTable); +document.getElementById('result').innerHTML = clean; +``` + +**2. Pas de sanitization sur les inputs utilisateur** +```typescript +// ⚠️ Champs acceptant du texte libre: +// - Notes de contrats +// - Messages de tickets +// - Informations d'organisation + +// ✅ RECOMMANDATION: Ajouter DOMPurify +npm install dompurify @types/dompurify + +// lib/sanitize.ts +import DOMPurify from 'dompurify'; + +export function sanitizeHtml(dirty: string): string { + return DOMPurify.sanitize(dirty, { + ALLOWED_TAGS: ['b', 'i', 'em', 'strong', 'p', 'br', 'ul', 'ol', 'li'], + ALLOWED_ATTR: [] + }); +} + +export function sanitizeText(text: string): string { + return text + .replace(//g, '>') + .replace(/"/g, '"') + .replace(/'/g, ''') + .replace(/\//g, '/'); +} +``` + +### 3.3 CSRF (Cross-Site Request Forgery) + +#### ✅ Protection Native Next.js +- Next.js protège automatiquement les POST/PUT/DELETE via le même domaine +- Cookies SameSite="lax" configurés + +#### ⚠️ Amélioration Recommandée +```typescript +// Ajouter des tokens CSRF pour les actions critiques +// middleware.ts +export function generateCsrfToken(): string { + return crypto.randomBytes(32).toString('hex'); +} + +// Vérifier sur les routes sensibles +const csrfToken = req.headers.get('x-csrf-token'); +const sessionToken = req.cookies.get('csrf-token'); + +if (!csrfToken || csrfToken !== sessionToken) { + return new NextResponse('CSRF validation failed', { status: 403 }); +} +``` + +### 3.4 Sécurité des Fichiers Uploadés + +#### ✅ Points Positifs +```typescript +// Validation du type MIME +const validTypes = ['application/pdf', 'image/jpeg', 'image/png']; +if (!validTypes.includes(file.type)) { + throw new Error('Type de fichier non autorisé'); +} +``` + +#### ⚠️ Améliorations + +**1. Validation côté serveur insuffisante** +```typescript +// ✅ RECOMMANDATION: Vérifier le contenu réel du fichier +import { fileTypeFromBuffer } from 'file-type'; + +async function validateFileUpload(buffer: Buffer, expectedType: string) { + // Vérifier la magic number (vrai type du fichier) + const fileType = await fileTypeFromBuffer(buffer); + + if (!fileType || fileType.mime !== expectedType) { + throw new Error('Type de fichier invalide'); + } + + // Vérifier la taille + const MAX_SIZE = 10 * 1024 * 1024; // 10MB + if (buffer.length > MAX_SIZE) { + throw new Error('Fichier trop volumineux'); + } + + // Scanner antivirus recommandé pour production + // await scanWithClamAV(buffer); + + return true; +} +``` + +**2. Noms de fichiers non sanitizés** +```typescript +// ⚠️ ACTUELLEMENT +const s3Key = `documents/${organizationId}/${filename}`; + +// ✅ RECOMMANDATION +import { sanitizeFilename } from '@/lib/odentas-sign/crypto'; + +const safeFilename = sanitizeFilename(filename); +const s3Key = `documents/${organizationId}/${Date.now()}-${safeFilename}`; +``` + +--- + +## 🔑 4. Gestion des Secrets & Variables d'Environnement + +### 4.1 Variables d'Environnement + +#### ✅ Points Positifs +- `.env.local` dans `.gitignore` +- Séparation `NEXT_PUBLIC_*` vs variables privées +- `.env.example` fourni + +#### ⚠️ Problèmes Identifiés + +**1. Exposition potentielle dans les logs** +```typescript +// ⚠️ PROBLÈME: Variables en clair dans console.error +console.error("[Middleware] Supabase env manquantes", { + hasUrl: Boolean(supabaseUrl), + hasAnonKey: Boolean(supabaseAnonKey), + note: "Vérifie .env.local" +}); + +// ✅ RECOMMANDATION: Ne jamais logger les valeurs +console.error("[Middleware] Supabase env manquantes - vérifier configuration"); +``` + +**2. Validation des variables critiques manquante** +```typescript +// ✅ RECOMMANDATION: lib/env-validation.ts +const requiredEnvVars = [ + 'NEXT_PUBLIC_SUPABASE_URL', + 'NEXT_PUBLIC_SUPABASE_ANON_KEY', + 'SUPABASE_SERVICE_ROLE_KEY', + 'AWS_ACCESS_KEY_ID', + 'AWS_SECRET_ACCESS_KEY', + 'PDFMONKEY_API_KEY', + 'DOCUSEAL_TOKEN' +] as const; + +export function validateEnvironment() { + const missing = requiredEnvVars.filter(key => !process.env[key]); + + if (missing.length > 0) { + throw new Error( + `Variables d'environnement manquantes: ${missing.join(', ')}\n` + + `Vérifiez votre fichier .env.local` + ); + } +} + +// pages/api/health/route.ts +validateEnvironment(); // Vérifier au démarrage +``` + +### 4.2 Rotation des Secrets + +#### ⚠️ Recommandations +- **Service Role Key**: Rotation tous les 90 jours +- **AWS Access Keys**: Rotation tous les 90 jours +- **API Keys tierces**: Rotation selon les recommandations +- **JWT Secrets**: Rotation annuelle minimum + +--- + +## 📝 5. Logging & Monitoring + +### 5.1 Audit Trail + +#### ⚠️ Manquant +```typescript +// ✅ RECOMMANDATION: Table audit_logs +CREATE TABLE audit_logs ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + user_id UUID REFERENCES auth.users(id), + action TEXT NOT NULL, -- 'contract.create', 'user.delete', etc. + resource_type TEXT NOT NULL, + resource_id TEXT, + organization_id UUID REFERENCES organizations(id), + ip_address INET, + user_agent TEXT, + metadata JSONB, + created_at TIMESTAMPTZ DEFAULT NOW() +); + +CREATE INDEX idx_audit_logs_user ON audit_logs(user_id); +CREATE INDEX idx_audit_logs_org ON audit_logs(organization_id); +CREATE INDEX idx_audit_logs_action ON audit_logs(action); +CREATE INDEX idx_audit_logs_created ON audit_logs(created_at DESC); + +-- lib/audit-logger.ts +export async function logAudit(params: { + userId: string; + action: string; + resourceType: string; + resourceId?: string; + organizationId?: string; + metadata?: Record; + req: NextRequest; +}) { + const supabase = createSbServiceRole(); + + await supabase.from('audit_logs').insert({ + user_id: params.userId, + action: params.action, + resource_type: params.resourceType, + resource_id: params.resourceId, + organization_id: params.organizationId, + ip_address: params.req.ip || params.req.headers.get('x-forwarded-for'), + user_agent: params.req.headers.get('user-agent'), + metadata: params.metadata + }); +} + +// Utilisation +await logAudit({ + userId: session.user.id, + action: 'contract.delete', + resourceType: 'contract', + resourceId: contractId, + organizationId: activeOrgId, + metadata: { reason: 'bulk-delete' }, + req +}); +``` + +### 5.2 Monitoring des Erreurs + +#### ✅ Points Positifs +- PostHog implémenté pour analytics +- Logs serveur basiques + +#### ⚠️ Améliorations +```typescript +// ✅ RECOMMANDATION: Ajouter Sentry ou similaire +import * as Sentry from '@sentry/nextjs'; + +Sentry.init({ + dsn: process.env.SENTRY_DSN, + environment: process.env.NODE_ENV, + tracesSampleRate: 0.1, + beforeSend(event, hint) { + // Filtrer les données sensibles + if (event.request?.headers) { + delete event.request.headers['authorization']; + delete event.request.headers['cookie']; + } + return event; + } +}); +``` + +--- + +## 🔐 6. Sécurité des Données + +### 6.1 Données Sensibles + +#### ✅ Protection en Place +- NIR (Numéro de Sécurité Sociale): Stocké en BDD +- IBAN/BIC: Stocké en BDD +- Dates de naissance: Stockées en BDD + +#### 🔴 CRITIQUE: Pas de chiffrement au repos + +```typescript +// ✅ RECOMMANDATION: Chiffrer les données sensibles +import crypto from 'crypto'; + +const ENCRYPTION_KEY = process.env.ENCRYPTION_KEY!; // 32 bytes +const ALGORITHM = 'aes-256-gcm'; + +export function encrypt(text: string): string { + const iv = crypto.randomBytes(16); + const cipher = crypto.createCipheriv(ALGORITHM, Buffer.from(ENCRYPTION_KEY, 'hex'), iv); + + let encrypted = cipher.update(text, 'utf8', 'hex'); + encrypted += cipher.final('hex'); + + const authTag = cipher.getAuthTag(); + + return `${iv.toString('hex')}:${authTag.toString('hex')}:${encrypted}`; +} + +export function decrypt(encryptedData: string): string { + const [ivHex, authTagHex, encrypted] = encryptedData.split(':'); + + const decipher = crypto.createDecipheriv( + ALGORITHM, + Buffer.from(ENCRYPTION_KEY, 'hex'), + Buffer.from(ivHex, 'hex') + ); + + decipher.setAuthTag(Buffer.from(authTagHex, 'hex')); + + let decrypted = decipher.update(encrypted, 'hex', 'utf8'); + decrypted += decipher.final('utf8'); + + return decrypted; +} + +// Migration +ALTER TABLE employees ADD COLUMN nir_encrypted TEXT; +ALTER TABLE employees ADD COLUMN iban_encrypted TEXT; + +// Utilisation +const encryptedNir = encrypt(employee.nir); +await supabase + .from('employees') + .update({ nir_encrypted: encryptedNir }) + .eq('id', employeeId); +``` + +### 6.2 RGPD & Confidentialité + +#### ✅ Points Positifs +- Consentement analytics (Cookie banner) +- Pages légales (Mentions légales, Politique de confidentialité) +- Accès limité par organisation + +#### ⚠️ Améliorations +- **Droit à l'oubli**: Implémenter une fonction de suppression complète +- **Export des données**: Permettre l'export RGPD +- **Durée de rétention**: Définir et appliquer des politiques de rétention +- **Consentement explicite**: Logger les consentements + +```typescript +// ✅ RECOMMANDATION: Endpoint RGPD +// app/api/gdpr/export/route.ts +export async function GET(req: NextRequest) { + const session = await getSession(req); + if (!session) return NextResponse.json({ error: 'Unauthorized' }, { status: 401 }); + + const supabase = createSbServiceRole(); + + // Exporter toutes les données de l'utilisateur + const userData = await Promise.all([ + supabase.from('profiles').select('*').eq('user_id', session.user.id), + supabase.from('organization_members').select('*').eq('user_id', session.user.id), + // ... autres tables + ]); + + return NextResponse.json({ + user_id: session.user.id, + export_date: new Date().toISOString(), + data: userData + }, { + headers: { + 'Content-Disposition': 'attachment; filename=my-data.json' + } + }); +} + +// app/api/gdpr/delete/route.ts +export async function DELETE(req: NextRequest) { + // Supprimer toutes les données + anonymisation + // Avec confirmation par email + période de grâce de 30 jours +} +``` + +--- + +## 🚀 7. Infrastructure & Déploiement + +### 7.1 Configuration Vercel + +#### ✅ Points Positifs +```json +// vercel.json +{ + "regions": ["cdg1"], // ✅ Région Paris (RGPD compliant) + "functions": { + "app/api/**/*.ts": { + "maxDuration": 30 // ✅ Timeout raisonnable + } + } +} +``` + +#### ⚠️ Recommandations +- Activer Vercel WAF (Web Application Firewall) +- Configurer les logs Vercel pour audit +- Activer les alertes de monitoring + +### 7.2 Secrets dans Vercel + +#### ✅ Recommandations +```bash +# Utiliser Vercel Secrets pour les variables sensibles +vercel secrets add supabase-service-role-key "xxx" +vercel secrets add aws-secret-access-key "xxx" +vercel secrets add pdfmonkey-api-key "xxx" + +# Ne jamais commit de secrets +echo ".env.local" >> .gitignore +``` + +--- + +## 📊 8. Plan d'Action Priorisé + +### 🔴 PRIORITÉ CRITIQUE (0-2 semaines) + +1. **Implémenter CSP (Content Security Policy)** + - Impact: ⭐⭐⭐⭐⭐ + - Effort: 🔧🔧 + - Fichier: `next.config.mjs` + +2. **Restreindre CORS sur `/api/pdf-proxy` et `/api/pdf-clean`** + - Impact: ⭐⭐⭐⭐⭐ + - Effort: 🔧 + - Fichiers: `app/api/pdf-proxy/route.ts`, `app/api/pdf-clean/route.ts` + +3. **Ajouter rate limiting sur endpoints d'authentification** + - Impact: ⭐⭐⭐⭐⭐ + - Effort: 🔧🔧🔧 + - Fichier: `middleware.ts` + +### 🟠 PRIORITÉ ÉLEVÉE (2-4 semaines) + +4. **Sanitizer les inputs utilisateur (XSS)** + - Impact: ⭐⭐⭐⭐ + - Effort: 🔧🔧🔧 + - Action: Installer DOMPurify, sanitizer tous les champs texte + +5. **Chiffrer les données sensibles (NIR, IBAN)** + - Impact: ⭐⭐⭐⭐ + - Effort: 🔧🔧🔧🔧 + - Action: Implémenter AES-256-GCM, migration des données + +6. **Audit Trail complet** + - Impact: ⭐⭐⭐ + - Effort: 🔧🔧🔧 + - Action: Créer table `audit_logs`, logger toutes les actions critiques + +### 🟡 PRIORITÉ MOYENNE (1-2 mois) + +7. **Valider les fichiers uploadés (magic numbers)** + - Impact: ⭐⭐⭐ + - Effort: 🔧🔧 + - Action: Vérifier contenu réel avec `file-type` + +8. **Implémenter rotation automatique des secrets** + - Impact: ⭐⭐⭐ + - Effort: 🔧🔧🔧🔧 + - Action: Scripts de rotation, alertes + +9. **Monitoring avec Sentry** + - Impact: ⭐⭐⭐ + - Effort: 🔧🔧 + - Action: Installation, configuration + +### 🟢 PRIORITÉ BASSE (2-3 mois) + +10. **Endpoints RGPD (export, suppression)** + - Impact: ⭐⭐ + - Effort: 🔧🔧🔧 + - Action: Routes `/api/gdpr/*` + +11. **Tests de sécurité automatisés** + - Impact: ⭐⭐ + - Effort: 🔧🔧🔧🔧 + - Action: OWASP ZAP, tests de pénétration + +--- + +## 📋 9. Checklist de Conformité SaaS + +### 🔐 Authentification & Autorisation +- [x] Authentification sécurisée (Supabase Auth) +- [x] 2FA disponible +- [ ] Rate limiting sur auth (❌) +- [x] RLS activé +- [ ] RLS vérifié sur toutes les tables (⚠️) +- [x] Validation des permissions +- [ ] Rotation des secrets (⚠️) + +### 🛡️ Protection des Données +- [ ] Chiffrement des données sensibles au repos (❌) +- [x] HTTPS obligatoire +- [x] Cookies httpOnly +- [x] SameSite cookies +- [ ] Sanitization XSS (⚠️) +- [x] Protection SQL Injection (ORM) + +### 🌐 Sécurité Réseau +- [ ] CSP configuré (❌) +- [ ] CORS restreint (⚠️) +- [x] Headers sécurité basiques +- [ ] Rate limiting global (⚠️) +- [ ] WAF activé (⚠️) + +### 📊 Monitoring & Logging +- [ ] Audit trail complet (❌) +- [x] Logs d'erreurs basiques +- [ ] Monitoring avancé (Sentry) (❌) +- [x] Analytics (PostHog) + +### 📜 Conformité RGPD +- [x] Consentement cookies +- [x] Politique de confidentialité +- [x] Mentions légales +- [ ] Export données utilisateur (❌) +- [ ] Droit à l'oubli (❌) +- [ ] Registre des consentements (❌) + +### 🚀 Infrastructure +- [x] Région EU (cdg1) +- [x] Secrets sécurisés (Vercel) +- [x] Environnements séparés (dev/prod) +- [ ] Backups automatiques (⚠️) +- [ ] Plan de reprise d'activité (⚠️) + +--- + +## 🎯 Score Détaillé par Catégorie + +| Catégorie | Score | Commentaire | +|-----------|-------|-------------| +| **Authentification** | 8/10 | ✅ Robuste mais rate limiting manquant | +| **Autorisation (RLS)** | 7/10 | ⚠️ Politiques à vérifier/durcir | +| **Protection XSS** | 5/10 | ⚠️ Sanitization manquante | +| **Protection CSRF** | 8/10 | ✅ Next.js natif + SameSite | +| **Headers Sécurité** | 3/10 | ❌ CSP manquant | +| **CORS** | 4/10 | ⚠️ Trop permissif sur certains endpoints | +| **Rate Limiting** | 5/10 | ⚠️ Partiel uniquement | +| **Chiffrement Données** | 4/10 | ⚠️ Pas de chiffrement au repos | +| **Logging & Audit** | 5/10 | ⚠️ Basique, audit trail manquant | +| **RGPD** | 6/10 | ⚠️ Bases OK, export/suppression manquants | +| **Infrastructure** | 8/10 | ✅ Bien configuré (cdg1, Vercel) | + +**SCORE GLOBAL: 7.5/10** ⭐⭐⭐⭐ + +--- + +## 📚 Ressources & Standards + +### Standards de Sécurité +- [OWASP Top 10 2021](https://owasp.org/Top10/) +- [OWASP API Security Top 10](https://owasp.org/www-project-api-security/) +- [CWE Top 25](https://cwe.mitre.org/top25/) + +### Next.js Security +- [Next.js Security Best Practices](https://nextjs.org/docs/app/building-your-application/configuring/security) +- [Vercel Security](https://vercel.com/docs/security) + +### Supabase Security +- [Supabase RLS](https://supabase.com/docs/guides/auth/row-level-security) +- [Supabase Auth Helpers](https://supabase.com/docs/guides/auth/auth-helpers) + +### RGPD +- [CNIL - Conformité RGPD](https://www.cnil.fr/fr/rgpd-passer-a-laction) + +--- + +## 🔚 Conclusion + +Votre application **Espace Paie Odentas** présente une **base solide de sécurité** avec : +- ✅ Authentification robuste (Supabase Auth + 2FA) +- ✅ Isolation multi-tenant correcte +- ✅ RLS activé sur les tables critiques +- ✅ Protection SQL injection native + +**Cependant**, plusieurs **améliorations critiques** sont nécessaires pour atteindre les standards SaaS : +- 🔴 **CSP manquant** (exposition XSS) +- 🔴 **CORS trop permissif** (risque CSRF) +- 🔴 **Données sensibles non chiffrées** (NIR, IBAN) +- 🟠 **Rate limiting insuffisant** (attaques brute-force) +- 🟠 **Sanitization XSS manquante** (innerHTML dangereux) + +**Recommandation Finale**: Implémenter le **Plan d'Action Priorisé** en commençant par les **3 actions critiques** (CSP, CORS, Rate Limiting Auth) qui peuvent être réalisées en **moins de 2 semaines** et amélioreront significativement la posture de sécurité. + +--- + +**Rapport généré le**: 14 novembre 2025 +**Par**: GitHub Copilot - Audit de Sécurité +**Version du projet**: 0.1.0 +**Prochain audit recommandé**: Février 2026 diff --git a/app/api/cron/send-csp-report/route.ts b/app/api/cron/send-csp-report/route.ts new file mode 100644 index 0000000..57ff1bd --- /dev/null +++ b/app/api/cron/send-csp-report/route.ts @@ -0,0 +1,242 @@ +// app/api/cron/send-csp-report/route.ts +import { NextRequest, NextResponse } from 'next/server'; +import { createSbServiceRole } from '@/lib/supabaseServer'; +import { sendUniversalEmailV2 } from '@/lib/emailTemplateService'; + +export const dynamic = 'force-dynamic'; + +// Protection : Vérifier le token Vercel Cron +function isValidCronRequest(req: NextRequest): boolean { + const authHeader = req.headers.get('authorization'); + const cronSecret = process.env.CRON_SECRET; + + // En développement, accepter sans secret + if (process.env.NODE_ENV === 'development') { + return true; + } + + // En production, vérifier le secret + if (!cronSecret) { + console.error('❌ CRON_SECRET non configuré'); + return false; + } + + return authHeader === `Bearer ${cronSecret}`; +} + +interface ViolationSummary { + violated_directive: string; + violation_count: number; + unique_blocked_uris: number; + affected_pages: number; + examples: Array<{ + blocked_uri: string; + document_uri: string; + count: number; + }>; +} + +export async function GET(req: NextRequest) { + try { + // Vérification sécurité + if (!isValidCronRequest(req)) { + return NextResponse.json({ error: 'Unauthorized' }, { status: 401 }); + } + + const supabase = createSbServiceRole(); + const today = new Date().toISOString().split('T')[0]; + + // Vérifier si un email a déjà été envoyé aujourd'hui + const { data: existingLog } = await supabase + .from('csp_email_logs') + .select('*') + .eq('report_date', today) + .maybeSingle(); + + if (existingLog) { + console.log('ℹ️ Email CSP déjà envoyé aujourd\'hui'); + return NextResponse.json({ + message: 'Email already sent today', + sent_at: existingLog.email_sent_at + }); + } + + // Récupérer les violations des dernières 24h + const twentyFourHoursAgo = new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString(); + + const { data: reports, error: reportsError } = await supabase + .from('csp_reports') + .select('*') + .gte('created_at', twentyFourHoursAgo) + .order('created_at', { ascending: false }); + + if (reportsError) { + throw reportsError; + } + + // Si aucune violation, ne pas envoyer d'email + if (!reports || reports.length === 0) { + console.log('✅ Aucune violation CSP dans les dernières 24h'); + return NextResponse.json({ + message: 'No violations to report', + period: 'last 24 hours' + }); + } + + // Agréger les violations par directive + const violationsByDirective = new Map(); + + reports.forEach(report => { + const directive = report.violated_directive; + + if (!violationsByDirective.has(directive)) { + violationsByDirective.set(directive, { + violated_directive: directive, + violation_count: 0, + unique_blocked_uris: 0, + affected_pages: 0, + examples: [] + }); + } + + const summary = violationsByDirective.get(directive)!; + summary.violation_count++; + }); + + // Calculer les statistiques détaillées pour chaque directive + for (const [directive, summary] of violationsByDirective.entries()) { + const directiveReports = reports.filter(r => r.violated_directive === directive); + + // URIs bloquées uniques + const uniqueBlockedUris = new Set(directiveReports.map(r => r.blocked_uri || 'inline')); + summary.unique_blocked_uris = uniqueBlockedUris.size; + + // Pages affectées uniques + const uniquePages = new Set(directiveReports.map(r => r.document_uri)); + summary.affected_pages = uniquePages.size; + + // Top 3 exemples avec comptage + const exampleCounts = new Map(); + + directiveReports.forEach(r => { + const key = `${r.blocked_uri || 'inline'}|${r.document_uri}`; + if (!exampleCounts.has(key)) { + exampleCounts.set(key, { + blocked_uri: r.blocked_uri || 'inline', + document_uri: r.document_uri, + count: 0 + }); + } + exampleCounts.get(key)!.count++; + }); + + summary.examples = Array.from(exampleCounts.values()) + .sort((a, b) => b.count - a.count) + .slice(0, 3); + } + + const summaries = Array.from(violationsByDirective.values()) + .sort((a, b) => b.violation_count - a.violation_count); + + // Générer le contenu HTML du rapport + const reportHtml = generateReportHtml(summaries, reports.length); + + // Envoyer l'email via le système universel + await sendUniversalEmailV2({ + type: 'notification', + toEmail: 'paie@odentas.fr', + subject: `🔒 Rapport CSP quotidien - ${reports.length} violation${reports.length > 1 ? 's' : ''} détectée${reports.length > 1 ? 's' : ''}`, + data: { + firstName: 'Équipe', + organizationName: 'Odentas', + customMessage: reportHtml, + ctaUrl: 'https://espace-paie.odentas.fr/staff/csp-reports' // Pour future dashboard + } + }); + + // Logger l'envoi + await supabase + .from('csp_email_logs') + .insert({ + report_date: today, + reports_count: reports.length, + unique_violations: summaries.length + }); + + console.log(`✅ Rapport CSP envoyé: ${reports.length} violations, ${summaries.length} directives`); + + return NextResponse.json({ + success: true, + violations_count: reports.length, + unique_directives: summaries.length, + summaries + }); + + } catch (error) { + console.error('❌ Erreur envoi rapport CSP:', error); + return NextResponse.json({ + error: 'Internal server error', + message: error instanceof Error ? error.message : 'Unknown error' + }, { status: 500 }); + } +} + +function generateReportHtml(summaries: ViolationSummary[], totalViolations: number): string { + let html = ` +
+

Rapport CSP des dernières 24 heures

+

+ ${totalViolations} violation${totalViolations > 1 ? 's' : ''} de Content Security Policy détectée${totalViolations > 1 ? 's' : ''}. +

+ `; + + summaries.forEach((summary, index) => { + html += ` +
+

+ ${summary.violated_directive} +

+
+ ${summary.violation_count} occurrence${summary.violation_count > 1 ? 's' : ''} • + ${summary.unique_blocked_uris} ressource${summary.unique_blocked_uris > 1 ? 's' : ''} bloquée${summary.unique_blocked_uris > 1 ? 's' : ''} • + ${summary.affected_pages} page${summary.affected_pages > 1 ? 's' : ''} affectée${summary.affected_pages > 1 ? 's' : ''} +
+ +
+ Exemples: + ${summary.examples.map(ex => ` +
+
+ ${ex.blocked_uri} +
+
+ Sur: ${ex.document_uri.replace('https://espace-paie.odentas.fr', '')} + ${ex.count > 1 ? ` • ${ex.count} fois` : ''} +
+
+ `).join('')} +
+
+ `; + }); + + html += ` +
+ 📋 Prochaines étapes: +
    +
  1. Analyser les directives violées les plus fréquentes
    2. +
  2. Identifier si ce sont des ressources légitimes ou des tentatives d'attaque
    3. +
  3. Ajuster la CSP en conséquence (ajouter les sources autorisées)
    4. +
  4. Après 5 jours d'observation, passer en mode "Enforce"
    5. +
+
+ +
+ Ce rapport est généré quotidiennement en mode Report-Only.
+ Les violations sont collectées mais n'affectent pas le fonctionnement de l'application. +
+
+ `; + + return html; +} diff --git a/app/api/csp-report/route.ts b/app/api/csp-report/route.ts new file mode 100644 index 0000000..010fe34 --- /dev/null +++ b/app/api/csp-report/route.ts @@ -0,0 +1,78 @@ +// app/api/csp-report/route.ts +import { NextRequest, NextResponse } from 'next/server'; +import { createSbServiceRole } from '@/lib/supabaseServer'; + +export const dynamic = 'force-dynamic'; + +interface CSPReport { + 'csp-report': { + 'document-uri': string; + 'violated-directive': string; + 'effective-directive'?: string; + 'blocked-uri'?: string; + 'source-file'?: string; + 'line-number'?: number; + 'column-number'?: number; + 'status-code'?: number; + referrer?: string; + 'original-policy'?: string; + }; +} + +export async function POST(req: NextRequest) { + try { + const report: CSPReport = await req.json(); + const cspReport = report['csp-report']; + + // Validation basique + if (!cspReport || !cspReport['document-uri'] || !cspReport['violated-directive']) { + console.error('❌ CSP Report invalide:', report); + return NextResponse.json({ error: 'Invalid CSP report format' }, { status: 400 }); + } + + // Log console pour debug immédiat + console.log('🔒 CSP Violation détectée:', { + timestamp: new Date().toISOString(), + page: cspReport['document-uri'], + directive: cspReport['violated-directive'], + blocked: cspReport['blocked-uri'] || 'inline', + source: cspReport['source-file'], + line: cspReport['line-number'] + }); + + // Enregistrer en base de données + const supabase = createSbServiceRole(); + + const { error: insertError } = await supabase + .from('csp_reports') + .insert({ + document_uri: cspReport['document-uri'], + violated_directive: cspReport['violated-directive'], + effective_directive: cspReport['effective-directive'], + blocked_uri: cspReport['blocked-uri'], + source_file: cspReport['source-file'], + line_number: cspReport['line-number'], + column_number: cspReport['column-number'], + status_code: cspReport['status-code'], + user_agent: req.headers.get('user-agent'), + referrer: cspReport.referrer, + original_policy: cspReport['original-policy'] + }); + + if (insertError) { + console.error('❌ Erreur insertion CSP report:', insertError); + // Ne pas échouer la requête même si l'insertion échoue + } + + return NextResponse.json({ received: true }, { status: 200 }); + } catch (error) { + console.error('❌ Erreur traitement CSP report:', error); + // Retourner 200 quand même pour ne pas polluer les logs navigateur + return NextResponse.json({ received: false }, { status: 200 }); + } +} + +// Gérer les requêtes OPTIONS (CORS preflight) +export async function OPTIONS() { + return NextResponse.json({}, { status: 200 }); +} diff --git a/app/api/pdf-clean/route.ts b/app/api/pdf-clean/route.ts deleted file mode 100644 index 3ad0838..0000000 --- a/app/api/pdf-clean/route.ts +++ /dev/null @@ -1,65 +0,0 @@ -import { NextRequest, NextResponse } from 'next/server'; -import { PDFDocument } from 'pdf-lib'; - -export async function GET(request: NextRequest) { - try { - const { searchParams } = new URL(request.url); - const pdfUrl = searchParams.get('url'); - const requestId = searchParams.get('requestId'); - - if (!pdfUrl) { - return NextResponse.json( - { error: 'URL du PDF requise' }, - { status: 400 } - ); - } - - // Récupérer le PDF depuis S3 - const response = await fetch(decodeURIComponent(pdfUrl)); - if (!response.ok) { - return NextResponse.json( - { error: `Erreur S3: ${response.status}` }, - { status: response.status } - ); - } - - const pdfBytes = await response.arrayBuffer(); - - try { - // Charger le PDF avec pdf-lib - const pdfDoc = await PDFDocument.load(pdfBytes); - const pages = pdfDoc.getPages(); - - // Parcourir chaque page et extraire les annotations - // Note: pdf-lib ne peut pas modifier directement le texte rendu - // On va donc simplement retourner le PDF tel quel - // car les placeholders seront masqués par les overlays de signature - - const modifiedPdfBytes = await pdfDoc.save(); - - return new NextResponse(Buffer.from(modifiedPdfBytes), { - headers: { - 'Content-Type': 'application/pdf', - 'Cache-Control': 'public, max-age=3600', - 'Access-Control-Allow-Origin': '*', - }, - }); - } catch (error) { - console.error('Erreur parsing PDF avec pdf-lib:', error); - // En cas d'erreur, retourner le PDF original - return new NextResponse(Buffer.from(pdfBytes), { - headers: { - 'Content-Type': 'application/pdf', - 'Cache-Control': 'public, max-age=3600', - 'Access-Control-Allow-Origin': '*', - }, - }); - } - } catch (error) { - console.error('Erreur nettoyage PDF:', error); - return NextResponse.json( - { error: 'Erreur serveur' }, - { status: 500 } - ); - } -} diff --git a/app/api/pdf-proxy/route.ts b/app/api/pdf-proxy/route.ts deleted file mode 100644 index 46dcd2c..0000000 --- a/app/api/pdf-proxy/route.ts +++ /dev/null @@ -1,45 +0,0 @@ -import { NextRequest, NextResponse } from 'next/server'; - -export async function GET(request: NextRequest) { - try { - const { searchParams } = new URL(request.url); - const pdfUrl = searchParams.get('url'); - - if (!pdfUrl) { - return NextResponse.json( - { error: 'URL du PDF requise' }, - { status: 400 } - ); - } - - // Décoder l'URL si elle est encodée - const decodedUrl = decodeURIComponent(pdfUrl); - - // Fetcher le PDF depuis S3 - const response = await fetch(decodedUrl); - - if (!response.ok) { - return NextResponse.json( - { error: `Erreur S3: ${response.status}` }, - { status: response.status } - ); - } - - const buffer = await response.arrayBuffer(); - - // Retourner le PDF avec les headers CORS appropriés - return new NextResponse(buffer, { - headers: { - 'Content-Type': 'application/pdf', - 'Cache-Control': 'public, max-age=3600', - 'Access-Control-Allow-Origin': '*', - }, - }); - } catch (error) { - console.error('Erreur proxy PDF:', error); - return NextResponse.json( - { error: 'Erreur serveur' }, - { status: 500 } - ); - } -} diff --git a/next.config.mjs b/next.config.mjs index f7d2f54..82456a2 100644 --- a/next.config.mjs +++ b/next.config.mjs @@ -8,6 +8,92 @@ const nextConfig = { eslint: { ignoreDuringBuilds: true, }, + + // 🔒 SÉCURITÉ : Headers de sécurité avec CSP en mode Report-Only + async headers() { + return [ + { + source: '/:path*', + headers: [ + { + key: 'Content-Security-Policy-Report-Only', + value: [ + // Scripts JavaScript + "default-src 'self'", + "script-src 'self' 'unsafe-inline' 'unsafe-eval' https://eu-assets.i.posthog.com https://eu.i.posthog.com", + + // Styles CSS + "style-src 'self' 'unsafe-inline'", + + // Images + "img-src 'self' data: blob: https: https://*.s3.eu-west-3.amazonaws.com", + + // Fonts + "font-src 'self' data:", + + // Connexions réseau (API, WebSocket, etc.) + "connect-src 'self' " + + "https://eu.i.posthog.com " + + "https://eu-assets.i.posthog.com " + + "https://*.supabase.co " + + "wss://*.supabase.co " + + "https://*.s3.eu-west-3.amazonaws.com " + + "https://*.lambda-url.eu-west-3.on.aws " + + "https://api.pdfmonkey.io " + + "https://api.docuseal.com " + + "https://api.docuseal.eu", + + // Frames (iframes) + "frame-ancestors 'none'", + "frame-src 'self' blob:", + + // Base URI + "base-uri 'self'", + + // Formulaires + "form-action 'self'", + + // Media + "media-src 'self' blob:", + + // Workers + "worker-src 'self' blob:", + + // Objects (Flash, Java, etc.) + "object-src 'none'", + + // Rapport des violations + "report-uri /api/csp-report", + + // Forcer HTTPS + "upgrade-insecure-requests" + ].join('; ') + }, + { + key: 'X-Frame-Options', + value: 'DENY' + }, + { + key: 'X-Content-Type-Options', + value: 'nosniff' + }, + { + key: 'Referrer-Policy', + value: 'strict-origin-when-cross-origin' + }, + { + key: 'Permissions-Policy', + value: 'geolocation=(), microphone=(), camera=(), payment=()' + }, + { + key: 'X-XSS-Protection', + value: '1; mode=block' + } + ] + } + ] + }, + // Configuration pour optimiser les chunks et éviter les erreurs de modules Supabase webpack: (config, { dev, isServer }) => { if (!isServer) { diff --git a/supabase/migrations/20251114_create_csp_reports.sql b/supabase/migrations/20251114_create_csp_reports.sql new file mode 100644 index 0000000..d8d3c38 --- /dev/null +++ b/supabase/migrations/20251114_create_csp_reports.sql @@ -0,0 +1,75 @@ +-- Migration : Table pour les rapports CSP +-- Date : 14 novembre 2025 +-- Description : Stockage des violations CSP pour analyse de sécurité + +-- Table principale pour les rapports CSP +CREATE TABLE IF NOT EXISTS csp_reports ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + document_uri TEXT NOT NULL, + violated_directive TEXT NOT NULL, + effective_directive TEXT, + blocked_uri TEXT, + source_file TEXT, + line_number INTEGER, + column_number INTEGER, + status_code INTEGER, + user_agent TEXT, + referrer TEXT, + original_policy TEXT, + created_at TIMESTAMPTZ DEFAULT NOW() +); + +-- Index pour les requêtes fréquentes +CREATE INDEX idx_csp_reports_created_at ON csp_reports(created_at DESC); +CREATE INDEX idx_csp_reports_directive ON csp_reports(violated_directive); +CREATE INDEX idx_csp_reports_blocked_uri ON csp_reports(blocked_uri); +CREATE INDEX idx_csp_reports_document_uri ON csp_reports(document_uri); + +-- Table pour tracker les emails envoyés (éviter les doublons) +CREATE TABLE IF NOT EXISTS csp_email_logs ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + report_date DATE NOT NULL UNIQUE, + reports_count INTEGER NOT NULL DEFAULT 0, + unique_violations INTEGER NOT NULL DEFAULT 0, + email_sent_at TIMESTAMPTZ DEFAULT NOW() +); + +-- Activer RLS (même si non utilisé pour l'instant) +ALTER TABLE csp_reports ENABLE ROW LEVEL SECURITY; +ALTER TABLE csp_email_logs ENABLE ROW LEVEL SECURITY; + +-- Politique pour permettre l'insertion via service role +CREATE POLICY "Service role can insert reports" ON csp_reports + FOR INSERT + WITH CHECK (true); + +CREATE POLICY "Staff can view reports" ON csp_reports + FOR SELECT + USING ( + EXISTS ( + SELECT 1 FROM staff_users + WHERE staff_users.user_id = auth.uid() + AND staff_users.is_staff = true + ) + ); + +-- Vue pour les statistiques +CREATE OR REPLACE VIEW csp_reports_summary AS +SELECT + violated_directive, + COUNT(*) as violation_count, + COUNT(DISTINCT blocked_uri) as unique_blocked_uris, + COUNT(DISTINCT document_uri) as affected_pages, + MAX(created_at) as last_occurrence +FROM csp_reports +WHERE created_at > NOW() - INTERVAL '7 days' +GROUP BY violated_directive +ORDER BY violation_count DESC; + +-- Grant permissions +GRANT SELECT ON csp_reports_summary TO authenticated; + +-- Commentaires +COMMENT ON TABLE csp_reports IS 'Stockage des violations CSP (Content Security Policy) pour analyse de sécurité'; +COMMENT ON TABLE csp_email_logs IS 'Log des emails quotidiens envoyés avec rapports CSP'; +COMMENT ON VIEW csp_reports_summary IS 'Vue résumée des violations CSP des 7 derniers jours'; diff --git a/vercel.json b/vercel.json index 9869d47..d382e6c 100644 --- a/vercel.json +++ b/vercel.json @@ -7,6 +7,12 @@ "maxDuration": 30 } }, + "crons": [ + { + "path": "/api/cron/send-csp-report", + "schedule": "0 9 * * *" + } + ], "headers": [ { "source": "/(.*)",