Skip to content
← Tous les articles
· Delta1 Labs SecurityKeyright

Ne faites pas confiance à l'algorithme déclaré par une licence

Un jeton de licence signé qui transporte son propre champ d'algorithme invite l'attaque classique de confusion d'algorithme : passez-le à « none », ou à un HMAC utilisant votre propre clé publique, et un vérificateur qui aiguille selon ce champ laisse passer la contrefaçon. Cette analyse montre la contrefaçon exacte contre un jeton Ed25519, les deux lignes de C# qui la rendent possible, et pourquoi un vérificateur correct fixe l'algorithme au déploiement et ne lit jamais celui que le jeton déclare.

Un jeton de licence a souvent la forme d’un JWT : un en-tête, une charge utile, une signature, chacun encodé en base64url et joint par des points. L’en-tête nomme l’algorithme — {"alg":"Ed25519"} — afin que le vérificateur sache quoi exécuter. Cela se lit proprement, c’est autodescriptif, et cela transporte l’idée la plus dangereuse de la sécurité des jetons. Le champ d’algorithme voyage avec le jeton, ce qui signifie qu’il est contrôlé par quiconque détient le jeton, ce qui signifie qu’un attaquant peut choisir quelle vérification cryptographique votre client exécute. C’est la famille des attaques de confusion d’algorithme, et elle a discrètement cassé du vrai code de licenciement comme elle a cassé les premières bibliothèques JWT.

À retenir : L’algorithme utilisé pour vérifier une signature est une propriété de votre déploiement, non du jeton devant vous. Un vérificateur correct fixe l’algorithme et la clé publique au moment de la compilation ou du déploiement et n’aiguille jamais selon le alg que le jeton déclare. L’attaque fonctionne précisément parce que le vérificateur naïf aiguille bien selon lui : passez le champ à none et la vérification de signature est sautée, ou passez-le à HMAC et l’attaquant signe avec votre propre clé publique, qui n’est pas un secret. La solution est de supprimer la branche qui lit le champ.

La vraie question : qui choisit l’algorithme ?

Considérez un vérificateur qui prend en charge trois algorithmes de signature parce que le produit en a livré plusieurs au fil des ans. Il lit l’en-tête, fait un switch sur le nom et appelle la vérification correspondante :

// 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,
    };
}

Chaque ligne ici semble défensive. Il y a une liste blanche d’algorithmes, un default => false explicite, une vraie vérification de signature pour les cas asymétriques. Et c’est contrefaisable de deux manières différentes par quiconque a déjà reçu un jeton valide et peut lire la clé publique — ce qui, dans un client priorisant le hors ligne, est tout le monde, car la clé publique est intégrée dans le binaire afin que l’application puisse vérifier sans serveur.

Contrefaçon un : alg: none

La branche none existe parce que quelque part, un jour, un jeton non signé était pratique pour une fixture de test. L’attaquant prend un jeton authentique, décode l’en-tête en base64url, le réécrit en {"alg":"none"}, le réencode et laisse la charge utile à ce qu’il veut — "tier":"enterprise", une expiration dans une décennie. Le segment de signature peut être vide. VerifyNaive voit none, renvoie true et la charge utile contrefaite est approuvée. Aucune cryptographie n’a été vaincue parce qu’aucune n’a été exécutée.

Contrefaçon deux : confusion de clé

La deuxième contrefaçon est la subtile, et c’est la raison pour laquelle « supprimez simplement la branche none » ne suffit pas. L’attaquant déclare un algorithme symétrique — HS256 — et exploite l’asymétrie que le vérificateur a oubliée. Une clé publique Ed25519 est publique : elle est dans le client, afin qu’une vérification hors ligne légitime puisse s’exécuter. HMAC-SHA256 prend un secret partagé. Le vérificateur naïf, n’ayant pas de clé HS256 propre, passe la seule clé qu’il possède — la clé publique Ed25519 — à HmacMatches. L’attaquant calcule donc le même HMAC sur son entrée de signature choisie en utilisant ces octets exacts de la clé publique comme secret, et le vérificateur recalcule une étiquette identique et l’accepte.

Même jeton contrefait — deux vérificateursjeton contrefait{"alg":"HS256"}tier=enterpriseVULNÉRABLE : aiguille selon algswitch (token.Header.Alg)"HS256" → HMAC avec la clé PUBLIQUE Ed25519la clé publique n'est pas secrète → l'attaquant la connaîtl'étiquette recalculée correspondACCEPTÉ — contrefaçon approuvéeFIXÉ : le déploiement choisit l'algEd25519.Verify(pinnedPubKey, input, sig)token.Header.Alg n'est jamais lu pour aiguillerl'étiquette HMAC n'est pas une signature Ed25519 valideREJETÉ — contrefaçon stoppéeLa seule différence est si des données contrôlées par l'attaquant choisissent le chemin de code.
Un jeton contrefait, deux vérificateurs. Le chemin vulnérable laisse le propre champ alg du jeton choisir la vérification ; le chemin fixé fixe l'algorithme au déploiement et ignore ce que le jeton déclare.

La contrefaçon tient en quelques lignes du propre code de l’attaquant :

// 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

Rien d’exotique ne s’est produit. L’attaquant n’a jamais vu la clé privée. Il s’est appuyé sur le fait que le vérificateur a laissé le jeton proposer un schéma symétrique puis lui a tendu le seul matériel de clé qui traînait.

La solution : le vérificateur possède l’algorithme

Le vérificateur correct n’a pas de switch. Il sait, comme un fait de ce déploiement, que les licences sont signées en Ed25519 avec une clé publique fixée, et il exécute exactement cette vérification :

// 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);
    }
}

(L’API ci-dessus est NSec.Cryptography, que Keyright utilise pour Ed25519 sur les frameworks où System.Security.Cryptography ne l’expose pas encore.) Un jeton contrefait alg: none n’a pas de signature Ed25519 valide, donc Verify renvoie false. La contrefaçon HMAC produit 32 octets qui ne sont pas une signature Ed25519 de 64 octets sur l’entrée, donc elle échoue aussi. Aucune contrefaçon ne survit, car aucune ne peut faire passer la vérification fixée sans la clé privée.

Si vous voulez conserver le champ alg pour le diagnostic ou une migration, ne le lisez qu’après qu’un vérificateur fixé a déjà validé la signature, et utilisez-le uniquement pour rejeter une incohérence :

if (!verifier.Verify(token)) return LicenseResult.Invalid;
if (token.Header.Alg != "Ed25519") return LicenseResult.Invalid;   // defence in depth, post-verify

Cet ordre est toute la discipline : la cryptographie d’abord, avec un algorithme que vous avez choisi ; l’autodescription du jeton n’est jamais digne de confiance pour diriger la vérification.

Comment cela s’applique dans Keyright

Le vérificateur du SDK de Keyright est fixé par construction. Vous lui remettez la clé publique obtenue à la création du produit, et il n’exécute que l’algorithme que cette clé est. Il n’y a pas de commutateur de configuration qui lit un algorithme dans le jeton, donc aucune des deux contrefaçons ci-dessus n’a de surface où atterrir. Pour les équipes qui ont d’abord traîné un schéma maison, c’est la vulnérabilité la plus courante que nous voyons dans les audits de migration — une bibliothèque JWT configurée pour accepter « n’importe quel algorithme pris en charge », laissée active par défaut.

Si vous exécutez plus d’un algorithme pendant une rotation de clés, vous fixez les deux et acceptez un jeton que l’un ou l’autre des vérificateurs fixés valide. C’est encore le déploiement qui choisit son ensemble de confiance, non le jeton :

bool ok = _current.Verify(token) || _previousDuringOverlap.Verify(token);

La fenêtre de recouvrement de la rotation elle-même — émettre sous la nouvelle clé tout en acceptant encore l’ancienne — est traitée dans l’article sur la rotation des clés de signature ; ici, le seul point est qu’elle ne signifie jamais lire l’algorithme sur le fil.

Mises en garde et les limites honnêtes

Ceci ne remplace pas le reste de la vérification. Fixer l’algorithme stoppe une signature contrefaite. Cela ne fait rien contre la réémission d’un jeton authentique, une clé révoquée encore acceptée, ou une licence expirée dont vous avez oublié de vérifier le exp. Fixer la signature est une porte ; la révocation et l’expiration en sont d’autres.

La comparaison à temps constant compte encore pour les chemins symétriques que vous conservez. Si vous vérifiez légitimement un HMAC quelque part — un webhook de facturation entrant, par exemple —, comparez les étiquettes avec CryptographicOperations.FixedTimeEquals, non avec == ni SequenceEqual, afin qu’une fuite de temporisation octet par octet ne livre pas l’étiquette à un attaquant. C’est un bogue distinct de la confusion d’algorithme mais il vit dans le même code.

Un vérificateur fixé ne peut pas protéger un client qui a été patché. Si un attaquant réécrit votre méthode Verify en return true, aucune discipline d’algorithme n’aide — c’est un problème de falsification, non de signature —, et la réponse est de protéger la vérification elle-même. Associer Keyright à l’obfuscation et à l’anti-falsification de Nebula.NET est la façon d’empêcher que le vérificateur soit le point de patch.

À retenir

Un jeton autodescriptif est une commodité qui délègue discrètement une décision de sécurité à quiconque détient le jeton. L’algorithme utilisé pour vérifier une signature appartient à votre déploiement, non aux octets sur le fil : fixez-le, exécutez-le, et ne laissez jamais un switch lire le alg que le jeton déclare — cette unique branche est ce qui transforme une clé publique en outil de contrefaçon et un alg: none en passe-partout. Keyright livre un vérificateur fixé par construction, de sorte que la branche n’existe pas pour être exploitée ; la Community Edition est gratuite et auto-hébergée, ce qui signifie que vous pouvez émettre une clé, inspecter le format du jeton et tenter de contrefaire contre votre propre client de bout en bout avant de lui faire confiance en production. La surface complète du SDK est dans la documentation de Keyright.

Essayez Nebula.NET

Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.