Pourquoi Permissions Policy mérite votre attention

Une page web moderne peut demander beaucoup de choses au navigateur : accéder à la caméra, au micro, à la géolocalisation, au plein écran, au presse-papiers, aux capteurs, à certaines API de paiement ou encore à des fonctionnalités expérimentales. Cette richesse est utile, mais elle augmente aussi la surface d’exposition d’une application.

Permissions Policy, anciennement appelée Feature Policy, sert à définir quelles capacités du navigateur sont autorisées pour une page et pour les documents qu’elle embarque, notamment les iframes. Elle ne remplace pas les permissions utilisateur : un site ne peut pas utiliser la caméra sans consentement. En revanche, elle permet de dire au navigateur : « même si du code essaie d’utiliser cette fonctionnalité ici, elle doit rester interdite ».

C’est une approche complémentaire à d’autres mécanismes de sécurité HTTP. Une Content Security Policy limite les sources de scripts, styles, images ou connexions autorisées. Trusted Types durcit certaines injections DOM. Permissions Policy, elle, se concentre sur les capacités exposées par le navigateur.

Le principe : refuser par défaut, ouvrir explicitement

Une politique de permissions se définit principalement avec l’en-tête HTTP Permissions-Policy. Chaque directive cible une fonctionnalité et indique les origines autorisées à l’utiliser.

Exemple volontairement strict :

Permissions-Policy: camera=(), microphone=(), geolocation=(), payment=()

Ici, la caméra, le micro, la géolocalisation et l’API de paiement sont désactivés pour la page et ses descendants. Les parenthèses vides signifient : aucune origine n’est autorisée.

À l’inverse, on peut autoriser une fonctionnalité uniquement pour la page courante :

Permissions-Policy: geolocation=(self)

self désigne l’origine du document courant. Si votre application a réellement besoin de géolocalisation, elle peut y accéder après accord de l’utilisateur, mais une iframe tierce ne le pourra pas automatiquement.

On peut aussi autoriser une origine précise :

Permissions-Policy: camera=(self "https://visio.example")

Ce type de règle doit rester exceptionnel. Chaque origine ajoutée devient une capacité déléguée. Il faut donc documenter pourquoi elle est nécessaire, à quel écran elle correspond et quel risque elle introduit.

Cas concret : protéger une page avec des iframes tierces

Les iframes sont un cas fréquent : widget de paiement, carte, vidéo, outil de support, contenu marketing, espace partenaire. Même si ces intégrations sont légitimes, elles ne devraient pas recevoir toutes les capacités du navigateur par défaut.

Prenons une page qui affiche une vidéo externe, sans besoin de caméra, micro ni géolocalisation :

Permissions-Policy: camera=(), microphone=(), geolocation=(), fullscreen=(self "https://player.example")

La page interdit les API sensibles inutiles, mais autorise le plein écran pour le lecteur vidéo. La politique reste lisible : chaque autorisation correspond à un besoin fonctionnel.

Côté HTML, l’attribut allow d’une iframe permet aussi de déléguer certaines capacités localement :

<iframe
  src="https://player.example/video/42"
  title="Démonstration produit"
  allow="fullscreen"
></iframe>

L’en-tête HTTP définit le cadre global. L’attribut allow précise ce que l’iframe peut recevoir. Les deux doivent être cohérents : une iframe ne peut pas obtenir une capacité interdite par la politique du document parent.

Configurer Permissions Policy avec Node.js

Dans une application Node.js avec Express, on peut ajouter l’en-tête au niveau global. L’exemple suivant adopte une politique prudente pour une application qui n’a pas besoin d’API matérielles sensibles :

import express from "express";

const app = express();

app.use((req, res, next) => {
  res.setHeader(
    "Permissions-Policy",
    [
      "camera=()",
      "microphone=()",
      "geolocation=()",
      "payment=()",
      "usb=()",
      "bluetooth=()",
      "fullscreen=(self)"
    ].join(", ")
  );

  next();
});

app.get("/", (req, res) => {
  res.send("Application protégée par Permissions Policy");
});

app.listen(3000);

Ce code est simple, mais il faut éviter de copier-coller une liste de directives sans audit. Une politique trop large donne une fausse impression de sécurité. Une politique trop stricte peut casser certaines fonctionnalités légitimes, notamment sur des pages avec intégrations externes.

Une bonne méthode consiste à partir des écrans réels :

  • quelles API navigateur sont utilisées par l’application ;
  • quelles pages en ont besoin ;
  • quelles iframes tierces sont présentes ;
  • quelles fonctionnalités doivent leur être déléguées ;
  • quelles capacités peuvent être interdites partout.

Configurer l’en-tête avec Nginx

Dans une configuration Nginx, l’en-tête peut être ajouté au niveau du serveur ou d’un bloc location :

server {
  listen 443 ssl;
  server_name example.com;

  add_header Permissions-Policy "camera=(), microphone=(), geolocation=(), payment=(), fullscreen=(self)" always;

  location / {
    try_files $uri $uri/ /index.html;
  }
}

Le mot-clé always est important : il permet d’ajouter l’en-tête même sur certaines réponses d’erreur. C’est souvent souhaitable pour les en-têtes de sécurité.

Si une route précise a besoin d’une politique différente, par exemple une page de visioconférence, mieux vaut isoler cette route plutôt que d’assouplir toute l’application :

location /meeting/ {
  add_header Permissions-Policy "camera=(self), microphone=(self), geolocation=()" always;
  try_files $uri $uri/ /index.html;
}

Cette approche évite qu’une capacité sensible soit disponible sur des pages qui n’en ont pas besoin.

Vérifier côté JavaScript sans confondre les responsabilités

Permissions Policy n’est pas une API d’interface utilisateur. Elle ne sert pas à afficher une modale ou à gérer un état applicatif. Elle agit au niveau du navigateur. Votre code JavaScript doit donc rester défensif : vérifier le support, gérer les refus et prévoir un fallback.

Exemple avec la géolocalisation :

export async function getCurrentPosition(): Promise<GeolocationPosition | null> {
  if (!("geolocation" in navigator)) {
    return null;
  }

  return new Promise((resolve) => {
    navigator.geolocation.getCurrentPosition(
      (position) => resolve(position),
      () => resolve(null),
      {
        enableHighAccuracy: false,
        timeout: 5000,
        maximumAge: 60_000
      }
    );
  });
}

Si la politique interdit la géolocalisation, l’appel échouera. Si l’utilisateur refuse, il échouera aussi. Si le navigateur ne supporte pas l’API, le résultat sera également indisponible. L’interface ne doit pas supposer que la permission est acquise.

Cette logique rejoint le progressive enhancement : l’expérience principale doit rester utilisable, puis s’améliorer lorsque le contexte technique le permet.

Permissions Policy et architecture frontend

Dans une application frontend complexe, la politique ne devrait pas être décidée à la fin du projet. Elle fait partie de l’architecture, au même titre que le routage, le cache, la stratégie d’authentification ou les règles CSP.

Pour une application avec rendu serveur ou framework fullstack, vous pouvez adapter les en-têtes par route. Une page marketing, un tableau de bord, une page de paiement et une page de visioconférence n’ont pas les mêmes besoins. C’est particulièrement pertinent avec des architectures modernes comme Next.js, Nuxt ou des serveurs Node.js personnalisés.

Il faut toutefois éviter une granularité excessive. Une politique différente pour chaque micro-écran devient difficile à tester. En pratique, on peut souvent définir trois niveaux :

  • une politique globale stricte pour la majorité du site ;
  • quelques exceptions documentées pour les pages avec intégrations tierces ;
  • des routes sensibles isolées pour les fonctionnalités qui nécessitent caméra, micro, géolocalisation ou paiement.

La documentation interne est aussi importante que la configuration. Quand une directive est ouverte, il faut savoir pourquoi. Cela évite qu’une exception temporaire devienne un privilège permanent.

Erreurs fréquentes

La première erreur consiste à croire que Permissions Policy remplace les demandes de permission du navigateur. Ce n’est pas le cas. Elle limite ce qui est techniquement autorisable, mais l’utilisateur conserve le contrôle sur les permissions sensibles.

La deuxième erreur est de configurer uniquement l’attribut allow des iframes sans en-tête global. C’est utile, mais insuffisant pour établir une politique cohérente sur toute l’application.

La troisième erreur est d’autoriser trop largement les origines tierces. Une directive comme celle-ci doit déclencher une revue :

Permissions-Policy: camera=(self "https://widget.example" "https://partner.example")

Pourquoi ces deux partenaires ont-ils besoin de la caméra ? Sur quelles pages ? Pour quelle durée ? Existe-t-il une alternative moins permissive ? Ces questions sont précisément l’intérêt d’une politique explicite.

Enfin, il ne faut pas oublier les tests. Ouvrez les DevTools, inspectez les en-têtes réseau, testez les iframes, vérifiez les parcours critiques et surveillez les erreurs côté client. Comme pour la mesure de performance frontend, une politique fiable repose sur des observations réelles, pas seulement sur une intention de configuration.

Une couche discrète, mais structurante

Permissions Policy n’est pas la fonctionnalité web la plus visible. Elle ne produit pas d’interface spectaculaire et ne remplace pas une bonne conception applicative. Pourtant, elle apporte une propriété précieuse : la réduction explicite des capacités disponibles.

Dans une application professionnelle, tout code n’a pas besoin d’accéder à tout. Une page de lecture n’a pas besoin du micro. Un widget vidéo n’a pas besoin de la géolocalisation. Une iframe marketing n’a pas besoin du presse-papiers. En exprimant ces limites au niveau HTTP, vous transformez des hypothèses implicites en règles vérifiables.

C’est souvent ainsi que l’on améliore durablement la sécurité frontend : non pas avec une seule barrière magique, mais avec plusieurs contraintes claires, testées et maintenues.