Des articles approfondis sur les technologies qui façonnent l'avenir.

Dépassement EVP_EncodeBlock d'OpenSSL : 5 mythes testés

Le dépassement de tampon EVP_EncodeBlock d'OpenSSL (CVSS 9.8) montre comment les API d'encodage base64 échappent aux contrôles. Cinq mythes testés.

Un énorme entonnoir verse des cubes lumineux dans un petit verre qui déborde.
EVP_EncodeBlock fait confiance à l'appelant pour avoir bien dimensionné le verre — il ne vérifie jamais.

Une fonction qui se contente de transformer des octets en texte base64 vient de recevoir un score CVSS de 9.8. Le dépassement de tampon EVP_EncodeBlock dans OpenSSL, suivi sous le nom CVE-2026-121481, est le genre de bug qui paraît anodin jusqu'à ce qu'on réalise que l'encodage base64 se trouve sous la gestion des certificats, les clients HTTP, l'authentification auprès des proxys et la moitié du code de liaison de votre infrastructure. Le correctif lui-même a demandé quatre commits et une discussion houleuse entre mainteneurs sur ce que devrait réellement être une valeur de retour d'erreur.

La discussion autour de cette CVE est une vraie mine d'or pour quiconque s'intéresse à la conception d'API, car elle met au jour toute une série d'hypothèses que les ingénieurs font sur les fonctions d'encodage. Ces hypothèses continuent de produire la même classe de bugs, depuis des décennies et dans de nombreuses bibliothèques. Prenons cinq des croyances les plus répandues et confrontons-les à ce qui s'est réellement passé.

Comment fonctionne réellement le dépassement de tampon EVP_EncodeBlock

L'encodage base64 gonfle les données : chaque groupe de trois octets d'entrée devient quatre caractères de sortie. La taille de sortie vaut donc 4 * ((n + 2) / 3), plus un octet pour un terminateur NUL si vous voulez une chaîne C. La fonction EVP_EncodeBlock() d'OpenSSL demande à l'appelant de calculer cette taille et d'allouer le buffer de destination. Elle reçoit elle-même le pointeur d'entrée, le pointeur de sortie et la longueur d'entrée, sous forme d'int. Elle n'apprend jamais la taille du buffer de sortie, donc elle ne peut rien valider. Elle écrit, point.

Passons maintenant aux calculs. Le plus grand int vaut 2 147 483 647. Lorsque la longueur d'entrée dépasse (INT_MAX / 4) * 3, soit 1 610 612 733 octets, environ 1,6 Go, le calcul interne de la taille déborde d'un entier signé de 32 bits. L'arithmétique boucle, l'idée que la fonction se fait de la fin de la sortie ne correspond plus à la réalité, et l'on obtient des écritures au-delà de la fin du buffer alloué par l'appelant. Celui-ci, en suivant la formule documentée, a fait exactement le même calcul débordant, si bien que les deux côtés peuvent se contredire catastrophiquement sur la place réellement disponible.

Le correctif en amont ajoute une garde : rejeter les entrées où dlen > (INT_MAX / 4) * 3, ainsi que les buffers NULL et les longueurs négatives. Si vous encapsulez cette API, et vous devriez le faire, la vérification doit aussi se trouver à votre frontière :

#include <limits.h>
#include <stddef.h>
#include <openssl/evp.h>
/*
* Mirrors the upstream guard: refuse inputs whose encoded size
* cannot be represented in an int, and verify the destination
* capacity ourselves since the API never sees it.
*/
int b64_encode_checked(const unsigned char *in, size_t n,
unsigned char *out, size_t out_cap)
{
size_t need;
if (in == NULL || n > ((size_t)INT_MAX / 4) * 3)
return -1;
need = ((n + 2) / 3) * 4 + 1;   /* +1 for the NUL terminator */
if (out == NULL || out_cap < need)
return -1;
if (EVP_EncodeBlock(out, in, (int)n) < 0)
return -1;
return 0;
}

Remarquez ce que cette API vous oblige à faire : réimplémenter, dans l'appelant, la formule interne de la bibliothèque, correctement, pour toujours. Ce contrat est la vraie vulnérabilité. Le dépassement n'est que l'endroit où le contrat a fini par céder.

Mythe 1 : « Les décodeurs sont la surface d'attaque, les encodeurs sont ennuyeux »

La culture de revue de sécurité penche fortement d'un côté : l'analyse est dangereuse, la sérialisation relève de la comptabilité. Les décodeurs consomment des octets hostiles, donc on les fuzze, on les audite et on les réécrit dans des langages sûrs pour la mémoire. Les encodeurs produisent une sortie, et une sortie paraît sûre. Cette croyance est fausse d'une manière précise et reproductible : les bugs des encodeurs se logent dans le calcul de la taille de sortie, et ce calcul est fait confiance par les deux côtés de l'appel.

Le schéma se répète. Le fil de la pull request le note lui-même : CVE-2026-121481 ressemble à CVE-2021-23840, un ancien dépassement dans OpenSSL, dans les fonctions de mise à jour EVP, où un calcul de longueur débordait sur des entrées énormes. Et base64 a justement ce profil : quand le décodeur base64 d'OpenJDK a transformé 65 octets en exécution de code à distance, nous avons raconté comment un codec « anodin » est devenu une primitive RCE. Les décodeurs reçoivent des CVE pour avoir accepté de mauvaises entrées ; les encodeurs en reçoivent pour avoir mal calculé de bonnes entrées. C'est la même espèce : de l'arithmétique sur des longueurs influencées par l'attaquant.

Verdict : mythe démonté. Si votre modèle de menace s'arrête au parseur, vous avez laissé la porte de derrière ouverte pendant que vous gardiez celle de devant.

Mythe 2 : « Un CVSS 9.8 veut dire tout lâcher ce soir »

Ici, je vais un peu défendre les sceptiques. Un 9.8 sur un encodeur qui a besoin d'une entrée de 1,6 Go n'est pas Heartbleed. Il n'existe nulle part d'encodage base64 de données volumineuses dans la poignée de main TLS : les certificats voyagent en DER à l'intérieur de TLS, pas en PEM. Pour que cela vous touche, des données non fiables doivent atteindre EVP_EncodeBlock() (ou un appelant interne comme base64encode() dans le client HTTP d'OpenSSL) à une échelle supérieure à 1,6 Go. Un champ de protocole préfixé par une longueur de 16 bits ne pourra jamais y arriver.

Mais qualifier cela de « synthétique » sous-estime aussi le problème. Le rapporteur a démontré un vrai chemin en ligne de commande : passer une valeur -proxy_pass énorme à openssl s_client, fournie par une variable d'environnement pour contourner les limites d'arguments du shell, et certaines configurations (les moteurs GOST acceptent des mots de passe surdimensionnés par défaut) encoderont sans broncher ce contenu en base64 pour une requête CONNECT vers un proxy. Ce n'est pas une curiosité de laboratoire : c'est un outil standard qui fait une authentification proxy standard avec une variable d'environnement standard.

Ma position : traitez le CVSS comme une mesure de la fonction, et votre graphe d'appels comme une mesure de votre exposition. Avant de planifier une fenêtre de correctif d'urgence, cherchez dans votre code et vos dépendances qui encode réellement quoi, et jusqu'à quelle taille l'entrée peut grossir. Puis corrigez quand même, mais dans le bon ordre. Verdict : à moitié vrai. Le score est réel, mais la panique doit être proportionnelle à l'accessibilité, et seul votre code peut répondre à cette question.

Mythe 3 : « Le correctif est facile : il suffit de renvoyer un code d'erreur »

C'est ma partie préférée de toute l'histoire, car le dépassement était la partie simple. La partie difficile consistait à décider ce que EVP_EncodeBlock() devait faire à ce sujet, et les mainteneurs n'arrivaient pas à se mettre d'accord.

Le premier correctif renvoyait -1 pour les entrées invalides, en cohérence avec la couche de compatibilité de wolfSSL et les chemins d'échec existants de EVP_DecodeBlock(). Les objections sont arrivées immédiatement. Un mainteneur craignait que des appelants tiers castent la valeur de retour en size_t sans vérifier, et -1 devient alors SIZE_MAX, ce qui est sans doute pire que le dépassement qu'on veut empêcher. Alors renvoyer 0 ? Sauf que 0 est déjà un succès légitime : encoder zéro octet renvoie zéro. Comme l'a formulé un mainteneur, il s'était déjà brûlé à lever une erreur dans un cas de succès. Utilisez OPENSSL_assert(), a proposé un autre : plantez sur violation de contrat et documentez la précondition. À quoi un mainteneur senior a répondu, sans détour : un assert dans une bibliothèque est « une attaque DoS qui attend d'arriver ».

Chaque option était mauvaise, et chacune pour une raison différente : -1 casse les casts non signés, 0 entre en collision avec le succès, et l'assert transforme une erreur de logique en plantage contrôlable par l'attaquant. C'est ce qui arrive quand la sémantique d'erreur d'une API n'a jamais été conçue, seulement héritée. C'est l'écart entre spécification et implémentation à l'état pur : la documentation disait « renvoie le nombre d'octets encodés », et personne n'avait jamais écrit ce qui se passe quand l'encodage est impossible.

Deux autres détails du fil méritent attention. D'abord, un relecteur a remarqué que le correctif initial rejetait systématiquement f == NULL, alors qu'encoder un buffer vide avec un pointeur d'entrée NULL et dlen == 0 avait toujours fonctionné, et des applications réelles en dépendaient. Même la validation « évidemment correcte » cassait un cas limite légitime. Ensuite, un relecteur a cherché les sites d'appel qui ne vérifient pas la valeur de retour et les a trouvés dans OpenSSL lui-même : PEM_SignFinal() et NETSCAPE_SPKI_b64_encode(). Rendre une fonction soudain faillible ne sert à rien si ses appelants ont été écrits à l'époque où elle ne pouvait pas échouer. Verdict : mythe démonté, et sans appel. La sémantique des erreurs fait partie de la conception d'API, et la reprendre après coup relève de la chirurgie, pas d'un simple correctif.

Une voie ferrée se divise en trois chemins divergents dans la brume du crépuscule.
Retourner -1, retourner 0 ou assert : chaque branche du débat sur le correctif avait son propre danger.

Mythe 4 : « Personne ne fait passer un gigaoctet dans un encodeur base64 »

L'intuition est que base64 sert aux petites choses : certificats, clés, jetons courts. Et en général c'est vrai. Mais les systèmes modernes ont discrètement grossi, avec d'énormes blobs encodés en permanence : documents d'attestation, réponses SAML, manifestes d'images de conteneurs, identifiants de proxy, charges utiles de webhooks qu'un intermédiaire décide de réencoder. Le reproducteur de cette CVE n'avait rien d'exotique : c'était un mot de passe, transmis par une variable d'environnement, sur un chemin de code qui encode des identifiants pour un proxy HTTP. Rien dans ce pipeline n'a été conçu avec un plafond de 1,6 Go en tête, parce que personne n'a jamais écrit ce plafond nulle part.

Il existe aussi une habitude d'architecture qui aggrave les choses : les API d'encodage en un seul appel encouragent à charger la charge utile entière en mémoire avant de la transformer. OpenSSL propose des alternatives en flux, EVP_EncodeInit(), EVP_EncodeUpdate() et EVP_EncodeFinal(), qui traitent les données par morceaux et contournent le problème du « calcul de la taille totale de sortie à l'avance ». Le streaming vous coûte un objet de contexte et une boucle. Ce qu'il apporte, c'est qu'aucune longueur unique n'a jamais besoin d'être à la fois influencée par l'attaquant et fiable. Verdict : mythe démonté. Les entrées grossissent jusqu'à atteindre une limite, et si cette limite est un dépassement d'entier signé, c'est la limite qui vous rattrape.

Mythe 5 : « Nos fuzzers auraient trouvé ça »

Non, et il vaut la peine de comprendre pourquoi. Les fuzzers guidés par la couverture, comme libFuzzer, limitent par défaut la taille des entrées à des kilo-octets, soit 4096 octets par défaut. Un bug qui exige 1,6 milliard d'octets d'entrée n'est pas seulement peu probable à trouver : il est hors de l'espace de recherche. Vous pourriez fuzzer EVP_EncodeBlock() pendant un siècle sans jamais effleurer le dépassement, parce que le comportement intéressant n'existe qu'à une échelle que le fuzzer ne visitera jamais.

La solution n'est pas d'augmenter la taille des entrées de fuzzing : personne ne veut allouer 1,6 Go à chaque itération. Il faut tester l'arithmétique séparément de l'encodage. Extrayez le calcul de taille et bombardez ses bornes avec de simples tests unitaires :

#include <assert.h>
#include <limits.h>
/* Mirrors the upstream guard, computed in a wide type. */
static int encoded_len_fits_int(long long dlen)
{
return dlen >= 0 && dlen <= ((long long)INT_MAX / 4) * 3;
}
int main(void)
{
long long limit = ((long long)INT_MAX / 4) * 3; /* 1,610,612,733 */
assert(encoded_len_fits_int(0));
assert(encoded_len_fits_int(limit));
assert(!encoded_len_fits_int(limit + 1));
assert(!encoded_len_fits_int(-1));
/* The encoded size at the limit must itself fit in an int. */
assert(4 * ((limit + 2) / 3) <= INT_MAX);
return 0;
}

Ajoutez ensuite une vérification différentielle à des tailles modérées : calculez la longueur de sortie attendue avec la formule côté appelant, encodez, puis vérifiez que la fonction a écrit exactement ce nombre d'octets, pas un de plus. Lancez le tout sous AddressSanitizer avec quelques entrées de quelques centaines de mégaoctets en CI : assez grandes pour exercer les longues boucles, assez petites pour finir avant le déjeuner. Le fuzzing reste l'outil adapté à la logique octet par octet du codec ; il n'a simplement jamais été le bon outil pour les dépassements d'entiers à grande échelle, et confondre ces deux tâches est la raison pour laquelle des bugs comme celui-ci survivent à une décennie de fuzzing continu. Verdict : mythe démonté.

Comment auditer une API d'encodage avant qu'elle ne vous audite

Que vous relisiez l'usage d'OpenSSL dans votre propre code ou que vous évaluiez le chemin d'encodage de n'importe quelle bibliothèque, les mêmes quelques questions permettent de repérer toute cette classe de bugs :

  • Qui calcule la taille de sortie ? Si l'appelant le fait avec une formule non triviale, les deux côtés peuvent diverger. Privilégiez les API qui prennent la capacité de sortie en paramètre et échouent proprement lorsqu'elle est insuffisante.
  • Quel type entier transporte les longueurs ? Un paramètre de longueur int, c'est un plafond de 2 Go avec un bit de signe en prime. size_t ne rend pas le dépassement impossible, mais il repousse le plafond au-delà de tout buffer que vous pouvez réellement allouer sur une machine 64 bits.
  • Que se passe-t-il à zéro, à la limite et juste au-delà ? Entrée vide, exactement (INT_MAX/4)*3, et cette valeur plus un : ce sont les trois cas de test qui comptent.
  • La fonction est-elle devenue récemment faillible ? Si un correctif a ajouté des retours d'erreur à quelque chose qui ne pouvait pas échouer auparavant, cherchez chaque site d'appel. Les retours non vérifiés transforment un bug corrigé en bug silencieux.
  • Existe-t-il une variante en flux ? Les API découpées encode/update/final suppriment le besoin d'une longueur totale unique et fiable.

J'irai plus loin sur le premier point : toute API qui oblige l'appelant à reproduire la formule interne de taille de la bibliothèque est une usine à bugs, et l'industrie devrait arrêter d'en construire. Le callee connaît le facteur d'expansion, les règles de remplissage et la convention de terminateur. Forcer chaque appelant à redériver 4 * ((n + 2) / 3) + 1 garantit que quelqu'un, quelque part, se trompera, ou aura raison dans un type trop petit.

Une loupe inspecte des blocs lumineux sur un tapis roulant ; l'un d'eux est fissuré.
Les audits d'encodeurs doivent se concentrer sur le calcul des tailles, pas seulement sur la manipulation des octets.

La conclusion pour base64 et au-delà

La CVE-2026-121481 disparaîtra des flux d'actualité en une semaine, mais la classe de bugs, elle, restera. Les fonctions d'encodage se trouvent dans l'angle mort de la revue de sécurité : on leur fait confiance pour les longueurs, on les dispense de fuzzing à grande échelle, et on les enveloppe dans des API dont le comportement d'erreur n'a jamais été spécifié. Les mainteneurs d'OpenSSL ont passé plus de mots à débattre entre -1, 0 ou un plantage qu'à parler du dépassement lui-même, et ils avaient raison, car c'est la partie avec laquelle chaque appelant en aval devra vivre pendant des années.

Donc oui, corrigez, mais aussi cherchez. Trouvez vos sites d'appel d'encodage, vérifiez qui calcule la taille du buffer, assurez-vous que les retours sont réellement contrôlés, et migrez tout ce qui manipule des données volumineuses non fiables vers une API en flux. Le prochain 9.8 dans un encodeur se trouve déjà dans la formule de taille de quelqu'un, en attendant une entrée assez grosse pour le révéler.