chore: build

control-plane/api/internal/auth/handler.go

@@ -61,13 +61,16 @@ func (h *Handler) Login(c *gin.Context) {
 		return
 	}
 
-	token, err := h.startSession(c, user)
-	if err != nil {
+	// Le JWT n'est plus jamais renvoyé dans le corps JSON (pentest F-003) :
+	// uniquement posé en cookie HttpOnly par startSession. Le renvoyer ici
+	// permettait au frontend de le dupliquer en localStorage, annulant la
+	// protection HttpOnly contre un vol de session via XSS.
+	if _, err := h.startSession(c, user); err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{"error": "erreur serveur"})
 		return
 	}
 
-	c.JSON(http.StatusOK, gin.H{"token": token, "token_type": "Bearer", "role": user.Role})
+	c.JSON(http.StatusOK, gin.H{"role": user.Role})
 }
 
 // Me renvoie l'identité de la session courante (dont le rôle, pour le front).
@@ -111,7 +114,18 @@ func (h *Handler) Register(c *gin.Context) {
 		return
 	}
 
-	if _, exists := h.users.ByUsername(req.Username); exists {
+	if existing, exists := h.users.ByUsername(req.Username); exists {
+		// Un statut 409 distinct de la création (201) permet d'énumérer les
+		// comptes existants (pentest F-002) — inévitable pour un flux
+		// d'inscription instantané sans vérification email (l'utilisateur a
+		// besoin de savoir qu'il doit choisir un autre nom). On protège au
+		// moins la cible à plus fort enjeu : un compte admin ne confirme
+		// jamais son existence, la réponse est indiscernable d'un nom
+		// d'utilisateur simplement invalide.
+		if existing.Role == RoleAdmin {
+			c.JSON(http.StatusBadRequest, gin.H{"error": "requête invalide"})
+			return
+		}
 		c.JSON(http.StatusConflict, gin.H{"error": "nom d'utilisateur déjà pris"})
 		return
 	}
@@ -127,12 +141,11 @@ func (h *Handler) Register(c *gin.Context) {
 		return
 	}
 
-	token, err := h.startSession(c, user)
-	if err != nil {
+	if _, err := h.startSession(c, user); err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{"error": "erreur serveur"})
 		return
 	}
-	c.JSON(http.StatusCreated, gin.H{"token": token, "token_type": "Bearer", "role": user.Role})
+	c.JSON(http.StatusCreated, gin.H{"role": user.Role})
 }
 
 // startSession ouvre une session Redis, signe le JWT et pose le cookie.

control-plane/api/internal/config/config.go

@@ -16,7 +16,6 @@ type Config struct {
 	RedisURL         string        // OMNEX_REDIS_URL (sessions), ex. redis://:pass@host:6379/0
 	DemoDomain       string        // domaine des démos
 	DemoHTTPSPort    string        // port HTTPS public à afficher dans l'URL des démos (443 = omis, sinon ex. NodePort)
-	RegistrationCode string        // OMNEX_REGISTRATION_CODE (vide = inscription ouverte)
 	Kubeconfig       string
 	FrontendImage    string
 	BackendImage     string
@@ -47,7 +46,6 @@ func Load() (Config, error) {
 		RedisURL:          os.Getenv("OMNEX_REDIS_URL"),
 		DemoDomain:        getenv("OMNEX_DEMO_DOMAIN", "demo.omnex.app"),
 		DemoHTTPSPort:     getenv("OMNEX_DEMO_HTTPS_PORT", "443"),
-		RegistrationCode:  os.Getenv("OMNEX_REGISTRATION_CODE"),
 		Kubeconfig:        os.Getenv("KUBECONFIG"),
 		FrontendImage:     os.Getenv("FRONTEND_IMAGE_APP"),
 		BackendImage:      os.Getenv("BACKEND_IMAGE_APP"),

control-plane/api/internal/router/router.go

@@ -34,6 +34,29 @@ func New(d Deps) *gin.Engine {
 		gin.SetMode(gin.ReleaseMode)
 	}
 	r := gin.New()
+	// Sans ça, Gin fait confiance par défaut au X-Forwarded-For fourni par
+	// N'IMPORTE QUEL client pour déterminer c.ClientIP() (utilisé par
+	// RateLimit) — un attaquant peut alors faire croire que chaque requête
+	// vient d'une IP différente en changeant juste cet en-tête, contournant
+	// intégralement la limitation de débit sur /auth/login et
+	// /auth/register (trouvé en pentest, voir F-005).
+	//
+	// L'API n'est jamais exposée directement (pas de "ports:" dans
+	// docker-compose.yml, voir docker/docker-compose.yml) — seul nginx/waf,
+	// sur le réseau Docker interne, peut l'atteindre (proxy_pass vers
+	// http://api:8080, voir docker/waf/nginx.conf qui construit le
+	// X-Forwarded-For via $proxy_add_x_forwarded_for : ajoute toujours la
+	// vraie IP vue par nginx en dernière position, sans jamais écraser une
+	// valeur fournie par le client). En ne faisant confiance qu'aux plages
+	// privées RFC1918 (réseau Docker interne), Gin ignore la partie du
+	// X-Forwarded-For contrôlée par le client et ne retient que la partie
+	// ajoutée par nginx.
+	if err := r.SetTrustedProxies([]string{"10.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16"}); err != nil {
+		// CIDR statiques et valides : ne peut arriver qu'en cas d'erreur de
+		// programmation (typo) — fatal au démarrage plutôt que de tourner
+		// avec la protection anti-spoofing désactivée sans s'en rendre compte.
+		panic(err)
+	}
 	r.Use(gin.Recovery())
 	r.Use(httpx.SecurityHeaders())
 	r.Use(httpx.CORS(d.Cfg.AllowedOrigins))

web/dist/index.html

@@ -5,7 +5,7 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Omnex — Plateforme de gestion de commandes & livraison</title>
     <meta name="description" content="Déployez en un clic une démo complète de la plateforme de gestion de commandes et de livraison." />
-    <script type="module" crossorigin src="/assets/index-yR0d-eKM.js"></script>
+    <script type="module" crossorigin src="/assets/index-DkbJvUQ3.js"></script>
   </head>
   <body>
     <div id="root"></div>

web/src/lib/api.ts

@@ -1,19 +1,8 @@
-// Client HTTP vers l'API Omnex.
-const BASE = import.meta.env.VITE_API_URL ?? 'http://localhost:8080'
-
-const TOKEN_KEY = 'omnex.token'
-
-
-export function getToken(): string | null {
-  return localStorage.getItem(TOKEN_KEY)
-}
-export function setToken(t: string) {
-  localStorage.setItem(TOKEN_KEY, t)
-}
-export function clearToken() {
-  localStorage.removeItem(TOKEN_KEY)
-}
-
+// Client HTTP vers l'API Omnex. "" (chemin relatif) par défaut : same-origin
+// en prod (nginx proxy /api/ vers l'API, voir docker/waf/nginx.conf) et en
+// dev (proxy Vite, voir vite.config.ts) — nécessaire pour que le cookie de
+// session SameSite=Lax soit envoyé (jamais cross-origin, voir lib/auth.tsx).
+const BASE = import.meta.env.VITE_API_URL ?? ''
 
 export class ApiError extends Error {
   status: number
@@ -23,14 +12,19 @@ export class ApiError extends Error {
   }
 }
 
+// Authentification exclusivement via le cookie de session HttpOnly (posé par
+// le backend sur /auth/login et /auth/register) — jamais de JWT lu/stocké en
+// JS. Le dupliquer en localStorage (comme avant) annulait la protection
+// HttpOnly contre le vol de session par XSS (pentest F-003) : le SPA et
+// l'API étant same-origin, le cookie authentifie déjà chaque fetch() sans
+// qu'aucun en-tête Authorization manuel ne soit nécessaire.
 async function request<T>(method: string, path: string, body?: unknown): Promise<T> {
   const headers: Record<string, string> = { 'Content-Type': 'application/json' }
-  const token = getToken()
-  if (token) headers.Authorization = `Bearer ${token}`
 
   const res = await fetch(`${BASE}/api/v1${path}`, {
     method,
     headers,
+    credentials: 'include',
     body: body ? JSON.stringify(body) : undefined,
   })
   if (!res.ok) {
@@ -177,16 +171,9 @@ export interface AppDownloadsResponse {
 
 export const api = {
   login: (username: string, password: string, role: Role) =>
-    request<{ token: string; token_type: string; role: Role }>('POST', '/auth/login', {
-      username,
-      password,
-      role,
-    }),
+    request<{ role: Role }>('POST', '/auth/login', { username, password, role }),
   register: (username: string, password: string) =>
-    request<{ token: string; token_type: string; role: Role }>('POST', '/auth/register', {
-      username,
-      password,
-    }),
+    request<{ role: Role }>('POST', '/auth/register', { username, password }),
     me: () =>
       request<{
         user_id: string

web/src/lib/auth.tsx

@@ -7,7 +7,7 @@ import {
   useState,
   type ReactNode,
 } from 'react'
-import { api, clearToken, getToken, setToken, type Role } from './api'
+import { api, type Role } from './api'
 
 interface AuthState {
   isAuthenticated: boolean
@@ -26,16 +26,15 @@ interface AuthState {
 const AuthContext = createContext<AuthState | null>(null)
 
 export function AuthProvider({ children }: { children: ReactNode }) {
-  const [token, setTok] = useState<string | null>(getToken())
   const [role, setRole] = useState<Role | null>(null)
   const [typeAbo, setTypeAbo] = useState<string | null>(null)
-  const [initializing, setInitializing] = useState<boolean>(!!getToken())
+  const [initializing, setInitializing] = useState(true)
 
+  // Le cookie de session est HttpOnly : impossible à lire en JS pour savoir
+  // à l'avance si l'utilisateur est connecté. On tente donc systématiquement
+  // /auth/me au montage — le cookie (s'il existe et est valide) l'authentifie
+  // automatiquement ; un 401 signifie simplement "pas de session".
   useEffect(() => {
-    if (!token) {
-      setInitializing(false)
-      return
-    }
     let active = true
     api
       .me()
@@ -46,12 +45,7 @@ export function AuthProvider({ children }: { children: ReactNode }) {
         }
       })
       .catch(() => {
-        if (active) {
-          clearToken()
-          setTok(null)
-          setRole(null)
-          setTypeAbo(null)
-        }
+        /* pas de session valide — état par défaut (déconnecté) */
       })
       .finally(() => {
         if (active) setInitializing(false)
@@ -59,24 +53,19 @@ export function AuthProvider({ children }: { children: ReactNode }) {
     return () => {
       active = false
     }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [])
 
   const login = useCallback(async (username: string, password: string, role: Role) => {
-    const res = await api.login(username, password, role)
-    setToken(res.token)
-    setTok(res.token)
-    setRole(res.role)
+    await api.login(username, password, role)
     const me = await api.me()
+    setRole(me.role)
     setTypeAbo(me.type_abonnement)
   }, [])
 
   const register = useCallback(async (username: string, password: string) => {
-    const res = await api.register(username, password)
-    setToken(res.token)
-    setTok(res.token)
-    setRole(res.role)
+    await api.register(username, password)
     const me = await api.me()
+    setRole(me.role)
     setTypeAbo(me.type_abonnement)
   }, [])
 
@@ -84,8 +73,6 @@ export function AuthProvider({ children }: { children: ReactNode }) {
     try {
       await api.logout()
     } finally {
-      clearToken()
-      setTok(null)
       setRole(null)
       setTypeAbo(null)
     }
@@ -99,7 +86,7 @@ export function AuthProvider({ children }: { children: ReactNode }) {
 
   const value = useMemo<AuthState>(
     () => ({
-      isAuthenticated: !!token,
+      isAuthenticated: !!role,
       isAdmin: role === 'admin',
       isClient: role === 'client',
       isPremium: typeAbo === 'premium',
@@ -111,7 +98,7 @@ export function AuthProvider({ children }: { children: ReactNode }) {
       logout,
       refreshAbo,
     }),
-    [token, role, typeAbo, initializing, login, register, logout, refreshAbo],
+    [role, typeAbo, initializing, login, register, logout, refreshAbo],
   )
 
   return <AuthContext.Provider value={value}>{children}</AuthContext.Provider>

web/vite.config.ts

@@ -4,6 +4,17 @@ import react from '@vitejs/plugin-react'
 
 export default defineConfig({
   plugins: [react()],
+  server: {
+    // Fait passer l'API par la même origine que le SPA en dev (localhost:5173)
+    // au lieu d'un appel cross-origin direct vers localhost:8080 — nécessaire
+    // depuis le passage à l'authentification 100% cookie HttpOnly (plus de
+    // fallback Authorization: Bearer, voir lib/api.ts) : un cookie
+    // SameSite=Lax n'est pas envoyé sur un fetch() cross-site.
+    proxy: {
+      '/api': { target: 'http://localhost:8080', changeOrigin: true },
+      '/healthz': { target: 'http://localhost:8080', changeOrigin: true },
+    },
+  },
   test: {
     globals: true,
     environment: 'jsdom',