Trau dem Algorithmus nicht, den eine Lizenz angibt
Ein signiertes Lizenz-Token, das sein eigenes Algorithmusfeld mitführt, lädt zum klassischen Algorithmus-Confusion-Angriff ein: Setz es auf "none" oder auf HMAC mit deinem eigenen öffentlichen Schlüssel, und ein Prüfer, der anhand dieses Felds verzweigt, winkt die Fälschung durch. Diese Analyse zeigt die exakte Fälschung gegen ein Ed25519-Token, die zwei Zeilen C#, die sie möglich machen, und warum ein korrekter Prüfer den Algorithmus beim Deployment festlegt und nie den liest, den das Token angibt.
Ein Lizenz-Token hat oft die Form eines JWT: ein Header, eine Nutzlast, eine Signatur, jeweils base64url-kodiert und mit Punkten verbunden. Der Header benennt den Algorithmus — {"alg":"Ed25519"} —, damit der Prüfer weiß, was er ausführen soll. Es liest sich sauber, es ist selbstbeschreibend, und es trägt die gefährlichste Idee der Token-Sicherheit in sich. Das Algorithmusfeld reist mit dem Token, was heißt, es wird von demjenigen kontrolliert, der das Token hält, was heißt, ein Angreifer darf wählen, welche kryptografische Prüfung dein Client ausführt. Das ist die Familie der Algorithmus-Confusion-Angriffe, und sie hat echten Lizenzierungscode genauso leise gebrochen, wie sie frühe JWT-Bibliotheken gebrochen hat.
Kernaussage: Der Algorithmus, mit dem eine Signatur geprüft wird, ist eine Eigenschaft deines Deployments, nicht des Tokens vor dir. Ein korrekter Prüfer legt Algorithmus und öffentlichen Schlüssel zur Build- oder Deploy-Zeit fest und verzweigt nie anhand des alg, das das Token angibt. Der Angriff funktioniert genau deshalb, weil der naive Prüfer eben doch danach verzweigt: Setz das Feld auf none, und die Signaturprüfung wird übersprungen, oder setz es auf HMAC, und der Angreifer signiert mit deinem eigenen öffentlichen Schlüssel, der kein Geheimnis ist. Die Lösung ist, den Zweig zu löschen, der das Feld liest.
Die eigentliche Frage: Wer wählt den Algorithmus?
Betrachte einen Prüfer, der drei Signaturalgorithmen unterstützt, weil das Produkt über die Jahre einige ausgeliefert hat. Er liest den Header, verzweigt per switch über den Namen und ruft die passende Prüfung auf:
// VULNERABLE: the token chooses which check runs.
public static bool VerifyNaive(LicenseToken token, VerificationKeys keys)
{
string signingInput = token.HeaderB64 + "." + token.PayloadB64;
return token.Header.Alg switch
{
"none" => true, // skips verification entirely
"HS256" => HmacMatches(signingInput, token.Signature, // symmetric: key is the "secret"
keys.Ed25519PublicKey),
"ES256" => EcdsaVerify(signingInput, token.Signature, keys.EcdsaPublicKey),
"Ed25519" => Ed25519Verify(signingInput, token.Signature, keys.Ed25519PublicKey),
_ => false,
};
}
Jede Zeile hier wirkt defensiv. Es gibt eine Whitelist von Algorithmen, ein explizites default => false, echte Signaturprüfung für die asymmetrischen Fälle. Und es ist auf zwei verschiedene Arten fälschbar durch jeden, der je ein gültiges Token erhalten hat und den öffentlichen Schlüssel lesen kann — was in einem offline-first-Client jeder ist, denn der öffentliche Schlüssel ist in die Binärdatei eingebettet, damit die Anwendung ohne Server prüfen kann.
Fälschung eins: alg: none
Der none-Zweig existiert, weil irgendwo, irgendwann ein unsigniertes Token für ein Test-Fixture praktisch war. Der Angreifer nimmt ein echtes Token, dekodiert den Header aus base64url, schreibt ihn zu {"alg":"none"} um, kodiert ihn neu und lässt die Nutzlast auf dem stehen, was er will — "tier":"enterprise", ein Ablauf in einem Jahrzehnt. Das Signatursegment kann leer sein. VerifyNaive sieht none, gibt true zurück, und die gefälschte Nutzlast wird als vertrauenswürdig behandelt. Es wurde keine Kryptografie besiegt, weil keine ausgeführt wurde.
Fälschung zwei: Schlüssel-Confusion
Die zweite Fälschung ist die subtile, und sie ist der Grund, warum „entferne einfach den none-Zweig” nicht genügt. Der Angreifer deklariert einen symmetrischen Algorithmus — HS256 — und nutzt die Asymmetrie aus, die der Prüfer vergaß. Ein öffentlicher Ed25519-Schlüssel ist öffentlich: Er ist im Client, damit eine legitime Offline-Prüfung laufen kann. HMAC-SHA256 nimmt ein geteiltes Geheimnis. Der naive Prüfer, der keinen eigenen HS256-Schlüssel hat, reicht den einzigen Schlüssel, den er besitzt — den öffentlichen Ed25519-Schlüssel — an HmacMatches weiter. Also berechnet der Angreifer denselben HMAC über seine gewählte Signatureingabe mit genau diesen Bytes des öffentlichen Schlüssels als Geheimnis, und der Prüfer berechnet ein identisches Tag neu und akzeptiert es.
alg-Feld des Tokens die Prüfung wählen; der festgelegte Pfad legt den Algorithmus beim Deployment fest und ignoriert, was das Token angibt.Die Fälschung sind ein paar Zeilen im eigenen Code des Angreifers:
// Attacker side — needs only the public key shipped in the client.
string header = Base64Url(Encoding.UTF8.GetBytes("{\"alg\":\"HS256\"}"));
string payload = Base64Url(Encoding.UTF8.GetBytes("{\"tier\":\"enterprise\",\"exp\":\"2036-01-01\"}"));
string signingInput = header + "." + payload;
using var h = new HMACSHA256(ed25519PublicKeyBytes); // public key AS the HMAC secret
byte[] tag = h.ComputeHash(Encoding.ASCII.GetBytes(signingInput));
string forged = signingInput + "." + Base64Url(tag); // verifies against VerifyNaive
Nichts Exotisches ist geschehen. Der Angreifer hat den privaten Schlüssel nie gesehen. Er stützte sich auf die Tatsache, dass der Prüfer das Token ein symmetrisches Verfahren vorschlagen ließ und ihm dann das einzige herumliegende Schlüsselmaterial reichte.
Die Lösung: Der Prüfer besitzt den Algorithmus
Der korrekte Prüfer hat keinen switch. Er weiß, als Tatsache dieses Deployments, dass Lizenzen mit Ed25519 und einem festgelegten öffentlichen Schlüssel signiert sind, und er führt genau diese Prüfung aus:
// SAFE: the deployment pins the algorithm; the token has no say.
public sealed class LicenseVerifier
{
private readonly PublicKey _pinned; // Ed25519, loaded once at startup
public LicenseVerifier(ReadOnlySpan<byte> ed25519PublicKey) =>
_pinned = PublicKey.Import(SignatureAlgorithm.Ed25519,
ed25519PublicKey, KeyBlobFormat.RawPublicKey);
public bool Verify(LicenseToken token)
{
byte[] input = Encoding.ASCII.GetBytes(token.HeaderB64 + "." + token.PayloadB64);
// token.Header.Alg is NEVER consulted to choose a path.
return SignatureAlgorithm.Ed25519.Verify(_pinned, input, token.Signature);
}
}
(Die obige API ist NSec.Cryptography, das Keyright für Ed25519 auf Frameworks nutzt, wo System.Security.Cryptography es noch nicht bereitstellt.) Ein gefälschtes alg: none-Token hat keine gültige Ed25519-Signatur, also gibt Verify false zurück. Die HMAC-Fälschung erzeugt 32 Bytes, die keine 64-Byte-Ed25519-Signatur über die Eingabe sind, also scheitert sie ebenfalls. Keine Fälschung überlebt, denn keine kann die festgelegte Prüfung ohne den privaten Schlüssel bestehen lassen.
Wenn du das alg-Feld für Diagnose oder eine Migration behalten willst, lies es nur nachdem ein festgelegter Prüfer die Signatur bereits validiert hat, und nutze es ausschließlich, um eine Abweichung zu verwerfen:
if (!verifier.Verify(token)) return LicenseResult.Invalid;
if (token.Header.Alg != "Ed25519") return LicenseResult.Invalid; // defence in depth, post-verify
Diese Reihenfolge ist die ganze Disziplin: Kryptografie zuerst, mit einem Algorithmus, den du gewählt hast; der Selbstbeschreibung des Tokens wird nie vertraut, die Prüfung zu steuern.
Wie das in Keyright zur Anwendung kommt
Der Prüfer des Keyright-SDK ist per Konstruktion festgelegt. Du übergibst ihm den öffentlichen Schlüssel, den du beim Anlegen des Produkts erhalten hast, und er führt nur den Algorithmus aus, der dieser Schlüssel ist. Es gibt keinen Konfigurationsschalter, der einen Algorithmus aus dem Token liest, also hat keine der beiden obigen Fälschungen eine Angriffsfläche. Für Teams, die zuerst ein selbstgebautes Schema mitschleppten, ist das die häufigste Schwachstelle, die wir in Migrationsaudits sehen — eine JWT-Bibliothek, die so konfiguriert ist, dass sie „jeden unterstützten Algorithmus” akzeptiert, standardmäßig aktiv gelassen.
Wenn du während einer Schlüsselrotation mehr als einen Algorithmus betreibst, legst du beide fest und akzeptierst ein Token, das einer der festgelegten Prüfer validiert. Das ist weiterhin das Deployment, das seinen vertrauenswürdigen Satz wählt, nicht das Token:
bool ok = _current.Verify(token) || _previousDuringOverlap.Verify(token);
Das Überlappungsfenster der Rotation selbst — unter dem neuen Schlüssel ausstellen und gleichzeitig den alten noch akzeptieren — wird im Beitrag zur Signaturschlüssel-Rotation behandelt; hier geht es nur darum, dass es nie bedeutet, den Algorithmus aus der Leitung zu lesen.
Vorbehalte und die ehrlichen Grenzen
Das ersetzt nicht den Rest der Prüfung. Den Algorithmus festzulegen stoppt eine gefälschte Signatur. Es tut nichts gegen das Replay eines echten Tokens, einen widerrufenen Schlüssel, der weiterhin akzeptiert wird, oder eine abgelaufene Lizenz, deren exp du zu prüfen vergessen hast. Die Signatur festzulegen ist ein Tor; Widerruf und Ablauf sind andere.
Der zeitkonstante Vergleich zählt weiterhin für die symmetrischen Pfade, die du behältst. Wenn du irgendwo legitim einen HMAC prüfst — etwa einen eingehenden Abrechnungs-Webhook —, vergleiche die Tags mit CryptographicOperations.FixedTimeEquals, nicht mit == oder SequenceEqual, damit ein byteweises Timing-Leck einem Angreifer nicht das Tag liefert. Das ist ein von der Algorithmus-Confusion getrennter Fehler, aber er lebt im selben Code.
Ein festgelegter Prüfer kann einen gepatchten Client nicht schützen. Wenn ein Angreifer deine Verify-Methode zu return true umschreibt, hilft keine Algorithmus-Disziplin — das ist ein Manipulationsproblem, kein Signaturproblem —, und die Antwort ist, die Prüfung selbst zu schützen. Keyright mit der Obfuskierung und dem Manipulationsschutz von Nebula.NET zu kombinieren ist, wie man verhindert, dass der Prüfer der Patch-Punkt wird.
Fazit
Ein selbstbeschreibendes Token ist eine Bequemlichkeit, die eine Sicherheitsentscheidung stillschweigend an denjenigen delegiert, der das Token hält. Der Algorithmus, mit dem eine Signatur geprüft wird, gehört deinem Deployment, nicht den Bytes auf der Leitung: Leg ihn fest, führ ihn aus, und lass nie einen switch das alg lesen, das das Token angibt — dieser eine Zweig ist es, der einen öffentlichen Schlüssel in ein Fälschungswerkzeug und ein alg: none in einen Generalschlüssel verwandelt. Keyright liefert einen Prüfer, der per Konstruktion festgelegt ist, sodass der Zweig gar nicht existiert, um ausgenutzt zu werden; die Community Edition ist kostenlos und selbst gehostet, was heißt, du kannst einen Schlüssel ausstellen, das Token-Format inspizieren und von Ende zu Ende gegen deinen eigenen Client zu fälschen versuchen, bevor du ihm in der Produktion vertraust. Die vollständige SDK-Oberfläche steht in der Keyright-Dokumentation.
Nebula.NET testen
Härten Sie Ihren .NET-Code in wenigen Minuten — starten Sie mit der kostenlosen Edition.