Fundierte Artikel über Technologien, die das Kommende formen.

OpenSSL EVP_EncodeBlock Overflow: 5 Mythen, getestet

Der OpenSSL-Pufferüberlauf in EVP_EncodeBlock (CVSS 9.8) zeigt, wie Base64-Encoder-APIs der Prüfung entgehen. Fünf Mythen, getestet.

Ein riesiger Trichter gießt leuchtende Würfel in ein kleines, überlaufendes Glas.
EVP_EncodeBlock vertraut darauf, dass der Aufrufer den Becher richtig dimensioniert hat. Geprüft wird das nie.

Eine Funktion, die nichts anderes tut, als Bytes in Base64-Text umzuwandeln, hat gerade einen CVSS-Wert von 9.8 eingefahren. Der Pufferüberlauf in EVP_EncodeBlock in OpenSSL, erfasst als CVE-2026-121481, ist genau die Sorte Bug, die langweilig klingt, bis du merkst, dass Base64-Kodierung unter der Zertifikatsverarbeitung, HTTP-Clients, Proxy-Authentifizierung und der Hälfte des Verbindungscodes in deiner Infrastruktur liegt. Der Fix selbst brauchte vier Commits und einen richtig hitzigen Streit unter den Maintainern darüber, wie eine Fehlerrückgabe eigentlich aussehen sollte.

Die Diskussion um diese CVE ist ein Geschenk für alle, denen API-Design wichtig ist, denn sie fördert eine Menge Annahmen zutage, die Entwickler über Kodierungsfunktionen treffen. Diese Annahmen erzeugen über Jahrzehnte und über Bibliotheken hinweg immer wieder dieselbe Fehlerklasse. Schauen wir uns fünf der verbreitetsten Überzeugungen an und halten sie an das, was tatsächlich passiert ist.

Wie der Pufferüberlauf in EVP_EncodeBlock tatsächlich funktioniert

Base64-Kodierung vergrößert Daten: Aus jeweils drei Eingabebytes werden vier Ausgabezeichen. Die Ausgabegröße ist also 4 * ((n + 2) / 3), plus eins für ein NUL-Terminator, wenn du einen C-String willst. OpenSSLs EVP_EncodeBlock() verlangt vom Aufrufer, diese Größe zu berechnen und den Zielpuffer zu allozieren. Die Funktion selbst bekommt den Eingabezeiger, den Ausgabezeiger und die Eingabelänge als int. Sie erfährt nie, wie groß der Ausgabepuffer ist, und kann deshalb nichts validieren. Sie schreibt einfach.

Rechnen wir nach. Der größte int ist 2.147.483.647. Übersteigt die Eingabelänge (INT_MAX / 4) * 3, also 1.610.612.733 Bytes bzw. etwa 1,6 GB, läuft die interne Größenberechnung über einen vorzeichenbehafteten 32-Bit-Integer hinaus. Die Längenrechnung wickelt sich um, die Vorstellung der Funktion davon, wo die Ausgabe endet, stimmt nicht mehr mit der Realität überein, und du bekommst Schreibzugriffe jenseits des Endes des vom Aufrufer allozierten Puffers. Der Aufrufer hat der dokumentierten Formel folgend dieselbe überlaufende Rechnung durchgeführt, sodass beide Seiten katastrophal uneins darüber sein können, wie viel Platz tatsächlich vorhanden ist.

Der Upstream-Fix ergänzte einen Guard: Eingaben mit dlen > (INT_MAX / 4) * 3 werden abgelehnt, ebenso NULL-Puffer und negative Längen. Wenn du diese API kapselst, und das solltest du, gehört die Prüfung auch an deine Schnittstelle:

#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;
}

Beachte, was diese API von dir verlangt: Die interne Größenformel der Bibliothek muss im Aufrufer korrekt nachgebaut werden, und zwar für immer. Dieser Vertrag ist die eigentliche Schwachstelle. Der Überlauf ist nur die Stelle, an der der Vertrag schließlich gerissen ist.

Mythos 1: „Decoder sind die Angriffsfläche, Encoder sind langweilig“

Die Kultur der Sicherheitsprüfung hat eine starke Schlagseite: Parsen gilt als gefährlich, Serialisieren als reine Buchhaltung. Decoder verarbeiten feindselige Bytes, also werden sie gefuzzt, geprüft und in speichersicheren Sprachen neu geschrieben. Encoder erzeugen Ausgaben, und Ausgaben fühlen sich sicher an. Diese Annahme ist auf eine konkrete, wiederholbare Weise falsch: Encoder-Bugs stecken in der Berechnung der Ausgabegröße, und dieser Mathematik vertrauen beide Seiten des Aufrufs.

Das Muster wiederholt sich. Der PR-Thread selbst merkt an, dass CVE-2026-121481 an CVE-2021-23840 erinnert, einen früheren OpenSSL-Überlauf in den EVP-Update-Funktionen, bei dem eine Längenberechnung bei riesigen Eingaben überlief. Gerade bei Base64 gibt es Präzedenzfälle: Als der Base64-Decoder von OpenJDK 65 Bytes in Remote Code Execution verwandelte, haben wir berichtet, wie ein „trivialer“ Codec zu einem RCE-Primitiv wurde. Decoder bekommen CVEs, weil sie schlechte Eingaben akzeptieren; Encoder bekommen CVEs, weil sie gute Eingaben falsch berechnen. Beides ist dieselbe Art: Arithmetik mit Längen, die ein Angreifer beeinflussen kann.

Fazit: widerlegt. Wenn dein Bedrohungsmodell beim Parser aufhört, hast du die Hintertür offen gelassen, während du die Vordertür bewachst.

Mythos 2: „CVSS 9.8 heißt, heute Nacht alles stehen und liegen lassen“

Hier verteidige ich die Skeptiker ein Stück weit. Eine 9.8 bei einem Encoder, der eine 1,6-GB-Eingabe braucht, ist nicht Heartbleed. Base64-Kodierung großer Datenmengen kommt im TLS-Handshake nirgends vor, denn Zertifikate reisen in TLS als DER, nicht als PEM. Damit es dir wirklich wehtut, muss nicht vertrauenswürdige Eingabe in EVP_EncodeBlock() gelangen (oder über einen internen Aufrufer wie base64encode() im HTTP-Client von OpenSSL) in einer Größe jenseits von 1,6 GB. Ein Protokollfeld mit 16-Bit-Längenpräfix kann dort niemals landen.

Aber „synthetisch“ untertreibt auch. Der Melder hat einen echten Kommandozeilenpfad demonstriert: Man übergibt einen enormen -proxy_pass-Wert an openssl s_client, geliefert über eine Umgebungsvariable, um Shell-Limits für Argumente zu umgehen. Bestimmte Konfigurationen, etwa GOST-Engines, die übergroße Passwörter standardmäßig akzeptieren, kodieren das dann bereitwillig in Base64 für einen Proxy-CONNECT-Request. Das ist keine Laborkuriosität, sondern ein Standardwerkzeug, das Standard-Proxy-Authentifizierung mit einer Standard-Umgebungsvariable betreibt.

Meine Position: Behandle CVSS als Maß für die Funktion und deinen Aufrufgraphen als Maß für deine Exposition. Bevor du ein Notfall-Patchfenster planst, durchsuche deine Codebasis und deine Abhängigkeiten danach, wer was wirklich kodiert und wie groß die Eingabe werden kann. Dann patchen, aber in der richtigen Reihenfolge. Fazit: halb wahr. Der Score ist real, aber die Panik sollte sich an der Erreichbarkeit orientieren, und die Erreichbarkeit kann nur dein Code beantworten.

Mythos 3: „Der Fix ist einfach, gib einfach einen Fehlercode zurück“

Das ist mein Lieblingsteil der ganzen Geschichte, denn der Überlauf war der einfache Teil. Schwer war die Frage, was EVP_EncodeBlock() dagegen tun soll, und die Maintainer konnten sich nicht einigen.

Der ursprüngliche Patch gab bei ungültigen Eingaben -1 zurück, passend zur Kompatibilitätsschicht von wolfSSL und den bestehenden Fehlerpfaden in EVP_DecodeBlock(). Der Gegenwind kam sofort. Ein Maintainer befürchtete, dass Drittanbieter-Aufrufer den Rückgabewert ohne Prüfung nach size_t casten, und unter diesem Cast wird -1 zu SIZE_MAX, was wohl schlimmer ist als der Überlauf, den es verhindern soll. Also 0 zurückgeben? Nur ist 0 bereits ein gültiger Erfolg: Null Bytes zu kodieren liefert null. Wie ein Maintainer sagte, hatte er sich schon einmal die Finger verbrannt, weil ein Erfolgsfall als Fehler gemeldet wurde. Dann OPENSSL_assert() verwenden, meinte ein anderer: bei Verletzung des Vertrags abstürzen und die Vorbedingung dokumentieren. Darauf antwortete ein erfahrener Maintainer nüchtern, ein Assert in einer Bibliothek sei „ein DoS, das nur darauf wartet, zu passieren“.

Jede Option war schlecht, jede aus einem anderen Grund: -1 bricht vorzeichenlose Casts, 0 kollidiert mit dem Erfolg, und Assert macht aus einem Logikfehler einen vom Angreifer auslösbaren Absturz. Das passiert, wenn die Fehlersemantik einer API nie entworfen, sondern nur geerbt wurde. Es ist die Lücke zwischen Spezifikation und Implementierung in Reinform. Die Doku sagte „gibt die Anzahl der kodierten Bytes zurück“, und niemand hatte je festgehalten, was passiert, wenn Kodierung unmöglich ist.

Zwei weitere Details aus dem Thread verdienen Aufmerksamkeit. Erstens fiel einem Reviewer auf, dass der erste Patch f == NULL bedingungslos ablehnte. Dabei hatte die Kodierung eines leeren Puffers mit NULL-Eingabezeiger und dlen == 0 immer funktioniert, und echte Anwendungen hingen davon ab. Selbst die „offensichtlich korrekte“ Validierung brach also einen legitimen Randfall. Zweitens suchte ein Reviewer nach Aufrufstellen, die den Rückgabewert nicht prüfen, und fand sie in OpenSSL selbst: PEM_SignFinal() und NETSCAPE_SPKI_b64_encode(). Eine Funktion nachträglich fehlbar zu machen, bringt nichts, wenn die Aufrufer geschrieben wurden, als sie nicht fehlschlagen konnte. Fazit: gründlich widerlegt. Fehlersemantik ist Teil des API-Designs, und sie nachzurüsten ist Chirurgie, kein Patch.

Ein Gleis teilt sich im Nebel bei Dämmerung in drei auseinanderlaufende Wege.
-1 zurückgeben, 0 zurückgeben oder assert: Jeder Zweig der Fix-Debatte hatte seine eigene Gefahr.

Mythos 4: „Niemand füttert einen Base64-Encoder mit einem Gigabyte“

Die Intuition: Base64 ist für kleine Dinge gedacht, etwa Zertifikate, Schlüssel und kurze Tokens. Und meistens stimmt das auch. Aber moderne Systeme haben still und leise riesige Blobs wachsen lassen, die ständig kodiert werden: Attestierungsdokumente, SAML-Responses, Container-Image-Manifeste, Proxy-Credentials und Webhook-Payloads, die eine Middlebox irgendwann neu kodiert. Der Reproducer für diese CVE war nicht exotisch: ein Passwort, übergeben über eine Umgebungsvariable, auf einem Codepfad, der Zugangsdaten für einen HTTP-Proxy kodiert. An dieser Pipeline wurde nichts mit einer 1,6-GB-Grenze im Hinterkopf entworfen, weil niemand diese Grenze irgendwo festgeschrieben hatte.

Dazu kommt eine architektonische Gewohnheit, die das verschlimmert: Einmalige Kodierungs-APIs verleiten dazu, die gesamte Nutzlast erst komplett in den Speicher zu laden, bevor sie transformiert wird. OpenSSL bietet Streaming-Alternativen wie EVP_EncodeInit(), EVP_EncodeUpdate() und EVP_EncodeFinal(). Sie verarbeiten Daten in Blöcken und umgehen das Problem, die Gesamtgröße der Ausgabe vorab zu berechnen. Streaming kostet dich ein Kontextobjekt und eine Schleife. Dafür muss nie eine einzelne Länge gleichzeitig angreifer-beeinflusst und vertrauenswürdig sein. Fazit: widerlegt. Eingaben wachsen, bis sie an eine Grenze stoßen, und wenn diese Grenze ein vorzeichenbehafteter Integer-Überlauf ist, findet die Grenze dich.

Mythos 5: „Unsere Fuzzer hätten das gefunden“

Hätten sie nicht, und es lohnt sich zu verstehen, warum. Coverage-guided Fuzzer wie libFuzzer begrenzen die maximale Eingabelänge standardmäßig auf Kilobytes, out of the box sind es 4096 Bytes. Ein Bug, der 1,6 Milliarden Bytes Eingabe braucht, ist nicht nur unwahrscheinlich zu finden, er liegt komplett außerhalb des Suchraums. Du könntest EVP_EncodeBlock() ein Jahrhundert lang fuzzen und den Überlauf nie streifen, weil das interessante Verhalten nur in einer Größenordnung existiert, die der Fuzzer nie besuchen wird.

Die Lösung sind nicht größere Fuzz-Eingaben, denn niemand will bei jeder Fuzz-Iteration 1,6 GB allozieren. Die Lösung ist, die Arithmetik getrennt von der Kodierung zu testen. Extrahiere die Größenberechnung und bombardiere ihre Grenzen mit einfachen Unit-Tests:

#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;
}

Ergänze dann einen Differenzialtest bei moderaten Größen: Berechne die erwartete Ausgabelänge mit deiner aufrufseitigen Formel, kodiere und prüfe, ob die Funktion genau diese Anzahl Bytes geschrieben hat, nicht mehr. Lass alles unter AddressSanitizer mit ein paar hundert Megabyte großen Eingaben in der CI laufen: groß genug, um die breiten Schleifen zu durchlaufen, klein genug, um vor dem Mittagessen fertig zu sein. Fuzzing bleibt das richtige Werkzeug für die byteweise Logik des Codecs. Es war nur nie das richtige Werkzeug für Integer-Überläufe im großen Maßstab, und genau diese beiden Aufgaben zu verwechseln ist der Grund, warum Bugs wie dieser ein Jahrzehnt kontinuierliches Fuzzing überleben. Fazit: widerlegt.

So prüfst du eine Encoder-API, bevor sie dich prüft

Ob du die OpenSSL-Nutzung im eigenen Code überprüfst oder den Kodierungspfad einer beliebigen Bibliothek bewertest, dieselbe Handvoll Fragen erfasst die gesamte Bugklasse:

  • Wer berechnet die Ausgabegröße? Wenn der Aufrufer das mit einer nicht-trivialen Formel tut, können beide Seiten auseinanderdriften. Bevorzuge APIs, die die Ausgabekapazität als Parameter nehmen und sauber fehlschlagen, wenn sie nicht ausreicht.
  • Welcher Integer-Typ trägt die Längen? Ein int-Längenparameter ist eine 2-GB-Grenze mit einem angehängten Vorzeichenbit. size_t macht Überläufe nicht unmöglich, verschiebt die Grenze aber über den Rand jedes Puffers hinaus, den du auf einer 64-Bit-Maschine tatsächlich allozieren kannst.
  • Was passiert bei null, an der Grenze und eins darüber? Leere Eingabe, genau (INT_MAX/4)*3 und dieser Wert plus eins sind die drei Testfälle, die zählen.
  • Ist die Funktion kürzlich fehlbar geworden? Wenn ein Patch Fehlerrückgaben zu etwas hinzugefügt hat, das vorher nicht fehlschlagen konnte, durchsuche jede Aufrufstelle. Ungeprüfte Rückgaben machen aus einem behobenen Bug einen stillen.
  • Gibt es eine Streaming-Variante? Chunked-APIs für encode, update und final machen jede einzelne vertrauenswürdige Gesamtlänge überflüssig.

Beim ersten Punkt gehe ich noch weiter: Jede API, die den Aufrufer zwingt, die interne Größenformel der Bibliothek nachzubauen, ist eine Fehlerfabrik, und die Branche sollte aufhören, solche zu bauen. Die aufgerufene Funktion kennt den Expansionsfaktor, die Padding-Regeln und die Terminator-Konvention. Jeden Aufrufer zu zwingen, 4 * ((n + 2) / 3) + 1 neu herzuleiten, garantiert, dass irgendjemand irgendwo es falsch macht, oder richtig in einem Typ, der zu klein ist.

Eine Lupe prüft leuchtende Blöcke auf einem Förderband; einer ist gerissen.
Encoder-Audits sollten sich auf die Größenmathematik konzentrieren, nicht nur aufs Verschieben der Bytes.

Das Fazit für Base64 und darüber hinaus

CVE-2026-121481 wird innerhalb einer Woche aus den Feeds verschwinden, die Bugklasse aber nicht. Kodierungsfunktionen liegen im blinden Fleck der Sicherheitsprüfung: Ihnen werden Längen vertraut, sie sind vom groß angelegten Fuzzing ausgenommen und stecken in APIs, deren Fehlerverhalten nie spezifiziert wurde. Die OpenSSL-Maintainer haben mehr Worte darauf verwendet, ob man -1, 0 zurückgibt oder abstürzt, als auf den Überlauf selbst. Und das zu Recht, denn genau damit wird jeder nachgelagerte Aufrufer jahrelang leben.

Also: patchen ja, aber auch suchen. Finde deine Aufrufstellen für Kodierung, prüfe, wer die Puffergröße berechnet, kontrolliere, ob die Rückgaben tatsächlich geprüft werden, und verschiebe alles, was ungeprüfte Bulk-Daten verarbeitet, auf eine Streaming-API. Die nächste 9.8 in einem Encoder steckt schon in der Größenformel irgendeines Entwicklers und wartet auf eine Eingabe, groß genug, um sie zu finden.