Règles de partage et sécurité du bucket S3 (+ utilisation de l'API Key pour y accéder via SUIT)

[maxgfr]

Contexte

Les fichiers uploadés (avis CSE, évaluation conjointe) sont stockés sur S3 en {siren}/{year}/{uuid}.{ext}. Actuellement, aucune politique de bucket n'est configurée (ACL, CORS, lifecycle, chiffrement).

Besoin

• Isolation par SIREN : un utilisateur ne doit accéder qu'aux fichiers de son entreprise
• CORS : restreindre les origines autorisées au domaine de l'app
• Lifecycle rules : suppression automatique des fichiers orphelins (multipart uploads avortés, fichiers non référencés en base)
• Chiffrement : S3 server-side encryption (SSE-S3 ou SSE-KMS)
• Accès : les fichiers ne doivent jamais être publics — téléchargement via une route API authentifiée (pre-signed URL ou proxy)

Pistes

• Bucket policy pour bloquer l'accès public
• Lifecycle rule : AbortIncompleteMultipartUpload après 1 jour
• Route API GET /api/download?key=... avec vérification session + SIREN ownership
• Ou pre-signed URLs avec expiration courte (5 min)

Fichiers concernés

• packages/app/src/server/services/s3.ts (ajout getSignedUrl ou route proxy)
• .kontinuous/ (config bucket policy par environnement)
• docker-compose.yml (minio policy pour le dev local)

[maxgfr]

Ok, voici l'architecture simplifiée selon tes retours. Tout est en proxy, personne ne voit jamais l'URL S3.

---

Types

// types.ts
export interface Upload {
  id: string;
  userId: string;
  s3Key: string;
  fileName: string;
  contentType: string;
  fileSize: number;
  createdAt: Date;
}

export interface UserJwtPayload {
  sub: string;
  role: "user";
}

export interface GovJwtPayload {
  sub: string;
  role: "gov";
  scope: "read";
}

---

S3 service

// services/s3.service.ts
import { S3Client, PutObjectCommand, GetObjectCommand } from "@aws-sdk/client-s3";
import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
import { createHash } from "crypto";

const s3 = new S3Client({ region: process.env.AWS_REGION });
const BUCKET = process.env.S3_BUCKET!;

export async function uploadToS3(
  key: string,
  body: Buffer,
  contentType: string,
  userId: string
) {
  const sha256 = createHash("sha256").update(body).digest("base64");

  await s3.send(new PutObjectCommand({
    Bucket: BUCKET,
    Key: key,
    Body: body,
    ContentType: contentType,
    ChecksumAlgorithm: "SHA256",
    ChecksumSHA256: sha256,
    Metadata: { "uploaded-by": userId },
  }));
}

// Génère une presigned URL interne (jamais exposée au client)
export async function getInternalPresignedUrl(
  key: string,
  expiresInSeconds: number
): Promise<string> {
  const command = new GetObjectCommand({ Bucket: BUCKET, Key: key });
  return getSignedUrl(s3, command, { expiresIn: expiresInSeconds });
}

export function buildS3Key(userId: string, fileName: string): string {
  const timestamp = Date.now();
  const sanitized = fileName.replace(/[^a-zA-Z0-9._-]/g, "_");
  return `uploads/${userId}/${timestamp}-${sanitized}`;
}

---

Proxy service — Le cœur du système. Personne n'accède à S3 directement, tout passe par ce proxy.

// services/proxy.service.ts
import { Response } from "express";
import { getInternalPresignedUrl } from "./s3.service";

// Fetch la presigned URL en interne et stream le résultat au client
// Le client ne voit que notre URL à nous
export async function proxyS3File(
  s3Key: string,
  contentType: string,
  fileName: string,
  expiresInSeconds: number,
  res: Response
) {
  // 1. On génère la presigned URL (usage interne uniquement)
  const presignedUrl = await getInternalPresignedUrl(s3Key, expiresInSeconds);

  // 2. On fetch nous-mêmes cette URL
  const s3Response = await fetch(presignedUrl);

  if (!s3Response.ok || !s3Response.body) {
    return res.status(502).json({ error: "Erreur lors de la récupération du fichier" });
  }

  // 3. On stream le contenu vers le client
  res.set({
    "Content-Type": contentType,
    "Content-Disposition": `inline; filename="${fileName}"`,
    "Cache-Control": "private, no-store",
  });

  // Pipe le ReadableStream vers la response Express
  const reader = s3Response.body.getReader();
  const pump = async () => {
    while (true) {
      const { done, value } = await reader.read();
      if (done) { res.end(); return; }
      res.write(value);
    }
  };
  await pump();
}

---

Auth middleware

// middleware/auth.middleware.ts
import { Request, Response, NextFunction } from "express";
import jwt from "jsonwebtoken";

const SECRET = process.env.JWT_SECRET!;

declare global {
  namespace Express {
    interface Request {
      user?: { sub: string; role: "user" };
      gov?: { sub: string; role: "gov" };
    }
  }
}

// Vérifie que l'utilisateur est connecté
export function requireUser(req: Request, res: Response, next: NextFunction) {
  const token = req.headers.authorization?.replace("Bearer ", "");
  if (!token) return res.status(401).json({ error: "Token manquant" });

  try {
    req.user = jwt.verify(token, SECRET) as { sub: string; role: "user" };
    next();
  } catch {
    return res.status(401).json({ error: "Token invalide ou expiré" });
  }
}

// Vérifie le JWT du service de l'État
export function requireGov(req: Request, res: Response, next: NextFunction) {
  const token = req.headers.authorization?.replace("Bearer ", "");
  if (!token) return res.status(401).json({ error: "Token manquant" });

  try {
    const payload = jwt.verify(token, SECRET) as { sub: string; role: string };
    if (payload.role !== "gov") throw new Error();
    req.gov = payload as { sub: string; role: "gov" };
    next();
  } catch {
    return res.status(401).json({ error: "Token gov invalide" });
  }
}

---

Routes upload — Juste vérifier que l'utilisateur est connecté, upload sur S3, enregistrer en DB.

// routes/upload.routes.ts
import { Router } from "express";
import multer from "multer";
import { requireUser } from "../middleware/auth.middleware";
import { uploadToS3, buildS3Key } from "../services/s3.service";
import { db } from "../db";

const router = Router();
const upload = multer({
  limits: { fileSize: 10 * 1024 * 1024 },
  fileFilter: (_req, file, cb) => {
    const allowed = ["image/jpeg", "image/png", "image/webp", "application/pdf"];
    cb(null, allowed.includes(file.mimetype));
  },
});

// POST /api/uploads
// L'utilisateur est connecté → on upload directement
router.post("/", requireUser, upload.single("file"), async (req, res) => {
  const file = req.file;
  if (!file) return res.status(400).json({ error: "Aucun fichier" });

  const userId = req.user!.sub;
  const s3Key = buildS3Key(userId, file.originalname);

  // Upload S3 avec vérification d'intégrité
  await uploadToS3(s3Key, file.buffer, file.mimetype, userId);

  // Enregistrer la ref en DB (le front ne voit jamais s3Key)
  const result = await db.query(
    `INSERT INTO uploads (user_id, s3_key, file_name, content_type, file_size)
     VALUES ($1, $2, $3, $4, $5)
     RETURNING id, created_at`,
    [userId, s3Key, file.originalname, file.mimetype, file.size]
  );

  return res.status(201).json({
    id: result.rows[0].id,
    fileName: file.originalname,
    createdAt: result.rows[0].created_at,
  });
});

export default router;

---

Routes consultation utilisateur — Auth → DB → proxy. Toujours.

// routes/user.routes.ts
import { Router } from "express";
import { requireUser } from "../middleware/auth.middleware";
import { proxyS3File } from "../services/proxy.service";
import { db } from "../db";

const router = Router();

// GET /api/user/:userId/last-upload
// Le front fait <img src="/api/user/123/last-upload"> et c'est tout
router.get("/:userId/last-upload", requireUser, async (req, res) => {
  const { userId } = req.params;

  // L'utilisateur ne voit que ses propres fichiers
  if (req.user!.sub !== userId) {
    return res.status(403).json({ error: "Accès interdit" });
  }

  const result = await db.query(
    `SELECT s3_key, file_name, content_type
     FROM uploads
     WHERE user_id = $1
     ORDER BY created_at DESC
     LIMIT 1`,
    [userId]
  );

  if (result.rows.length === 0) {
    return res.status(404).json({ error: "Aucun fichier" });
  }

  const { s3_key, file_name, content_type } = result.rows[0];

  // Proxy : on fetch la presigned URL en interne et on stream au client
  // Le client ne voit que /api/user/123/last-upload, jamais S3
  await proxyS3File(s3_key, content_type, file_name, 300, res);
});

export default router;

---

Routes service de l'État — API key → JWT, puis proxy aussi.

// routes/gov.routes.ts
import { Router } from "express";
import jwt from "jsonwebtoken";
import { requireGov } from "../middleware/auth.middleware";
import { proxyS3File } from "../services/proxy.service";
import { db } from "../db";

const router = Router();
const SECRET = process.env.JWT_SECRET!;
const GOV_API_KEY = process.env.GOV_API_KEY!;

// POST /api/gov/auth
// Le service de l'État envoie sa clé API, reçoit un JWT courte durée
router.post("/auth", (req, res) => {
  const apiKey = req.headers["x-api-key"] as string;

  if (apiKey !== GOV_API_KEY) {
    return res.status(401).json({ error: "Clé API invalide" });
  }

  const token = jwt.sign(
    { sub: "service-etat", role: "gov", scope: "read" },
    SECRET,
    { expiresIn: "1h" }
  );

  return res.json({ token, expiresIn: "1h" });
});

// GET /api/gov/sirene/:siret/files
// Liste les fichiers d'un utilisateur par SIRET
router.get("/sirene/:siret/files", requireGov, async (req, res) => {
  const { siret } = req.params;

  const userResult = await db.query(
    `SELECT id, siret FROM users WHERE siret = $1`,
    [siret]
  );

  if (userResult.rows.length === 0) {
    return res.status(404).json({ error: "SIRET inconnu" });
  }

  const user = userResult.rows[0];

  const filesResult = await db.query(
    `SELECT id, file_name, content_type, created_at
     FROM uploads
     WHERE user_id = $1
     ORDER BY created_at DESC`,
    [user.id]
  );

  // Log d'audit
  await db.query(
    `INSERT INTO gov_access_logs (gov_service_id, user_id, siret, files_accessed, accessed_at)
     VALUES ($1, $2, $3, $4, NOW())`,
    [req.gov!.sub, user.id, siret, filesResult.rows.length]
  );

  // Chaque fichier a une URL qui pointe vers NOTRE proxy, pas vers S3
  return res.json({
    siret,
    files: filesResult.rows.map((f) => ({
      id: f.id,
      fileName: f.file_name,
      contentType: f.content_type,
      createdAt: f.created_at,
      accessUrl: `/api/gov/files/${f.id}`, // ← notre URL, pas S3
    })),
  });
});

// GET /api/gov/files/:fileId
// Le service de l'État télécharge un fichier via notre proxy
router.get("/files/:fileId", requireGov, async (req, res) => {
  const { fileId } = req.params;

  const result = await db.query(
    `SELECT s3_key, file_name, content_type FROM uploads WHERE id = $1`,
    [fileId]
  );

  if (result.rows.length === 0) {
    return res.status(404).json({ error: "Fichier non trouvé" });
  }

  const { s3_key, file_name, content_type } = result.rows[0];

  // Log unitaire
  await db.query(
    `INSERT INTO gov_file_access_logs (gov_service_id, file_id, accessed_at)
     VALUES ($1, $2, NOW())`,
    [req.gov!.sub, fileId]
  );

  // Proxy : presigned URL 24h, mais le service ne la voit jamais
  await proxyS3File(s3_key, content_type, file_name, 86400, res);
});

export default router;

---

App principale

// app.ts
import express from "express";
import helmet from "helmet";
import uploadRoutes from "./routes/upload.routes";
import userRoutes from "./routes/user.routes";
import govRoutes from "./routes/gov.routes";

const app = express();
app.use(helmet());
app.use(express.json());

app.use("/api/uploads", uploadRoutes);
app.use("/api/user", userRoutes);
app.use("/api/gov", govRoutes);

app.listen(3000, () => console.log("Server running on :3000"));

---

En résumé, les 3 simplifications par rapport à avant :

L'upload est direct — pas de token d'upload en deux étapes, juste le middleware requireUser puis POST /api/uploads avec le fichier. Plus simple.

La consultation est toujours en proxy — pas de mode redirect, pas de presigned URL exposée. Le client appelle /api/user/123/last-upload, ton serveur fetch S3 en interne et stream le résultat. Le client ne voit que ton domaine.

Le service de l'État pareil — il appelle /api/gov/files/{fileId}, ton serveur proxy le contenu. Il ne voit jamais d'URL S3, juste tes URLs à toi. La presigned URL de 24h est utilisée en interne entre ton serveur et S3, mais elle n'est jamais exposée.

Les points à noter : Est-ce qu'on a besoin de generer un JWT alors qu'on a un Bearer Auth token ? Est-ce qu'on a besoin d'un log d'audit de consultation ou alors le penser de maniere plus global et pas que sur les fichiers ? Pour moi le proxy est nécessaire car ça évite d'avoir un bucket non publié sur internet en local. Il ne faut pas oublier de mettre dans le bucket tous les fichiers en public et les droits en upload uniquement au backend de notre application. Enfin pas oublier de sanitzie les fichiers

Pour le point du JWT :

Quand le JWT aurait un intérêt : si tu veux éviter un lookup en DB à chaque requête. Le JWT est auto-vérifié (signature cryptographique), donc pas besoin de taper la DB. Mais soyons honnêtes, un SELECT ... WHERE api_token = $1 avec un index, c'est quelques millisecondes — dans ton cas ça ne justifie probablement pas la complexité en plus. L'autre cas où le JWT a du sens : si tu as plusieurs services de l'État avec des scopes différents (un qui peut lire, un autre qui peut supprimer, etc.) et que tu veux encoder ces permissions dans le token sans refaire un lookup à chaque fois. Mais là encore, une table gov_services avec une colonne permissions fait le même travail.