Google Guava: Deserialisierung in CompactHashMap/CompactHashSet/MapMakerInternalMap löst unkontrollierte Speicherbelegung aus
Native Deserialisierung in CompactHashMap/CompactHashSet/MapMakerInternalMap löst unkontrollierte Speicherbelegung aus
Zusammenfassung
CompactHashMap, CompactHashSet und MapMakerInternalMap implementieren readObject(ObjectInputStream), indem sie einen von Angreifern kontrollierten Wert für elementCount oder initialCapacity aus dem Datenstrom einlesen. Bereits beim allerersten Einfügen während oder nach der Deserialisierung (bei den CompactHash*-Sammlungen innerhalb von allocArrays()) oder unmittelbar während der Deserialisierung (bei MapMakerInternalMap) reserviert die Implementierung Arrays in voller Größe dieses unvalidierten Werts (beispielsweise bis zu CompactHashing.MAX_SIZE = 2^30-1, also ca. 1.07 Milliarden), noch bevor die eigentlichen Daten des Datenstroms verarbeitet wurden. Ein bösartiger serialisierter Datenstrom von nur 72 Bytes mit einem einzigen kleinen Element kann eine Zuweisung von mehreren Gigabyte erzwingen und eine JVM durch OutOfMemoryError zum Absturz bringen, was für das aktuelle Release dynamisch bestätigt wurde.
Details
CompactHashMap.readObject() (guava/src/com/google/common/collect/CompactHashMap.java):
private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException {
stream.defaultReadObject();
int elementCount = stream.readInt();
if (elementCount < 0) {
throw new InvalidObjectException("Invalid size: " + elementCount);
}
init(elementCount);
for (int i = 0; i < elementCount; i++) {
K key = (K) stream.readObject();
V value = (V) stream.readObject();
put(key, value);
}
}
elementCount wird lediglich daraufhin überprüft, ob der Wert nicht negativ ist; es existiert weder eine Obergrenze noch wird eine Beziehung zwischen der deklarierten Anzahl und der tatsächlich im Stream folgenden Datenmenge erzwungen. init(elementCount) (Zeile 251) speichert lediglich den Wert (begrenzt auf [1, CompactHashing.MAX_SIZE], d. h. bis zu 2^30-1):
void init(int expectedSize) {
Preconditions.checkArgument(expectedSize >= 0, "Expected size must be >= 0");
this.metadata = Ints.constrainToRange(expectedSize, 1, CompactHashing.MAX_SIZE);
}
Die eigentliche Allokation wird bis zu allocArrays() verzögert, was verzögert beim ersten Aufruf von put() ausgelöst wird — also nachdem erst ein einziges Schlüssel-Wert-Paar tatsächlich aus dem Datenstrom gelesen wurde:
int allocArrays() {
...
int expectedSize = metadata;
int buckets = CompactHashing.tableSize(expectedSize);
this.table = CompactHashing.createTable(buckets);
setHashTableMask(buckets - 1);
this.entries = new int[expectedSize];
this.keys = new Object[expectedSize];
this.values = new Object[expectedSize];
return expectedSize;
}
Wenn expectedSize nahe bei CompactHashing.MAX_SIZE liegt (2^30-1), weist dieser einzelne Aufruf ein Hash-table sowie drei Arrays der Länge expectedSize zu — was mehrere Gigabyte umfasst — ausgelöst durch einen Stream, der bis dahin lediglich ein einziges kleines reales Element geliefert hat. CompactHashSet.readObject()/allocArrays() weisen die identische Struktur auf. CompactLinkedHashMap/CompactLinkedHashSet erweitern diese Klassen und erben denselben ungeschützten Ausführungspfad.
Das Problem bei MapMakerInternalMap ist ähnlich gelagert: Eine aus den serialisierten Daten gelesene Größe wird in einer MapMaker-Instanz gespeichert) zur späteren Verwendung während der Deserialisierung,), wenn die MapMaker an MapMakerInternalMap zurückgegeben wird) und Segmente zugewiesen werden), indem newSegment aufgerufen wird](https://github.com/google/guava/blob/1278ad9c2257f48dc82fb7b7c625ab563605aa24/guava/src/com/google/common/collect/MapMakerInternalMap.java#L1143),), dessen Implementierungen (Beispiel))) Segment-Instanzen erzeugen (Beispiel))), welche Arrays mit der angeforderten Kapazität zuweisen) über den newTable-Helfer](https://github.com/google/guava/blob/1278ad9c2257f48dc82fb7b7c625ab563605aa24/guava/src/com/google/common/collect/MapMakerInternalMap.java#L1262)).
Dies entspricht demselben Verstärkungsmuster wie bei der bereits behobenen Schwachstelle CVE-2018-10237 (AtomicDoubleArray/CompoundOrdering: Ein Angreifer deklariert eine hohe Größe, und die Bibliothek reserviert Speicher vorab, bevor der tatsächliche Inhalt des Datenstroms validiert wurde). Dieser Fix hat AtomicDoubleArray.readObject() so umgeschrieben, dass eine ImmutableLongArray.Builder inkrementell für jedes gelesene Element wächst, anstatt anhand der angegebenen Größe vorab zu allokieren — Guavas eigenes HashBiMap.readObject() dokumentiert dasselbe Schutzprinzip explizit in einem Kommentar: init(16); // resist hostile attempts to allocate gratuitous heap. Weder CompactHashMap noch CompactHashSet folgen einem dieser beiden Muster, die in derselben Codebasis bereits existieren.
Erreichbarkeit: Alle Klassen sind Top-Level, implements ... Serializable und erfordern kein spezielles Classpath-Setup abgesehen von der Präsenz von Guava (was in JVM-Backends nahezu allgegenwärtig ist). Bei nativer Java-Deserialisierung kann ein Angreifer die Klasse direkt in einem eigens erstellten Stream benennen — die betroffene Anwendung muss keine bestimmte Factory-Methode von Guava verwendet haben, genau wie beim vorangegangenen CVE.
PoC
Vollständiger Quellcode und Ausführungsanweisungen finden sich im beigefügten poc-guava-compacthash-dos.zip (Maven-Projekt mit guava:33.7.1-jre — dem derzeit aktuellen Release — als einziger Abhängigkeit). Der PoC:
- Verwendet Reflection ausschließlich, um legitim an eine
CompactHashSet-Instanz zu gelangen (sie ist package-private; ein realer Angreifer benötigt diesen Schritt nicht, da die serialisierten Bytes direkt erstellt werden können, anstatt Guavas eigenen Serialisierungscode aufzurufen). - Serialisiert ein Set mit 1 Element und eines mit 2 Elementen und vergleicht die Byte-Streams, um den exakten Offset des Felds
elementCountbytegenau zu bestimmen. - Ändert dieses eine 4-Byte-Feld im Stream mit 1 Elementen von
1auf0x3FFFFFFF(CompactHashing.MAX_SIZE) und belässt den Rest des 72-Byte-Streams (ein reales"A"-Element) unverändert. - Übergibt den resultierenden manipulierten 72-Byte-Stream an einen regulären
new ObjectInputStream(...).readObject()-Aufruf gegen das echte, unmodifizierteguava-33.7.1-jre.jar.
Tatsächliche Programmausgabe:
### -Xmx8g (generous heap) ###
Located size field at offset 63, value=1 (expected 1)
Malicious stream size: 72 bytes
Declared elementCount: 1073741823 (~1.07 billion)
Real payload: 1 tiny string element ("A")
=== RESULT ===
Exception: java.lang.OutOfMemoryError: Java heap space
Time to allocate+fail: 4013 ms
Heap used before: 3 MB
Heap used after (at failure point): 4103 MB
JVM max heap (-Xmx): 8192 MB
### -Xmx128m (ordinary service-sized heap) ###
Located size field at offset 63, value=1 (expected 1)
Malicious stream size: 72 bytes
Declared elementCount: 1073741823 (~1.07 billion)
Real payload: 1 tiny string element ("A")
=== RESULT ===
Exception: java.lang.OutOfMemoryError: Java heap space
Time to allocate+fail: 24 ms
Heap used before: 4 MB
Heap used after (at failure point): 2 MB
JVM max heap (-Xmx): 128 MB
Eine Eingabe von 72 Bytes erzwingt eine tatsächliche Zuweisung von ca. 4.1 GB, bevor sie auf einem Heap von 8 GB fehlschlägt, und bringt einen Heap von 128 MB innerhalb von 24 ms zum Absturz — eine Verstärkung um mehr als das 50,000x-fache zwischen Eingabegröße und erzwungener Speicherallokation.
Zur Reproduktion: mvn -q compile dependency:build-classpath -Dmdep.outputFile=cp.txt && java -Xmx128m -cp "target/classes:$(cat cp.txt)" poc.Poc
Auswirkungen
Unkontrollierter Ressourcenverbrauch (CWE-770 / CWE-400) über native Java-Deserialisierung: Jede Anwendung, die ObjectInputStream.readObject() auf von Angreifern kontrollierbare Daten ausführt und Guava im Classpath bereitstellt (was auf einen großen Teil des JVM-Ökosystems zutrifft), kann mit einer einzigen Nutzlast von ca. 72 Bytes zum Absturz gebracht werden — unabhängig davon, welchen Objekttyp die Anwendung selbst zu deserialisieren erwartete.
Schweregrad
CVSS 3.1: AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H — identischer Vektor wie bei CVE-2018-10237, dem Vorgängerfehler. Neuberechnung nach der vollständigen Formel: Exploitability = 8.22 × 0.85 × 0.44 × 0.85 × 0.85 = 2.221; ISS = 1 - (1 × 1 × 0.44) = 0.56; Impact = 6.42 × 0.56 = 3.595; Base = roundup(5.816) = 5.9 (Medium).
Betroffene Versionen
com.google.guava:guava, alle Editionen (-jre/-android) — bestätigt auf dem aktuellen Release 33.7.1-jre. CompactHashMap/CompactHashSet/CompactLinkedHashMap/CompactLinkedHashSet weisen dieselbe Struktur in readObject/allocArrays seit längerer Zeit auf (vermutlich seit deren Einführung in Guava 23.6), und Entsprechendes gilt für MapMakerInternalMap (eingeführt in Guava 4.0); ältere Einzelreleases wurden nicht getestet.
Empfohlener Fix
Anwendung derselben Abwehrmaßnahme, die bereits an anderer Stelle in der Codebasis genutzt wird: Entweder die anfängliche Kapazität von init() unabhängig vom deklarierten elementCount auf eine kleine Konstante beschränken (wie es HashBiMap.readObject() bereits tut — init(16); // resist hostile attempts to allocate gratuitous heap) und sie inkrementell beim Einlesen der Elemente vergrößern, oder die zugrundeliegenden Arrays pro Iteration der Deserialisierungsschleife inkrementell vergrößern (wie es das behobene AtomicDoubleArray.readObject() über ImmutableLongArray.Builder handhabt), anstatt beim ersten Einfügen direkt den gesamten vom Angreifer angegebenen Wert zu allokieren.
Was zu tun ist
Aktualisieren Sie com.google.guava:guava auf Version 33.7.2 oder höher.
Betroffene Software
Klicken Sie auf eine Technologie, um alle zugehörigen Schwachstellen anzuzeigen.
| Plattform | Paket | Anfällige Versionen | Behoben in |
|---|---|---|---|
| Java / Kotlin (Maven) | com.google.guava:guava | >= 4.0, < 33.7.2 | 33.7.2 |
Verweise
- CVSS-Vektor
CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H- Schwäche (CWE)
CWE-400, CWE-502, CWE-770- Plattform
- Java / Kotlin (Maven)
- Paket
com.google.guava:guava- Veröffentlicht
- 27.10.2026
- Aktualisiert
- 30.10.2026 10:00
Quellen und Lizenzen · Von DockRay bearbeitet oder übersetzt; Rechte und Lizenzen der Quellen bleiben erhalten.
OSV / GitHub Advisory Database - GHSA-xxph-c9ww-hj94 - CC BY 4.0
Schwachstellenhistorie: com.google.guava:guava
Alle veröffentlichten Schwachstellen dieses Pakets (Java / Kotlin (Maven)), neueste zuerst. Zeigt, ob es ein einmaliger Ausrutscher ist oder ein Paket, das man im Auge behalten muss.
- Einträge insgesamt
- 4
- Erste → letzte
- 06.2020 10.2026
- Ohne Fix
- 0
- In Angriffen ausgenutzt
- 0
Verteilung nach Schweregrad
- Hoch 1
- Mittel 2
- Niedrig 1
Veröffentlichungen pro Jahr
- 2020: 1
- 2021: 1
- 2022: 0
- 2023: 1
- 2024: 0
- 2025: 0
- 2026: 1
-
Google Guava: Deserialisierung in CompactHashMap/CompactHashSet/MapMakerInternalMap löst unkontrollierte Speicherbelegung aus dieser Eintrag
Erkennen Sie Schwachstellen in Ihrer Anwendung
Mit der DockRay-Integration und aktivierter Softwareinventarisierung prüft DockRay gemeldete Komponentenversionen auf bekannte Schwachstellen und benachrichtigt Sie über bestätigte Treffer. Die Abdeckung hängt von der unterstützten Technologie und den verfügbaren Meldungen ab.