Symfony 8.2 bringt KeyManagement: einheitliche Verschlüsselung über jedes KMS

Am 15. September 2026 stellte Symfony KeyManagement vor, eine Komponente, die sensible Daten einer Anwendung verschlüsselt, ohne dass der Code je den Hauptschlüssel berührt. Beigetragen von Florent Morselli, zielt sie auf Symfony 8.2, das Ende November 2026 erscheinen soll. Sie erscheint als experimentell: Ihre API kann sich zwischen Minor-Versionen ändern.

#Den Hauptschlüssel aus der Anwendung heraushalten

Das Versprechen ist einfach: Die Anwendung kennt nur noch Schlüsselkennungen, nie das kryptografische Geheimnis selbst. Ver- und Entschlüsselung werden an ein Key-Management-System (KMS) delegiert, ob bei einem Cloud-Anbieter gehostet oder lokal für die Entwicklung betrieben. Das Kernpaket symfony/key-management liefert die Schnittstellen, die Umschlagverschlüsselung und die lokalen Backends; jeder entfernte Anbieter kommt über ein eigenes Bridge-Paket hinzu.

Diese Trennung verändert die Schadensreichweite eines Vorfalls. Eine abgeflossene Datenbank liefert nur inerte Umschläge, solange ein Angreifer nicht auch das KMS erreicht, und erweitert damit die Härtungsdisziplin, die bereits für Server und Zugänge gilt, auf die Datenebene.

#Zwei Modi: direkt für kleine Geheimnisse, Umschlag für den Rest

Der direkte Modus sendet die Nutzdaten an das KMS, das den Chiffretext zurückgibt. Er eignet sich für kurze Werte wie ein API-Token und bleibt an die Anbietergrenzen gebunden, etwa 4 KB bei AWS KMS. Der Umschlagmodus hebt diese Grenze auf: Die Daten werden lokal mit AES-256-GCM und einem spontan erzeugten Datenschlüssel verschlüsselt, und nur dieser Datenschlüssel geht an das KMS. Die Größe des Inhalts spielt keine Rolle mehr.

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

$kms = new SodiumKms(new InMemoryKeyLoader([
    'app-key' => sodium_crypto_aead_xchacha20poly1305_ietf_keygen(),
]));

$ciphertext = $kms->encrypt('app-key', $apiToken);
$apiToken   = $kms->decrypt($ciphertext);

$encrypter = new EnvelopeEncrypter($kms);
$envelope  = $encrypter->encrypt('app-key', $fileContents);
file_put_contents($path, $envelope);

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

Umschläge sind anbieterunabhängig: Mit einem Backend verschlüsselte Daten lassen sich mit einem anderen entschlüsseln, solange der Schlüssel erreichbar ist. Diese Portabilität erlaubt zusammen mit einer optionalen Datenschlüssel-Tabelle ein zeilenweises Rewrap, also das erneute Verschlüsseln unter einem neuen Schlüssel, ohne je den Klartext offenzulegen.

Eine abgeflossene Datenbank liefert nur inerte Umschläge, solange das KMS außer Reichweite bleibt.

#Konfiguration, Injection und Doctrine-Integration

Auf Framework-Seite werden KMS-Clients per DSN deklariert und in der Entwicklung durch ein sodium://-Backend ersetzt, ohne Cloud-Abhängigkeit.

# 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)%'

Die Dependency Injection folgt den üblichen Konventionen, wobei das Attribut #[Target] einen bestimmten Client auswählt. Zwei Doctrine-Bridges runden das Ganze ab: ein verschlüsselter Spaltentyp und ein Attribut #[BlindIndexed], das über einen Blind-Index eine verschlüsselte Spalte trotz des zufälligen Chiffretexts durchsuchbar macht.

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 = '';
}

Konsolenbefehle unterstützen den Betrieb: key-management:encrypt, key-management:decrypt, key-management:generate-data-key und key-management:rewrap-data-keys. Ein eigenes Panel in der Debug-Leiste listet die KMS-Aufrufe in der Entwicklungsumgebung auf, im selben Geist der Nachvollziehbarkeit, den das Infrastruktur-Monitoring dem Backend bringt.

#Das Wichtigste in Kürze

KeyManagement standardisiert in Symfony eine bisher projektweise zusammengebastelte Praxis: anwendungsseitige Verschlüsselung mit einem KMS im Rücken. Umschlagmodus, Umschlag-Portabilität und Blind-Index lösen die drei wiederkehrenden Hürden Datengröße, Anbieterbindung und Suche über verschlüsselte Spalten. Der experimentelle Status mahnt zur Vorsicht in der Produktion, doch die Richtung ist klar und die Doctrine-Integration senkt die Einstiegshürde deutlich.

Zum Weiterlesen: die offizielle Vorstellung der Komponente im Symfony-Blog.