Chiede le credenziali alle route che avvisano tutta la squadra (DD-024).

Le route in src/routes/api/public/ girano con la service role e saltano la RLS,
quindi DD-023 non le copre. Nessuna faceva un controllo di accesso: cercando
"authorization" in quella cartella l'unico header era lo User-Agent con cui
csi.ts chiama il portale CSI. Chiunque conoscesse l'URL poteva far suonare i
telefoni della squadra, e promemoria-palloni accetta perfino una POST con il
corpo vuoto.

La difesa apparente delle altre due — serve un id evento valido — non è una
difesa: l'id è "e" più il timestamp in base 36, compare negli URL che la squadra
si scambia ed è elencabile da qualsiasi utente loggato.

auth-route.server.ts porta i due controlli, diversi perché i chiamanti sono
diversi. apri-sondaggio e sollecita-presenze usano richiediAdmin: token della
sessione verificato con auth.getUser, poi ruolo admin da user_roles, la stessa
fonte di ruoli.ts. Il controllo precede la validazione dell'input, così la
risposta non rivela nemmeno se un evento esiste. promemoria-palloni usa
richiediSegreto, perché la chiama un cron che una sessione non ce l'ha: se
CRON_SEGRETO non è configurata la route resta chiusa con 503, perché una porta
che si riapre da sola quando manca una variabile non se ne accorge nessuno.

csi, push-config, push-subscribe e push-messaggio restano aperte: le chiamano il
browser prima del login e il service worker, dove qualsiasi segreto finirebbe
nel bundle.

Lato client i due pulsanti admin mandano il token con intestazioniAutenticate(),
letto al momento della chiamata e non da uno stato React.

permessi-route.test.ts copre il giro intero — nessun token, giocatore, admin —
avviando il server di sviluppo puntato al database locale, perché servono utenti
veri. Il controllo positivo è il 404: l'admin supera l'accesso e arriva alla
validazione. In api.test.ts restano i rifiuti che non richiedono un utente e
sparisce la verifica della validazione di sollecita-presenze, che ora sta dietro
all'accesso.

I limiti noti di palloni.md sono aggiornati: il secret che il piano originale
prevedeva ora c'è. Resta vero che nessun cron chiama la route, quindi il
promemoria quotidiano non parte da solo.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

src/components/crapp/RosaPresenze.tsx

@@ -9,6 +9,7 @@ import { statoMeta, type Giocatore, type Stato } from "@/lib/crapp-data";
 import { usePresenzeEvento, useSalvaPresenza } from "@/lib/presenze";
 import { useRosa } from "@/lib/rosa";
 import { useGiocatoreCorrente } from "@/lib/user-store";
+import { intestazioniAutenticate } from "@/lib/auth";
 import { useIsAdmin } from "@/lib/ruoli";
 import { dataOggi } from "@/lib/scout-live";
 
@@ -33,7 +34,7 @@ export function RosaPresenze({ eventoId, data }: { eventoId: string; data: strin
     try {
       const res = await fetch("/api/public/sollecita-presenze", {
         method: "POST",
-        headers: { "Content-Type": "application/json" },
+        headers: { "Content-Type": "application/json", ...(await intestazioniAutenticate()) },
         body: JSON.stringify({ eventoId, da: io?.nome }),
       });
       if (!res.ok) throw new Error();

src/components/crapp/SondaggioCacche.tsx

@@ -5,6 +5,7 @@ import { cn } from "@/lib/utils";
 import { Card } from "@/components/crapp/ui-bits";
 import { nomeCompleto, useGiocatoriSquadra } from "@/lib/giocatori-squadra";
 import { useGiocatoreCorrente } from "@/lib/user-store";
+import { intestazioniAutenticate } from "@/lib/auth";
 import { useIsAdmin } from "@/lib/ruoli";
 import { mediaPartita, sondaggioAperto, useCacche, useSalvaCacche } from "@/lib/cacche";
 
@@ -51,7 +52,7 @@ export function SondaggioCacche({
     try {
       const res = await fetch("/api/public/apri-sondaggio", {
         method: "POST",
-        headers: { "Content-Type": "application/json" },
+        headers: { "Content-Type": "application/json", ...(await intestazioniAutenticate()) },
         body: JSON.stringify({ eventoId }),
       });
       if (!res.ok) throw new Error();

src/lib/auth-route.server.ts

@@ -0,0 +1,69 @@
+/**
+ * Controllo di accesso per le route in `src/routes/api/public/` che inviano notifiche
+ * a tutta la squadra (DD-024).
+ *
+ * Quelle route usano la service role e saltano la RLS: senza un controllo qui, chiunque
+ * conosca l'URL può far suonare i telefoni di tutti. L'id di un evento non è un segreto —
+ * è un timestamp in base 36 e compare negli URL che la squadra si scambia — quindi non
+ * può fare da credenziale.
+ *
+ * Due tipi di chiamante, due controlli:
+ * - dall'app, per un'azione da amministratore -> `richiediAdmin`, che verifica il token
+ *   della sessione Supabase e poi il ruolo in `user_roles`;
+ * - da una macchina (cron), dove nessuna sessione esiste -> `richiediSegreto`.
+ *
+ * Entrambe tornano `null` quando la richiesta può proseguire, altrimenti la `Response` di
+ * rifiuto già pronta.
+ */
+
+/** Il token della sessione Supabase, se la richiesta ne porta uno ben formato. */
+function tokenDaRichiesta(request: Request): string | null {
+  const intestazione = request.headers.get("authorization");
+  if (!intestazione?.startsWith("Bearer ")) return null;
+  const token = intestazione.slice("Bearer ".length).trim();
+  // Un JWT ha tre segmenti: scartarlo qui evita una chiamata di rete per ogni rumore.
+  return token && token.split(".").length === 3 ? token : null;
+}
+
+/**
+ * Lascia passare solo un amministratore autenticato. `401` se manca o non vale il token,
+ * `403` se il token è buono ma l'utente non è admin.
+ */
+export async function richiediAdmin(request: Request): Promise<Response | null> {
+  const token = tokenDaRichiesta(request);
+  if (!token) return new Response("Autenticazione richiesta", { status: 401 });
+
+  const { supabaseAdmin } = await import("@/integrations/supabase/client.server");
+
+  const { data: utente, error } = await supabaseAdmin.auth.getUser(token);
+  if (error || !utente?.user) return new Response("Sessione non valida", { status: 401 });
+
+  // Stessa fonte di `src/lib/ruoli.ts`: i permessi stanno solo in `user_roles` (DD-011).
+  const { data: ruolo } = await supabaseAdmin
+    .from("user_roles")
+    .select("role")
+    .eq("user_id", utente.user.id)
+    .eq("role", "admin")
+    .maybeSingle();
+
+  if (!ruolo) return new Response("Riservato agli amministratori", { status: 403 });
+  return null;
+}
+
+/**
+ * Lascia passare solo chi conosce `CRON_SEGRETO`, per le chiamate senza sessione.
+ *
+ * Se la variabile non è configurata la route resta chiusa: una porta che si apre da sola
+ * quando manca una configurazione è peggio di una porta che non funziona, perché nessuno
+ * se ne accorge.
+ */
+export function richiediSegreto(request: Request): Response | null {
+  const atteso = process.env["CRON_SEGRETO"];
+  if (!atteso) {
+    console.error("[auth] CRON_SEGRETO non configurato: la route resta chiusa");
+    return new Response("Route non configurata", { status: 503 });
+  }
+  const fornito = request.headers.get("x-cron-segreto");
+  if (fornito !== atteso) return new Response("Segreto non valido", { status: 401 });
+  return null;
+}

src/lib/auth.ts

@@ -47,6 +47,17 @@ export function useSessione() {
   };
 }
 
+/**
+ * Intestazioni con il token della sessione, per le route server che verificano il ruolo
+ * (DD-024). Letta al momento della chiamata e non da uno stato React, così non si spedisce
+ * un token già scaduto.
+ */
+export async function intestazioniAutenticate(): Promise<Record<string, string>> {
+  const { data } = await supabase.auth.getSession();
+  const token = data.session?.access_token;
+  return token ? { Authorization: `Bearer ${token}` } : {};
+}
+
 export async function accediConGoogle(): Promise<void> {
   const { error } = await supabase.auth.signInWithOAuth({
     provider: "google",

src/routes/api/public/apri-sondaggio.ts

@@ -1,5 +1,6 @@
 import { createFileRoute } from "@tanstack/react-router";
 import { z } from "zod";
+import { richiediAdmin } from "@/lib/auth-route.server";
 import { leggiEventi } from "@/lib/eventi.server";
 import { inviaPush } from "@/lib/webpush.server";
 
@@ -10,6 +11,9 @@ export const Route = createFileRoute("/api/public/apri-sondaggio")({
   server: {
     handlers: {
       POST: async ({ request }) => {
+        const negato = await richiediAdmin(request);
+        if (negato) return negato;
+
         const parsed = schema.safeParse(await request.json());
         if (!parsed.success) return new Response("Dati non validi", { status: 400 });
 

src/routes/api/public/promemoria-palloni.ts

@@ -1,4 +1,5 @@
 import { createFileRoute } from "@tanstack/react-router";
+import { richiediSegreto } from "@/lib/auth-route.server";
 import { nomeCompleto } from "@/lib/giocatori-squadra";
 import { leggiGiocatoriSquadra } from "@/lib/giocatori-squadra.server";
 import { completaTurni, destinatariPromemoriaPalloni, oggiISO } from "@/lib/palloni-core";
@@ -8,7 +9,11 @@ import { leggiEventi } from "@/lib/eventi.server";
 export const Route = createFileRoute("/api/public/promemoria-palloni")({
   server: {
     handlers: {
-      POST: async () => {
+      POST: async ({ request }) => {
+        // Chiamata da un cron, senza sessione: qui vale il segreto condiviso.
+        const negato = richiediSegreto(request);
+        if (negato) return negato;
+
         const { supabaseAdmin } = await import("@/integrations/supabase/client.server");
 
         const { data: righe } = await supabaseAdmin

src/routes/api/public/sollecita-presenze.ts

@@ -1,5 +1,6 @@
 import { createFileRoute } from "@tanstack/react-router";
 import { z } from "zod";
+import { richiediAdmin } from "@/lib/auth-route.server";
 import { formatData } from "@/lib/crapp-data";
 import { leggiEventi } from "@/lib/eventi.server";
 import { leggiGiocatoriSquadra } from "@/lib/giocatori-squadra.server";
@@ -14,6 +15,9 @@ export const Route = createFileRoute("/api/public/sollecita-presenze")({
   server: {
     handlers: {
       POST: async ({ request }) => {
+        const negato = await richiediAdmin(request);
+        if (negato) return negato;
+
         const parsed = schema.safeParse(await request.json());
         if (!parsed.success) return new Response("Dati non validi", { status: 400 });