Chaque route de zanabler.com dit qui peut l’atteindre

Quatre couches, de Zana 2.21 à 2.23 : chaque route déclare qui peut l’atteindre, les tests attaquent chaque route, une version dangereuse ne peut pas être construite, et une liste relue consigne qui peut atteindre quoi. Appliqué aux 150 routes de ce site, avec des résultats réels.

Une liste de routes marquées de cadenas, de personnes et d’anneaux ouverts ; une nouvelle route surlignée en or attend l’approbation d’une personne.

La faille grave la plus fréquente des applications web n’est pas une attaque exotique. C’est une page qui a oublié de vérifier qui la demande. Un écran d’administration ajouté un vendredi sans son contrôle de permission, un export accessible sans connexion, un aperçu de brouillon que n’importe qui peut ouvrir. Chaque fois, il manque une seule ligne, et chaque fois la relecture de code ne voit rien, puisqu’il n’y a justement rien à voir.

Zana 2.21 à 2.23 attaquent ce problème sous quatre angles. Chaque route doit dire qui peut l’atteindre. Chaque route est attaquée par la suite de tests. Une version ne peut pas être construite tant qu’une règle échoue. Et une liste versionnée avec le code consigne qui peut atteindre chaque route, pour que chacun de ses changements soit relu par une personne.

Ce site applique les quatre. Ses 150 routes sont vérifiées à chaque construction : 86 exigent une permission, 62 sont publiques avec une raison écrite, et 2 sont ouvertes à tout éditeur connecté. Voici comment fonctionne chaque couche, avec les résultats réels de ce site et d’un petit projet de démonstration où nous avons commis les erreurs exprès.

Couche 1 : chaque route dit qui peut l’atteindre

Depuis Zana 2.21, une route qui ne dit rien est une erreur. Chaque route, ou la classe ou le groupe auquel elle appartient, déclare l’une de ces trois choses :

  • #[RequiresPermission('articles.edit')] : seuls les utilisateurs qui ont cette permission ;
  • #[RequiresAuthentication] : tout utilisateur connecté ;
  • #[PublicRoute(reason: '…')] : n’importe qui, et pourquoi.

La raison n’est pas décorative. C’est ce que lit le relecteur, et elle oblige l’auteur à énoncer son intention. Voici comment les pages de connexion de ce site la déclarent :

#[PublicRoute(reason: 'Signing in and out: the sign-in form is for people without a session yet, and signing out without one only leads back to it')]
final readonly class LoginController

Dans notre démonstration, nous avons ajouté deux pages comme on le fait souvent. La première est une page de recherche qui ne déclare rien. La seconde est une page de rapports qui exige une permission, mais sans le middleware qui la fait respecter. php bin/console check arrête les deux :

  ✘ GET /search does not say who may reach it. (modules/Site/Presentation/Web/SearchController.php:17)
      → Add #[RequiresAuthentication] or #[RequiresPermission('…')] with AuthorizationMiddleware on the route, or #[PublicRoute(reason: '…')] if anyone may reach it.
  ✘ GET /reports requires a user, but AuthorizationMiddleware is not on the route, so anyone reaches it. (modules/Site/Presentation/Web/ReportsController.php:18)
      → Add AuthorizationMiddleware to the route or its group. Authentication middleware alone lets anonymous requests through.

Le second constat est le plus subtil. Le code a l’air protégé : l’attribut est bien là. Mais un attribut n’est qu’une déclaration. Sans AuthorizationMiddleware sur la route, personne ne le lit, et la page est ouverte à tous. Zana repère l’écart entre ce que dit le code et ce qu’il fait.

Couche 2 : chaque route est attaquée

Les déclarations peuvent être fausses. Depuis Zana 2.22, la suite de tests attaque donc chaque route, en mémoire, à chaque exécution. Une seule ligne de tests/SecurityTest.php s’en charge :

$this->assertRoutesWithstandAttacks();

Les attaques dépendent de ce que déclare chaque route :

  • une route qui exige un utilisateur reçoit une requête anonyme et une session expirée, qui ne doivent jamais atteindre son handler ;
  • un formulaire reçoit une requête sans jeton CSRF, une avec un jeton falsifié, et un envoi depuis un autre site ;
  • une route limitée reçoit une requête de plus que sa limite ;
  • toute route ouverte à tous reçoit des entrées hostiles : un script, du SQL, une syntaxe de template, des chemins ../, des octets NUL, des valeurs très longues, une liste là où une valeur est attendue, un corps qui n’est pas du JSON et un corps de 2 Mo.

Cela attrape ce que les déclarations ne peuvent pas voir. Dans la démonstration, la page de recherche était désormais correctement déclarée publique, mais elle affichait la requête du visiteur telle quelle :

return $this->responses->html("<h1>Results for {$q}</h1>");

Le test d’attaque l’a trouvé, et a trouvé autre chose en plus :

7 route(s) attacked with 55 request(s): 2 failure(s).
  ✘ GET /search — a script in the query: the page prints the script as it was sent: a visitor could be made to run it.
  ✘ GET /search — a list where a value is expected: caused a PHP warning in the application: Array to string conversion (SearchController.php:21). Check the type of what the request sends before using it.

Le premier est une faille XSS (cross-site scripting) : un lien piégé pourrait faire exécuter le script de quelqu’un d’autre dans le navigateur d’un visiteur, sur notre site. Le second est le genre de fissure que les attaquants cherchent. Une fois le type vérifié et la sortie échappée, les 55 requêtes passent.

Les attaques tournent aussi en tant qu’utilisateur connecté. Le test de ce site se connecte en tant qu’éditeur et déclare ce qu’un éditeur détient. Les attaques vérifient alors que les écrans de gestion des comptes, qui exigent editors.manage, refusent un éditeur, et que chaque écran qu’un éditeur peut utiliser résiste aux formulaires falsifiés et aux entrées hostiles :

$this->assertRoutesWithstandAttacks(
    signIn: static fn (ServerRequestInterface $request): ServerRequestInterface => $request->withHeader('Cookie', $cookie),
    holding: self::EDITOR,
);

Sur ce site, les deux passes, anonyme et en tant qu’éditeur, font 2 554 vérifications en 19 secondes environ. Une nouvelle route est attaquée dès qu’elle existe, sans test à écrire pour elle.

Couche 3 : une version dangereuse ne peut pas être construite

Les contrôles ne servent que s’ils arrêtent quelque chose. Avec security.strict à true, comme dans les deux squelettes Zana et sur ce site, les règles de sécurité de check sont des erreurs et non des avertissements. L’intégration continue des squelettes lance les tests, check et composer audit à chaque push : une règle en échec bloque la fusion.

La commande de mise en ligne applique les mêmes règles au code qu’elle empaquette. Dans la démonstration, après avoir enregistré les deux nouvelles routes sans les faire relire :

 [ERROR] Nothing was built: the security rules of check report 2 error(s) (security.strict).

         [security.exposure] GET /reports is new, and not in the reviewed baseline security/exposure.json: users with reports.read may reach it.

Aucune archive n’est écrite : il n’y a rien à envoyer sur le serveur.

Couche 4 : une liste relue de qui peut atteindre quoi

Les trois premières couches garantissent que chaque route est déclarée et se comporte comme elle le déclare. Elles ne peuvent pas dire si la déclaration est juste. La page de rapports doit-elle vraiment être ouverte à quiconque détient reports.read ? Les brouillons doivent-ils pouvoir être prévisualisés par lien ? Ce sont des décisions, et les décisions appartiennent aux personnes.

Zana 2.23 les consigne dans un fichier versionné avec le code, security/exposure.json, à raison d’une ligne par route. En voici quelques-unes de ce site :

"GET /admin/account": {"access": "user"},
"GET /admin/editors": {"access": "permission", "permissions": ["editors.manage"]},
"GET /en/insights/{slug}": {"access": "public", "reason": "The public blog: published articles and their feeds"},
"POST /en/start-a-project": {"access": "public", "reason": "The \"Start a project\" form, for any visitor"},
"GET /preview/articles/{token}": {"access": "public", "reason": "A draft preview: the signed link an editor shares is the access, for an hour"},

Dès que quelque chose change, comme une nouvelle route, une route rendue publique ou une permission remplacée par une autre, check le signale. php bin/console security:exposure montre exactement ce qui diffère, sans rien écrire :

2 route(s) differ from the reviewed baseline security/exposure.json:
  + GET /reports: users with reports.read
  + GET /search: anyone (public: "Searching the public pages")
Nothing was written. Review each change; once reviewed, record them with security:exposure --update, and commit the file.

Montrer et approuver sont volontairement séparés. Relancer la commande n’approuve jamais rien. Seul --update enregistre un changement, et seul le fichier qu’il écrit est accepté : une modification à la main fait échouer le contrôle. Dans une pull request, le changement de exposure.json figure à côté du code qui l’a provoqué. Le relecteur lit « cette route est maintenant publique, parce que… » en une ligne, au lieu de devoir la chercher.

La même règle s’applique aux agents de codage IA. Le fichier AGENTS.md que Zana écrit dans chaque projet leur demande de montrer les changements et de les nommer un par un dans leur résumé, mais jamais de les enregistrer : enregistrer un changement l’approuve, et c’est la décision d’une personne.

Ce que ces couches ne font pas

La documentation de Zana est claire sur les limites :

  • Un utilisateur qui lit les données d’un autre n’est pas testé. Savoir si la facture 42 appartient à la personne qui la demande relève de votre application. Testez-le avec deux utilisateurs à vous.
  • Une raison déclarée est crue, pas jugée. Une raison faible passe check : c’est pour cela qu’elle est écrite, pour un relecteur.
  • Les attaques en tant qu’utilisateur connecté ne valent que la connexion que vous leur fournissez, et le CSRF est attaqué avec une session, pas avec un jeton d’accès.
  • Les attaques par entrées hostiles exécutent vos handlers, comme pourrait le faire un visiteur : elles tournent sur la base de test.

Ces couches ne remplacent pas la réflexion sur les accès. Elles garantissent que cette réflexion a lieu pour chaque route, à chaque fois, et que son résultat est écrit là où la personne suivante pourra le lire.

Amener une application existante à ce niveau

  1. Mettez à jour avec composer update et lancez php bin/console check. Chaque avertissement security.* nomme une route ou un réglage à corriger.
  2. Donnez à chaque route sa déclaration. Pour les pages d’un site, une ligne couvre tout un groupe : $router->group('', $routes, public: 'The public website').
  3. Ajoutez tests/SecurityTest.php, comme dans les squelettes, et corrigez ce qu’il trouve. Attendez-vous à des constats au premier passage ; chacun nomme la route et l’attaque.
  4. Quand check est propre, passez security.strict à true, et ajoutez composer audit à votre intégration continue.
  5. Lancez php bin/console security:exposure, relisez qui peut atteindre chaque route, enregistrez la référence avec --init, et versionnez security/exposure.json.

Sur ce site, il a suffi d’un commit de mise à jour et d’une relecture. Depuis, aucune route ne peut apparaître, s’ouvrir ou changer de permission sans que quelqu’un le dise.

Si vous voulez de l’aide pour appliquer cette démarche à votre propre application, construite avec Zana ou non, parlez-nous de votre projet.

Recevez nos nouveaux articles par e-mail

Un e-mail par mois. Vous confirmez votre adresse avant tout envoi.