Aller au contenu
Meubles Morinière

Le projetCompétences et preuves4 min de lecture

Sécurité

Des garanties qui ne dépendent pas du code qu’elles protègent : une base qui limite ce que le site peut faire, des actions serveur qui s’ouvrent toutes sur leur garde, des messages signés, un assistant qui ne peut pas inventer un chiffre.

Ce qui est exposé, c’est le site public, ouvert à tout Internet. L’argent, la comptabilité et les données des clients sont dans l’ERP. Chaque limite ci-dessous reste en place même si le code au-dessus se trompe, et un test le vérifie.

Une faille du site ne peut pas marquer une commande payée

L’ERP et le site tournent sur la même base. Si le site avait les droits de l’ERP, il suffirait d’une injection, d’une erreur de logique ou d’une dépendance compromise pour marquer une commande payée, toucher à une facture ou lire les notes internes.

Du coup, le site se connecte avec un rôle Postgres qui n’a que les droits dont son code se sert, table par table et colonne par colonne. Là où il écrit, des triggers vérifient la forme de ce qu’il écrit. Avec ce rôle, la seule commande que la base accepte, c’est une commande web en attente de paiement.

tables, sur les 54 du schéma, où le site public peut écrire
6
apps/site/scripts/lib/database-grants.ts#SITE_TABLE_GRANTS
tables que le site public ne peut même pas lire
19
apps/site/scripts/lib/database-grants.ts#SITE_TABLE_GRANTS
Mesuré dans le dépôt à chaque build de cette documentation.
Order_site_guard_insertpackages/db/prisma/migrations/20261024020000_avis_retard_fabricant_et_rupture/migration.sql · lignes 6–53
CREATE OR REPLACE FUNCTION "Order_site_guard_insert"() RETURNS trigger
LANGUAGE plpgsql AS $$
BEGIN
  IF current_user = 'moriniere_site' AND (
    NEW."channel" <> 'WEB'
    OR NEW."paymentStatus" <> 'PENDING'
    OR NEW."fulfillmentStatus" <> 'UNFULFILLED'
    OR NEW."paidAt" IS NOT NULL
    OR NEW."confirmedAt" IS NOT NULL
    OR NEW."canceledAt" IS NOT NULL
    OR NEW."createdById" IS NOT NULL
    OR NEW."internalNote" IS NOT NULL
    OR NEW."customerId" IS NOT NULL
    OR NEW."depositCents" IS NOT NULL
    OR NEW."stripeSessionId" IS NOT NULL
    OR NEW."stripePaymentIntentId" IS NOT NULL
    OR NEW."shippedAt" IS NOT NULL
    OR NEW."deliveredAt" IS NOT NULL
    OR NEW."workshopDueAt" IS NOT NULL
    OR NEW."promisedWorkshopDueAt" IS NOT NULL
    OR NEW."workshopDueNoticeSentAt" IS NOT NULL
    OR NEW."supplierDelayNoticeSentAt" IS NOT NULL
    OR NEW."backorderNoticeSentAt" IS NOT NULL
    OR NEW."deliveryAppointmentStartsAt" IS NOT NULL
    OR NEW."deliveryAppointmentEndsAt" IS NOT NULL
    OR NEW."deliveryAppointmentNoticeSentAt" IS NOT NULL
    OR NEW."deliveryNoticeSentAt" IS NOT NULL
    OR NEW."deliveryEvidence" IS NOT NULL
    OR NEW."deliveryReserves" IS NOT NULL
    OR NEW."deliveryReservesNotedAt" IS NOT NULL
    OR NEW."carrierClaimedAt" IS NOT NULL
    OR NEW."confirmationSentAt" IS NOT NULL
    OR NEW."shipmentNoticeSentAt" IS NOT NULL
    OR NEW."pickupNoticeSentAt" IS NOT NULL
    OR NEW."withdrawalRequestedAt" IS NOT NULL
    OR NEW."withdrawalAcknowledgedAt" IS NOT NULL
    OR NEW."withdrawalClosedAt" IS NOT NULL
    OR NEW."withdrawalClosure" IS NOT NULL
    OR NEW."returnClosedAt" IS NOT NULL
    OR NEW."billingCorrectedAt" IS NOT NULL
    OR NEW."anonymizedAt" IS NOT NULL
    OR NEW."anonymizationReason" IS NOT NULL
  ) THEN
    RAISE EXCEPTION 'Order_site_guard_insert : le site ne crée qu''une commande web en attente de paiement';
  END IF;
  RETURN NEW;
END;
$$;

Pour aller plus loin : Le site n’a que les droits qu’il lui faut, Droits PostgreSQL, ADR 0003, ADR 0004.

Chaque droit du site correspond à une requête de son code, et aucun de plus

Une liste de droits qu’on met à jour à la main finit par dériver, dans les deux sens. Un droit oublié casse la prod. Un droit en trop rouvre ce qu’on voulait fermer.

Alors un test relève chaque requête Prisma, chaque création imbriquée et chaque requête SQL du site, puis il compare avec la liste des droits. Il échoue s’il trouve une requête sans droit. Il échoue aussi s’il trouve un droit d’écriture qu’aucune requête ne justifie.

test « chaque droit d'écriture est justifié par une écriture du code, une création imbriquée ou une ligne filtrée »apps/site/test/database-grants.regression.test.ts · lignes 352–377
it("chaque droit d'écriture est justifié par une écriture du code, une création imbriquée ou une ligne filtrée", () => {
	const written = new Set([
		...CODE_NEEDS.filter((need) => need.privilege !== "SELECT").map(
			(need) => `${need.table}:${need.privilege}`,
		),
		...NESTED_CREATES.flatMap(({ field }) =>
			(RELATION_TARGETS.get(field) ?? []).map((table) => `${table}:INSERT`),
		),
		...SITE_AUTH_ADAPTER_WRITES.flatMap((write) =>
			write.privileges.map((privilege) => `${write.table}:${privilege}`),
		),
	]);
	const unjustified = SITE_TABLE_GRANTS.flatMap((grant: SiteTableGrant) => [
		...grantedPrivileges(grant)
			.filter((privilege) => privilege !== "SELECT")
			.filter((privilege) => !written.has(`${grant.table}:${privilege}`))
			.map((privilege) => `${grant.table} ${privilege}`),
		...((grant.lockColumns ?? []).length > 0 && !written.has(`${grant.table}:LOCK`)
			? [`${grant.table} verrou`]
			: []),
	]);

	expect(unjustified, "droit d'écriture sans écriture dans le code du site : le retirer").toEqual(
		[],
	);
});

Le site refuse de démarrer avec le mauvais rôle

Toutes ces limites tombent si le site se connecte avec le rôle propriétaire, à cause d’une erreur de configuration.

Donc sur un déploiement, le site vérifie au démarrage qu’il est connecté avec son propre rôle, et que ce rôle ne contourne pas la sécurité des lignes. Sinon, il refuse de démarrer, pour ne pas servir sans protection.

assertSiteDatabaseRoleapps/site/shared/server/database-role-check.ts · lignes 26–51
export async function assertSiteDatabaseRole(): Promise<void> {
	if (env.VERCEL_ENV !== "production" && env.VERCEL_ENV !== "preview") return;
	if (isProductionBuildPhase()) return;

	const role = await readSessionRole();
	if (role instanceof Error) {
		logError({
			source: "db",
			message: "rôle de connexion du site invérifiable au démarrage",
			cause: describeError(role).message,
		});
		return;
	}
	if (role !== null && role.user === SITE_DATABASE_ROLE && !role.bypassesRls) return;

	const message =
		`le site ne se connecte pas en ${SITE_DATABASE_ROLE} sans contournement de la RLS\u00A0: ` +
		"droits par table, RLS des comptes et gardes des commandes ne s’appliquent plus";
	logError({
		source: "db",
		message,
		user: role?.user ?? null,
		bypassesRls: role?.bypassesRls ?? null,
	});
	throw new Error(message);
}

Chaque action serveur de l’ERP s’ouvre sur sa garde

Chaque export d’un fichier "use server" est un point d’entrée HTTP. Si on ajoute une action sans vérifier la session, n’importe qui peut l’appeler.

Du coup, un test lit chaque fichier d’actions de l’ERP. Il exige que chaque export commence par la garde, celle qui refuse quand il n’y a pas de session. Les exceptions sont nommées dans une liste, et cette liste ne doit contenir que des fichiers qui existent. Ce relevé est lui-même testé : il doit passer au rouge sur chaque faute qu’il est censé attraper.

test « chaque export de %s s'ouvre sur la garde qui refuse, ou le fichier est PUBLIC »apps/erp/test/admin-guard.regression.test.ts · lignes 80–86
it.each(actionFiles)(
	"chaque export de %s s'ouvre sur la garde qui refuse, ou le fichier est PUBLIC",
	(relativePath) => {
		const source = readFileSync(resolve(repoRoot, relativePath), "utf8");
		expect(actionFaults(relativePath, source, regimeOf(relativePath))).toEqual([]);
	},
);

Pour aller plus loin : Comptes et sessions, ADR 0011.

Les messages entre applications sont signés, datés et comparés à temps constant

Quand un client se rétracte ou supprime son compte, le site prévient l’ERP. Un message forgé, modifié ou rejoué déclencherait un geste qu’on ne peut pas défaire.

Du coup, le corps du message et son horodatage sont signés en HMAC-SHA256. L’ERP commence par refuser un horodatage hors de la fenêtre, avant même de lire le corps. Ensuite il vérifie la signature. Pour les autres canaux, les secrets partagés sont comparés par empreinte, à temps constant.

verifySiteEventapps/erp/shared/server/site-request.ts · lignes 28–47
export async function verifySiteEvent(request: Request): Promise<SignedSiteEvent> {
	const key = env.SITE_EVENTS_SECRET;
	if (key === undefined) return { verdict: "unconfigured" };

	const timestamp = request.headers.get(SITE_EVENT_TIMESTAMP_HEADER) ?? "";
	const signature = request.headers.get(SITE_EVENT_SIGNATURE_HEADER) ?? "";
	if (!isSiteEventSignature(signature) || !isFreshSiteEventTimestamp(timestamp, wallClockMs())) {
		return { verdict: "refused" };
	}

	let body: string;
	try {
		body = await request.text();
	} catch {
		return { verdict: "refused" };
	}
	return (await isAuthenticSiteEvent(key, timestamp, body, signature))
		? { verdict: "accepted", body }
		: { verdict: "refused" };
}

Pour aller plus loin : Webhooks et échanges.

Changer le secret des webhooks Stripe ne coupe rien, et ne passe pas inaperçu

Un secret de signature, ça se change. Pendant la bascule, Stripe peut encore signer avec l’ancien. Si on refuse ces livraisons, on perd des paiements. Mais si on les accepte sans rien dire, une rotation pas terminée peut rester comme ça indéfiniment.

Donc on vérifie la signature avec le secret actuel, puis avec le précédent s’il est encore déclaré. Une livraison validée par l’ancien secret passe, mais elle déclenche une alerte.

verifyStripeEventapps/erp/shared/server/stripe.ts · lignes 38–67
export async function verifyStripeEvent(
	rawBody: string,
	signatureHeader: string,
): Promise<Stripe.Event> {
	const secret = env.STRIPE_WEBHOOK_SECRET;
	if (!secret) {
		throw new Error("Webhook Stripe non configuré\u00A0: STRIPE_WEBHOOK_SECRET absente.");
	}
	try {
		return getStripe().webhooks.constructEvent(rawBody, signatureHeader, secret);
	} catch (error) {
		const previous = env.STRIPE_WEBHOOK_SECRET_PREVIOUS;
		if (previous === undefined) throw error;
		const event = getStripe().webhooks.constructEvent(rawBody, signatureHeader, previous);
		logInfo({
			source: "payments",
			context: "webhook.signature",
			message: "livraison validée par le secret précédent",
			eventId: event.id,
			eventType: event.type,
		});
		await sendAlert({
			source: "payments",
			context: "webhook.signature",
			message: "signature validée par le secret PRÉCÉDENT — rotation inachevée",
			eventType: event.type,
		});
		return event;
	}
}

Pour aller plus loin : Stripe.

L’assistant ne peut pas sortir un chiffre de nulle part sans que la personne le voie

Un modèle de langage peut écrire un montant, une date ou une quantité qui ont l’air justes et qui sont faux. Dans un ERP, un chiffre faux affiché avec assurance, c’est pire que pas de réponse du tout.

C’est pour ça qu’à la fin de chaque tour, le code compare les nombres de la réponse avec tout ce que Fisher a reçu : la question, les extraits du manuel, la fiche ouverte et les résultats de ses lectures dans l’ERP. Si un nombre ne vient d’aucune source, il est signalé à la personne, à l’endroit même où il est écrit.

figureCheckapps/erp/shared/server/ai/stream.ts · lignes 151–181
/**
 * Chaque chiffre d'une réponse vient de l'ERP : à la fin du tour, ceux que ni
 * la question, ni les extraits, ni la fiche, ni une lecture ne portent sont signalés à la personne,
 * sous la réponse. Un instantané par tour : le dernier remplace les précédents.
 */
export function figureCheck(runId: string, facts: string): ChatMiddleware {
	const known: string[] = [facts];
	let text = "";
	return {
		name: "fisher-figure-check",
		onAfterToolCall: (_ctx, info) => {
			if (info.ok) known.push(JSON.stringify(info.result));
		},
		onChunk: (_ctx, chunk) => {
			if (chunk.type === "TEXT_MESSAGE_CONTENT") {
				text += chunk.delta;
				return;
			}
			if (chunk.type !== "RUN_FINISHED" || text.trim() === "") return;
			const unsupported = inventedNumbers(text.replace(LIST_NUMBER, ""), known.join("\n"));
			return [
				activitySnapshot({
					messageId: `chiffres-${runId}`,
					activityType: FISHER_FIGURES_ACTIVITY,
					content: { chiffres: unsupported },
				}),
				chunk,
			];
		},
	};
}

Pour aller plus loin : Fisher, ADR 0012.

Sur cette page