Symfony 8.2 introduit KeyManagement, un chiffrement unifié adossé aux KMS

Symfony a présenté le 15 septembre 2026 le composant KeyManagement, une brique destinée à chiffrer les données sensibles d’une application sans jamais manipuler la clé maîtresse. Portée par Florent Morselli, la fonctionnalité arrivera dans Symfony 8.2, dont la sortie est attendue fin novembre 2026. Elle est publiée avec le statut expérimental : son API peut évoluer d’une version mineure à l’autre.

#Sortir la clé maîtresse de l’application

La promesse tient en une phrase : l’application ne connaît plus que des identifiants de clés, jamais le secret cryptographique lui-même. Le chiffrement et le déchiffrement sont délégués à un système de gestion de clés (KMS), qu’il soit hébergé chez un fournisseur cloud ou tourné localement pour le développement. Le paquet central symfony/key-management fournit les interfaces, le chiffrement enveloppe et les backends locaux ; chaque fournisseur distant s’ajoute par un paquet-pont dédié.

Cette séparation change la surface d’exposition d’un incident. Une base de données exfiltrée ne livre que des enveloppes inertes tant que l’attaquant n’a pas accès au KMS, une logique qui prolonge côté données la discipline de durcissement déjà appliquée aux serveurs et aux accès.

#Deux modes : direct pour les petits secrets, enveloppe pour le reste

Le mode direct envoie la donnée au KMS, qui renvoie le chiffré. Il convient aux charges courtes, un jeton d’API par exemple, et reste borné par les limites du fournisseur, de l’ordre de 4 Ko sur AWS KMS. Le mode enveloppe lève cette contrainte : la donnée est chiffrée localement en AES-256-GCM avec une clé de données générée à la volée, et seule cette clé de données est confiée au KMS. La taille du contenu devient indifférente.

use Symfony\Component\KeyManagement\Envelope;
use Symfony\Component\KeyManagement\EnvelopeEncrypter;
use Symfony\Component\KeyManagement\KeyLoader\InMemoryKeyLoader;
use Symfony\Component\KeyManagement\Local\SodiumKms;

// Backend local libsodium ; en production, un pont cloud prend le relais
$kms = new SodiumKms(new InMemoryKeyLoader([
    'app-key' => sodium_crypto_aead_xchacha20poly1305_ietf_keygen(),
]));

// Mode direct : charges courtes, le KMS voit le clair
$ciphertext = $kms->encrypt('app-key', $apiToken);
$apiToken   = $kms->decrypt($ciphertext);

// Mode enveloppe : toute taille, le KMS ne voit que la clé de données
$encrypter = new EnvelopeEncrypter($kms);
$envelope  = $encrypter->encrypt('app-key', $fileContents);
file_put_contents($path, $envelope);

$fileContents = $encrypter->decrypt(Envelope::fromBytes(file_get_contents($path)));

Les enveloppes sont indépendantes du fournisseur : une donnée chiffrée avec un backend se déchiffre avec un autre dès lors que la clé est accessible. Cette portabilité, couplée à une table optionnelle de clés de données, autorise le rewrap ligne par ligne, c’est-à-dire re-chiffrer sous une nouvelle clé sans jamais exposer le clair.

Une base exfiltrée ne livre que des enveloppes inertes tant que le KMS reste hors de portée.

#Configuration, injection et intégration Doctrine

Côté framework, les clients KMS se déclarent par DSN et se distinguent en développement grâce à un backend sodium://, sans dépendance cloud.

# config/packages/key_management.yaml
key_management:
    clients:
        aws: '%env(AWS_KMS_DSN)%'
        vault: '%env(VAULT_KMS_DSN)%'
    default_client: aws

when@dev:
    key_management:
        clients:
            aws: 'sodium://?keys[app-key]=%env(DEV_KMS_KEY)%'
            vault: 'sodium://?keys[app-key]=%env(DEV_KMS_KEY)%'

L’injection de dépendances suit les conventions habituelles, l’attribut #[Target] permettant de viser un client précis. Deux ponts Doctrine complètent l’ensemble : un type de colonne chiffrée et un attribut #[BlindIndexed] qui, via un index aveugle, rend une colonne chiffrée interrogeable malgré le caractère aléatoire du chiffrement.

use Doctrine\ORM\Mapping as ORM;
use Symfony\Component\KeyManagement\BlindIndex\Email;
use Symfony\Component\KeyManagement\Bridge\DoctrineOrm\Attribute\BlindIndexed;

#[ORM\Entity]
class User
{
    #[ORM\Column(type: 'encrypted_string')]
    private string $email = '';

    #[ORM\Column(length: 64)]
    #[BlindIndexed('email', Email::class)]
    private string $emailIndex = '';
}

Des commandes de console accompagnent l’exploitation : key-management:encrypt, key-management:decrypt, key-management:generate-data-key et key-management:rewrap-data-keys. Un panneau dédié dans la barre de débogage recense les appels au KMS en environnement de développement, dans le même esprit de traçabilité que le suivi d’infrastructure côté écosystème back-end.

#Ce qu’il faut retenir

KeyManagement standardise dans Symfony une pratique jusqu’ici bricolée projet par projet : le chiffrement applicatif adossé à un KMS. Le mode enveloppe, la portabilité des enveloppes et l’index aveugle répondent aux trois obstacles récurrents que sont la taille des données, le verrouillage fournisseur et la recherche sur colonnes chiffrées. Le statut expérimental invite à la prudence en production, mais la direction est claire et l’intégration Doctrine abaisse nettement le coût d’entrée.

Pour aller plus loin : la présentation officielle du composant sur le blog Symfony.