Java4Shell漏洞曝光!
摘要
Java4Shell(CVE-2026-114938) 是 OpenJDK HotSpot 虛擬機器 中,x86-64 Base64 解碼 Intrinsic 所存在的記憶體破壞漏洞。格式錯誤的 Padding 尾端會使解碼長度計數器降至零以下;隨後發生的 下溢(underflow) 會讓硬體儲存 遮罩(store mask)完全失效 ,進而造成固定資料的堆積區 越界寫入 。文章重建漏洞的根本原因,分析記憶體破壞操作(primitive),並追蹤攻擊者如何透過借鑑 Script Engine Exploitation 的 Heap Grooming 技術 ,將固定值覆寫逐步提升為任意寫入、堆積資料洩漏(「JavaBleed」),最終對尚未修補的伺服器應用程式達成 遠端程式碼執行 。
1. 簡介
漏洞並非位於應用程式程式碼,而是存在於一般開發人員不會檢查的效能最佳化路徑:
C2 編譯器
針對支援
AVX-512 VBMI 的 x86-64 CPU
所提供的
java.util.Base64.Decoder
Intrinsic。由於這個 Intrinsic 是手寫組合語言,只有在解碼器經過 JIT 編譯後才會被選用,因此任何應用程式的 Java 原始碼都無法直接看出這項缺陷,但只要程式執行路徑會解碼受到攻擊者影響的 Base64 資料,就可能觸發漏洞,例如驗證標頭、Token、上傳資料或序列化 Payload
[1]
。經過獨立驗證的分析,依據 CVSS 3.1 將此漏洞評定為 8.1,並指出該漏洞可透過廣泛部署的 Java 應用程式,在完成驗證之前觸及
[2]
。此外,數個月前曾公開的 crash 報告並未因此直接促成已合併的修補程式,也進一步加劇了漏洞的嚴重性
[1]
。
2. 根本原因:Padding 尾端寫入遮罩的下溢
Intrinsic 會以每次 256 位元組的區塊處理輸入資料,遇到較短的尾端資料時,則改用 64 位元組區塊。當輸入長度小於 64 位元組時,會使用
evmovdqub
(AVX-512 版本的
VMOVDQU8
),這是一種具有遮罩功能的移動指令,其 64 位元運算元遮罩會決定哪些位元組能夠寫入。遮罩是根據輸入長度計算輸出長度,再依照每個
=
Padding 字元遞減一次而得出。問題在於遞減操作沒有設定下限:對於
=
、
==
、
X=
、
X==
、
XY=
或
===
等尾端形式,Padding 調整之前計算出的輸出長度已經是零,因此減法會產生 −1 或 −2
[1]
。由於位元清除輔助函式在計數運算元大於或等於 64 時,會保留所有位元為 1,因此發生下溢的負數值會轉換成
output_mask == -1u64
,導致全部 64 個向量位元組都被寫入記憶體。
- // Pseudocode of the vulnerable tail logic (reconstructed from the advisory)
- input_mask := bzhiq(-1, input_length) // Build a mask of `input_length` low bits set to 1
- output_len := (input_length / 4) * 3 // Base64 decodes 3 output bytes per 4 input chars
- if input[input_length - 1] == '=': // If the last character is padding...
- output_len -= 1 // ... one output byte is dropped
- input_mask >>= 1 // ... shift the read mask to skip the '=' character
- if input[input_length - 2] == '=': // If the second-to-last char is also padding...
- output_len -= 1 // ... drop a second output byte
- input_mask >>= 1 // ... shift the read mask once more
- // BUG: for an all-padding tail, output_len is 0 before the decrements,
- // so it underflows to -1 or -2. bzhiq(-1, huge_value) leaves all bits set,
- // producing output_mask == -1u64 (a fully open 64-byte write mask).
程式 1. Padding 尾端長度處理邏輯;遞減操作缺少下限檢查,就是造成漏洞的原因。
3. 記憶體破壞模型與觸發條件
執行期間,解碼緩衝區會依照
(ceil(input_length / 4) * 3) - padding
計算配置長度。輸入 65 個位元組,也就是 64 個
A
字元加上一個
=
,會配置一個 50 位元組的緩衝區;然而 Intrinsic 會從偏移量 48 開始寫入 64 個位元組,造成超出緩衝區結尾 62 個位元組的越界寫入
[1]
。在 OpenJDK 17 上,受影響程式碼路徑的長度門檻會加倍,因此觸發條件會增加為 128 個
A
字元加上一個
=
。溢位寫入的位元組具有固定值:第 0 個位元組完全由攻擊者控制,第 1 個位元組有四個位元可由攻擊者控制,而第 48 至 63 個位元組則固定為
0x9a
。Java 層會透過
IllegalArgumentException
拒絕格式錯誤的輸入,但此時寫入操作早已完成;例外只是回報記憶體破壞已經發生,而不是阻止它
[1]
。
圖 1. 解碼路徑執行順序:記憶體破壞先發生,之後才拋出用來表示錯誤的例外。
4. 攻擊升級:從固定寫入到任意操作
無法自行選擇寫入值的操作,看起來似乎威脅有限,但其寫入位置可以受到控制,而這正是覆寫長度欄位所需要的條件。攻擊者會將一個 writer 陣列配置在解碼器輸出資料附近;固定值溢位會破壞 Writer 的長度欄位。接著,Writer 就能接受攻擊者選擇的位元組,將原本的操作提升為具有範圍限制、可寫入指定值的線性寫入能力。再破壞第二個陣列的長度,就能建立一個 reader 。透過應用程式 Response 反映 Reader 的內容,便會產生 JavaBleed ,形成一個能夠洩漏堆積資料的通道,可能暴露私密金鑰、Token 及其他儲存在記憶體中的機密資訊 [1] 。攻擊者會利用已洩漏的原始資料修復受損的物件標頭,讓 JVM 能夠繼續運作;之後再將有限制的寫入能力提升為任意寫入,進而觸及 Code Cache 與 JVM Hooks,達成程式碼執行。第三方評估也證實,要將這條攻擊鏈泛化,仍然需要針對每個目標進行調整。這降低了通用 Exploit 的風險,但 AI 輔助的 Exploit 建構方式也正在縮短開發時間 [3] 。
圖 2. 攻擊階段的執行流程:Warm-up、校準、觸發、資料洩漏、修復及最後執行。
5. 遠端 Heap Grooming
若要在 G1 中可靠地控制物件配置位置,關鍵陣列必須脫離各自執行緒的 Thread-Local Allocation Buffer(TLAB) ;只有達成這個條件,才能透過 Region 位址計算,讓解碼器緩衝區排列在 Writer Region 下方。攻擊者會透過陣列大小及 TLAB 壓力來控制配置位置,接著在跨越多個 Region 大小的範圍內大量配置成對的 Writer/Reader 物件,並持續重試,直到擴大的 Reader 成功增加應用程式 Response 的長度。這是一種具有丟棄及重試機制的 「spray and pray」策略 。遠端攻擊時,Request Body 會被分段傳送,使關鍵配置發生之前的資料先透過網路獲得確認,剩餘資料則稍後才抵達,藉此將 TCP 確認時間轉換成控制記憶體配置時機的手段。較低的往返時間(Round-Trip Time, RTT)及 Jitter 有助於穩定整條攻擊鏈;相較於調整 TCP Stack 參數,將攻擊主機與目標部署在相同的 Infrastructure Region,更能提高攻擊可靠性 [1] 。
6. Proof-of-Concept 分析
公開的觸發程式刻意限制了寫入範圍:所有覆寫操作都會落在專用的 4096 位元組陣列內,因此即使在存在漏洞的版本上執行,程式仍然是安全的。其結構包括讓 Intrinsic 進入 Hot 狀態、污染 Canary 區域、觸發格式錯誤的尾端資料,接著驗證偏移量 50 至 111 之間是否有 62 個位元組遭到修改。這與實際攻擊鏈的第一階段相對應 [1] 。
- mport java.nio.charset.StandardCharsets; // Charset constants for byte conversion
- import java.util.Arrays; // fill() and comparison helpers for the canary buffer
- import java.util.Base64; // The standard-library decoder under test
- /** Bounded standalone trigger: every write stays inside a real 4096-byte array. */
- public final class Base64Trigger { // final class; no subclassing side effects
- private static volatile int sink; // volatile sink prevents JIT from eliding warm-up loops
- public static void main(String[] args) {
- Base64.Decoder decoder = Base64.getDecoder(); // obtain the JDK decoder instance
- byte[] valid = "A".repeat(64).getBytes(StandardCharsets.US_ASCII); // canonical 64-byte valid input
- byte[] malformed = ("A".repeat(64) + "=").getBytes(StandardCharsets.US_ASCII); // 65-byte trigger tail
- byte[] target = new byte[4096]; // large canary buffer absorbing the OOB write
- for (int i = 0; i < 200_000; i++) { // heavy warm-up loop...
- sink += decoder.decode(valid, target); // ...forces C2 to compile the decode path
- } // loop end; intrinsic is now active
- Arrays.fill(target, (byte) 0x5a); // poison the buffer so spilled bytes become observable
- boolean rejected = false; // flag tracking the expected exception path
- try {
- decoder.decode(malformed, target); // fire the trigger; intrinsic spills 62 bytes past offset 49
- } catch (IllegalArgumentException expected) { // Java layer rejects the malformed input AFTER the write
- rejected = true; // record that rejection occurred as predicted
- }
- int changed = 0; // counter of poisoned bytes modified by the overflow
- int first = -1; // index of first modified byte
- int last = -1; // index of last modified byte
- for (int i = 50; i < target.length; i++) { // scan from offset 50 outward through the canary
- if (target[i] != (byte) 0x5a) { // detect any byte the spill overwrote
- changed++; // tally one more corrupted byte
- if (first < 0) first = i; // record first corruption offset once
- last = i; // keep advancing the last corruption offset
- }
- }
- System.out.println("runtime=" + System.getProperty("java.runtime.version")); // log JDK build for reproducibility
- System.out.println("vm=" + System.getProperty("java.vm.name")); // log VM name (expect HotSpot)
- System.out.printf("rejected=%s changed=%d first=%d last=%d%n", // print corruption report line
- rejected, changed, first, last); // arguments for the report line
- if (!rejected || changed != 62 || first != 50 || last != 111) { // exact signature: 62 bytes, offsets 50-111
- System.err.println("NOT REPRODUCED"); // signature mismatch: patched or non-x86-64 host
- System.exit(1); // exit nonzero to signal failure
- }
- System.out.println("REPRODUCED"); // exact signature matched: intrinsic bug confirmed
- }
- }
程式 2. 受限範圍的觸發程式。200,000 次 Warm-up、0x5a 污染值,以及偏移量 50 至 111 的 62-byte 修改特徵,都是這項測試能夠成立的關鍵。
7. 受影響範圍與硬體限制
受影響的版本涵蓋 OpenJDK 17.0.6 及之後的版本;由於主要發行版本都是以 OpenJDK 為基礎建置,因此大多數廠商提供的 JDK 也繼承了這項漏洞。Oracle 在 2026 年 11 月的修補版本中,已針對其支援的各個版本系列處理此問題 [1] [2] 。此外,利用漏洞還需要具備 AVX-512 VBMI 功能的 x86-64 CPU(Intel Xeon Ice Lake 至 Granite Rapids;AMD Zen 4 及更新架構);ARM64 不受影響。可以透過以下四個旗標檢查主機是否具備受影響的硬體條件:
- rep -m1 '^flags' /proc/cpuinfo # Extract the first CPU-flags line only (-m1); flags list capability bits
- | tr ' ' '\n' # Split the space-separated flag list into one flag per line
- | grep -E '^(avx512f|avx512bw|avx512vbmi|bmi2)$' # Keep only the four required instruction-set flags
- # All four flags must appear. Missing any one means the intrinsic path is unreachable and the host is safe.
程式 3. 主機適用性檢查;四個旗標全部存在,才具備觸發漏洞路徑的必要條件。
8. 緩解措施與限制
即使不安裝修補程式,也可以透過兩個 JVM 旗標消除漏洞:停用 Base64 Intrinsic 會強制使用安全的 Java 實作;將 AVX 限制在不啟用 512-bit 指令的範圍內,則能完全移除相關指令路徑(後者僅適用於 x86-64,並且會導致 ARM 平台啟動失敗)。
- XX:-UseBASE64Intrinsics # Disable the hand-written hardware Base64 stubs; decoder falls back to safe Java code
- -XX:UseAVX=2 # Restrict vector ISA to AVX2 so the AVX-512 VBMI intrinsic is never emitted<
程式 4. 執行階段緩解措施;必須在 JVM 啟動時套用。
這些緩解措施並不能消除結構性弱點。前端 Proxy 對 Request Body 進行緩衝處理,會破壞串流式 Grooming Profile 所需的資料釋放時間控制;然而,每次操作都會完整接收一個 Request 的應用程式,或是在 WebSocket 完成升級 Handshake 後傳輸資料的應用程式,仍然保留可行的攻擊路徑 [1] 。更根本的問題是,並不存在通用的 Payload:每條攻擊鏈都需要解碼器路徑、可用的 Writer、回傳的 Reader、可行的堆積配置,以及應用程式專屬的操作,因此每個目標都需要量身打造的 Profile [1] 。優先安裝修補程式仍然是唯一完整的修復方式。偵測方面,JVM 致命錯誤日誌、異常的 Abort 結束代碼,以及事件發生後輪替儲存在記憶體中的機密資訊,都具有參考價值;單純重新啟動並不會讓這些機密資訊失效 [2] 。
9. 結論
Java4Shell 證明,即使是標榜「記憶體安全」的平台,也必須仰賴底層最佳化層級的正確性:手寫組合語言中只要存在一次缺少防護的遞減操作,而且能透過標準函式庫中最常見的 API 觸及,就足以達成未經驗證的遠端程式碼執行。對防禦者而言,實務上的教訓有三點:盤點所有隨應用程式一起部署的 JDK、將 JIT Intrinsic 視為攻擊面,以及在證明並非如此之前,應將 crash 類型的漏洞報告視為潛在攻擊鏈。