이 글의 범위 — 재현이 아니라 분석이다
지금까지 이 블로그에서 다룬 RCE는 대개 라이브러리 한 겹의 문제였다. Log4Shell은 로깅 라이브러리, Crawl4AI는 크롤러, Langflow는 LLM 오케스트레이터였다. 이번은 층이 다르다. 취약한 코드가 JVM 본체 안, 그것도 HotSpot JIT가 깔아 두는 하드웨어 가속 Base64 디코더 인트린식에 있다.
CVE-2026-114938, 커뮤니티가 붙인 별칭은 Java4Shell(Calif.io의 공개 URL이 java4shell이다). 공격자 입장에서 한 줄로 요약하면 이렇다 — 특정 CPU에서 돌아가는 Java 앱에 지극히 평범해 보이는 Base64 문자열을 인증 없이 보내면, JVM이 그 문자열을 풀다가 힙을 넘어서 쓴다.

먼저 범위를 정직하게 못박아 둔다. 이 글은 재현글이 아니라 분석글이다. 이유는 셋이다.
- 아직 무기화된 공개 PoC가 없다. 발견자 쪽(Calif.io)은 애플리케이션별 익스플로잇 체인을 사용자 업그레이드 시간을 주려고 보류했고, 공개된 것은 피해 없이 손상만 재현하는 바운드 PoC와, 뒤에서 다룰 트리거 구조뿐이다.
- 이건 메모리 손상 + CPU 인트린식 조합이라 재현 난이도가 최상이다. 힙 손상에서 제어 흐름 탈취까지는 별개의 긴 작업이다.
- 결정적으로, 분석에 쓴 랩 머신 CPU에는 취약한 벡터 경로 자체가 없다. 뒤에서
lscpu로 보이겠지만, 이 PC의 CPU는 AVX-512 VBMI를 지원하지 않아 문제의 인트린식 분기에 도달하지 못한다.
그래서 재현(크래시 유발) 대신, OpenJDK 소스를 직접 읽어 근본 원인을 교차검증하고, 로컬 JVM의 디코더 경로와 CPU 피처를 핑거프린트하고, 권위 있는 외부 증거로 사실을 확정하는 쪽으로 간다. 트래픽이 몰리는 공개 직후에 선점하는 분석 속보이고, 트리거 바이트 구조와 패치 diff가 더 드러나면 완전 재현은 후속글(B)로 잇는다.

Source: GitHub Security Advisory — GHSA-6g7j-4xh3-xq2q
점수부터 솔직하게 갈라 둔다. 출처마다 숫자가 다르다.
| 출처 | 버전 | 점수 | 성격 |
|---|---|---|---|
| Oracle(CNA) · NVD · GHSA | CVSS 3.1 | 8.1 (High) | 공식 — AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H |
| Calif.io(연구팀) | CVSS 4.0 | 9.2 (Critical) | 연구자 평가 — 공식 기록엔 없음 |
공식 벡터를 뜯어 보면 공격자에게 유리한 축이 분명하다.
| 지표 | 값 | 뜻 |
|---|---|---|
| AV (공격 경로) | Network | 네트워크 너머에서 |
| AC (복잡도) | High | 조건이 붙는다 — CPU·JIT 가열 |
| PR (권한) | None | 인증 없이 |
| UI (상호작용) | None | 피해자 개입 없이 |
| S (스코프) | Unchanged | 같은 보안 권한 안에서 |
| C/I/A | H/H/H | 기밀·무결·가용 전부 완전 손상 |
두 점수의 간극은 AC에서 온다. Oracle은 "exploit하기 어렵다(difficult to exploit)"며 AC:H를 줬고, Calif.io는 "64자나 128자짜리 단순 문자열로 손쉽게 발화한다"며 더 높게 봤다. 공격자 입장에서 흥미로운 지점이 바로 여기다 — "어렵다"는 평가의 근거(CPU 의존·JIT 가열)가 곧 이 취약점의 발화 조건이다. 그 조건을 하나씩 소스로 확인해 나간다.

배경 — Base64 인트린식이 대체 뭔가
"Base64 디코더에 버그가 있다"는 말은 오해를 부른다. 문제는 java.util.Base64의 자바 코드가 아니다. 그 자바 코드는 멀쩡하다. 진짜 범인은 HotSpot JIT가 런타임에 깔아 두는 인트린식(intrinsic) — 핸드 튜닝된 어셈블리 스텁이다.
인트린식은 "자주 쓰이고 성능이 중요한 메서드"를 JIT가 CPU 네이티브 명령으로 치환하는 최적화다. Base64 인코딩/디코딩은 TLS·JWT·멀티파트·이미지 데이터 등에서 끝없이 호출되니, OpenJDK는 x86-64에서 AVX-512 VBMI 벡터 명령으로 한 번에 수십 바이트씩 처리하는 전용 스텁을 둔다. vpermb, evpermt2b, evmovdqub 같은 512비트 벡터 명령으로 룩업·변환·저장을 몰아친다.
이 치환이 어디에 등록되는지는 vmIntrinsics.hpp에서 바로 보인다.
git -C ../jdk17u-src show jdk-17.0.6-ga:src/hotspot/share/classfile/vmIntrinsics.hpp | sed -n '455,462p'
do_intrinsic(_base64_decodeBlock, java_util_Base64_Decoder, decodeBlock_name, ...) — JVM은 java.util.Base64$Decoder.decodeBlock을 만나면 자바 바이트코드 대신 저 네이티브 스텁으로 갈아끼운다. 즉 공격자가 제어하는 Base64 문자열이 결국 손으로 짠 벡터 어셈블리에 먹인다는 뜻이다. 그 어셈블리에 경계 계산 버그가 있다면, 라이브러리가 아니라 런타임 그 자체가 뚫린다.

Source: github.com/openjdk/jdk17u
Oracle이 이 취약점을 Compiler 컴포넌트로 분류한 것도 이 맥락이다. 버그는 "라이브러리"가 아니라 "JIT가 생성하는 코드"에 있다. GHSA/NVD가 붙인 분류는 CWE-122, 힙 기반 버퍼 오버플로다. 이제 그 오버플로가 소스 어디서 어떻게 나는지 따라가 본다.
대상 식별과 분석 환경
분석 환경을 먼저 못박는다. 로컬 JVM과, 소스를 읽기 위해 얕게 클론한 OpenJDK 17u 트리, 그리고 소스 태그와 정확히 맞춘 17.0.6 런타임(도커)을 함께 둔다.
java -version; echo; git -C ../jdk17u-src describe --tags; echo "--- 17.0.6 runtime (docker) ---"; docker run --rm eclipse-temurin:17.0.6_10-jdk java -version
로컬 JVM은 OpenJDK 21.0.11(2026-04-21 빌드)이다. 뒤에서 보겠지만 이 버전은 Nov 2026 패치(21.0.13.1) 이전이라, 버전만 보면 취약 구간에 든다. 소스 읽기는 jdk-17.0.6-ga 태그로 한다 — Calif.io가 영향 하한으로 지목한 바로 그 지점이고, 이 분석의 모든 소스 캡쳐는 이 태그에서 git show로 뽑은 것이다.
인트린식이 어디서 생성·등록되는지부터 본다.
git -C ../jdk17u-src show jdk-17.0.6-ga:src/hotspot/cpu/x86/stubGenerator_x86_64.cpp | sed -n '7710,7718p'
StubRoutines::_base64_decodeBlock = generate_base64_decodeBlock(); — JVM 기동 시 이 한 줄이 벡터 디코드 스텁을 만들어 등록한다. 그 함수의 몸통이 이 글의 중심이다.
근본 원인 — 소스로 따라간 정수 언더플로
Calif.io의 설명은 간결하다. "x86-64 Base64 인트린식이 패딩된 꼬리의 저장 마스크를 잘못 계산해 경계 밖 쓰기를 일으킨다. 입력이 패딩으로 끝나면 output_len이 -1이나 -2로 언더플로하고, bzhi(-1, output_len)은 길이가 64 이상이면 모든 비트를 남기므로 마스크가 전부 1이 되어 64바이트를 통째로 쓴다." 이 주장을 그대로 믿지 않고 소스에서 교차검증한다.
먼저 벡터 경로의 진입 조건이다.
git -C ../jdk17u-src show jdk-17.0.6-ga:src/hotspot/cpu/x86/stubGenerator_x86_64.cpp | sed -n '6048,6066p'
두 가지가 소스로 확정된다.
- AVX-512 VBMI 의존:
if(VM_Version::supports_avx512_vbmi() && VM_Version::supports_avx512bw())— 이 플래그가 없는 CPU는 애초에 벡터 코드를 컴파일조차 하지 않고 스칼라 경로로 간다. CPU 의존성은 가설이 아니라 소스에 박혀 있다. - 길이 임계값 128:
cmpl(length, 128); jcc(lessEqual, L_bruteForce)— 입력 길이가 128 이하이면 안전한 스칼라 경로다. 즉 jdk-17.0.6에서 벡터 경로를 타려면 129바이트 이상이어야 한다. 이게 "JDK 17에서는 128개의 A + 패딩"이라는 공개 PoC 기준 트리거 길이와 정확히 맞는다(128개 A +== 129바이트). 신형 빌드에서 이 임계값이 64로 낮아진 것이 "JDK 21 이상에서는 64개의 A"라는 설명과 이어진다(후자의 정확한 임계값은 17u 소스 밖이라 공개 PoC 기준으로 둔다).
이제 자바 레벨 진입점을 본다. 인트린식이 치환하는 바로 그 메서드다.
git -C ../jdk17u-src show jdk-17.0.6-ga:src/java.base/share/classes/java/util/Base64.java | sed -n '784,805p'
@IntrinsicCandidate private int decodeBlock(...) — 애너테이션이 "이 메서드는 인트린식으로 치환될 수 있다"고 표시한다. 자바 구현 자체는 평범하지만, JIT가 데워지면 이 몸통은 실행되지 않고 벡터 스텁이 대신 돈다. 그 스텁을 호출하는 쪽은 decode0의 빠른 경로다.
git -C ../jdk17u-src show jdk-17.0.6-ga:src/java.base/share/classes/java/util/Base64.java | sed -n '806,820p'
decode0은 대상 버퍼 dst를 디코드 예상 길이에 맞춰 작게 할당한 뒤 decodeBlock(src, sp, sl, dst, dp, ...)을 부른다. 핵심은 여기다 — 버퍼는 정상 출력 크기로 잡혀 있는데, 인트린식이 꼬리 처리에서 그보다 더 쓰면 그대로 경계 밖이다.
정상 경로에서 벡터 루프가 어떻게 저장하는지 먼저 보자.
git -C ../jdk17u-src show jdk-17.0.6-ga:src/hotspot/cpu/x86/stubGenerator_x86_64.cpp | sed -n '6186,6199p'
여기선 k2 마스크가 0x0000ffffffffffff로 고정돼 정확히 48바이트만 저장하고 dest를 48 전진시킨다. 64바이트 입력 → 48바이트 출력, 안전하다. 문제는 마지막 꼬리 조각이다.
git -C ../jdk17u-src show jdk-17.0.6-ga:src/hotspot/cpu/x86/stubGenerator_x86_64.cpp | sed -n '6204,6227p'
주석이 친절하다 — "Now have 1 to 63 bytes left to decode." 꼬리 조각을 자바로 넘기지 않고 여기서 직접 처리한다. 계산을 따라가 보자.
output_size = (length >> 2) * 3— 꼬리 길이length에서 출력 바이트 수를 구한다.- 트리거의 경우 128바이트 블록이 루프에서 다 처리되고 꼬리에
=1바이트만 남는다. 즉length = 1. output_size = (1 >> 2) * 3 = 0.
그 다음이 결정적이다. 꼬리 처리를 보자.
git -C ../jdk17u-src show jdk-17.0.6-ga:src/hotspot/cpu/x86/stubGenerator_x86_64.cpp | sed -n -e '6268,6276p' -e '6296,6305p'
L_padding에서 패딩 문자 = 하나마다 decrementq(output_size, 1)로 출력 크기를 깎는다. 그런데 꼬리가 = 한 글자뿐이면 output_size는 이미 0이다. 거기서 1을 빼면 -1, 64비트 레지스터에서는 0xFFFFFFFFFFFFFFFF로 언더플로한다.
그 망가진 output_size가 저장 마스크를 만든다(캡쳐 05의 마지막 줄).
movq(output_mask, -1)→ 마스크 레지스터를 전부 1로.bzhiq(output_mask, output_mask, output_size)→output_size하위 바이트를 인덱스로 상위 비트를 지운다. 그런데BZHI는 인덱스가 64 이상이면 아무 비트도 지우지 않는다.output_size = 0xFFFF...FF의 하위 바이트는0xFF = 255 ≥ 64→ 마스크는 그대로 전부 1(64비트).evmovdqub(Address(dest, dp), k1, tmp, ...)→ 마스크가 전부 1이니 64바이트를 통째로dst에 기록한다.
정리하면 Calif.io의 "정수 언더플로 → 저장 마스크 전부 1 → 64바이트 OOB write"는 소스에서 그대로 확인된다. (1 >> 2) * 3 = 0 → 패딩 =로 -1 언더플로 → bzhi의 64 이상 인덱스 특성으로 마스크가 전부 1 → 몇 바이트만 쓰려던 꼬리 저장이 64바이트를 쏟아, 작게 할당된 dst 경계를 넘는다. 이 체인은 가설이 아니라 소스로 교차검증된 사실이다.

주의할 점 하나 — 이렇게 length가 4의 배수가 아닌(정확히는 4로 나눈 나머지가 1인) 입력은 정상 Base64가 아니다. 자바 레벨 decode는 결국 IllegalArgumentException을 던진다. 하지만 그 예외는 벡터 스텁이 이미 메모리를 덮어쓴 뒤에 나온다. 예외가 손상을 되돌려 주지 않는다.
malformed padding — 왜 하필 "A" 64개 + "=" 인가
트리거가 왜 그 모양인지 소스로 보면 선명하다. 정상 Base64는 길이가 항상 4의 배수다(패딩 포함). 인코더는 4로 나눈 나머지가 1인 문자열을 절대 만들지 않는다. 그런데 트리거는 정확히 그 불가능한 모양 — 길이를 4로 나눈 나머지가 1인 malformed padding이다.
# lenmod.py — 정상 Base64 는 길이가 4의 배수(나머지 0). 트리거는 나머지 1 — 인코더가 못 만드는 모양이다.
samples = {
"normal_cred ": "QWxhZGRpbjpvcGVuIHNlc2FtZQ==",
"trigger_jdk21": "A"*64 + "=", # 65 bytes
"trigger_jdk17": "A"*128 + "=", # 129 bytes
}
for name, s in samples.items():
print(f"{name} len={len(s):>4} len%4={len(s)%4} tail={s[-3:]!r}")python3 lenmod.py
나머지가 1이라는 건 곧 마지막 그룹에 글자가 딱 하나 남는다는 뜻이고, 그 하나가 =이면 앞 절에서 본 output_size = 0 → -1 언더플로로 직행한다. 버전별 길이 차이는 벡터 경로 진입 임계값 차이로 설명된다.
| 대상 | 트리거 모양 | 근거 |
|---|---|---|
| OpenJDK 17.x | "A" 128개 + "=" (129바이트) | 소스 확정 — 임계값 128 (캡쳐 03) |
| OpenJDK 21 이상 | "A" 64개 + "=" (65바이트) | 공개 PoC 기준 — 신형 빌드 임계값 64 |
"A"를 쓰는 건 디코드 결과가 유효해 중간 에러 분기를 피하면서 꼬리까지 도달하기 좋기 때문이다. 핵심은 글자 종류가 아니라 **"벡터 경로를 타는 길이 + 나머지 1 + 꼬리 패딩"**이라는 조합이다. 이 세 가지가 맞으면 꼬리 저장이 64바이트로 폭발한다.
CPU 인트린식 의존성 — AVX-512 VBMI가 있어야 한다
앞서 소스에서 본 supports_avx512_vbmi() 게이트 때문에, 이 취약점은 CPU를 탄다. AVX-512 VBMI 벡터 경로가 있는 x86-64에서만 문제의 스텁이 돈다. 내 분석 랩 CPU가 거기 해당하는지 직접 확인한다.
lscpu | grep -iE 'Model name'; echo '--- AVX-512 VBMI flags present? ---'; grep -oE 'avx512f|avx512bw|avx512vbmi|bmi2' /proc/cpuinfo | sort -u
랩 머신은 Intel N100이다. avx512f/avx512bw/avx512vbmi는 하나도 없고 bmi2만 있다. N100은 Alder Lake-N 계열의 저전력 코어라 AVX-512를 아예 지원하지 않는다. 즉 이 CPU에서는 취약한 벡터 디코드 스텁이 컴파일되지 않는다. 디코드는 안전한 스칼라 경로로 떨어진다. 이게 "이 글이 재현이 아니라 분석"인 가장 물리적인 이유다 — 내 랩에서는 크래시를 낼 CPU 경로 자체가 없다.
공개 자료(Calif.io 디스클로저·oss-security 공지)가 지목한 취약 CPU는 다음과 같다. 네 플래그(avx512f·avx512bw·avx512vbmi·bmi2)가 모두 있어야 한다.
- Intel Xeon: Ice Lake, Sapphire Rapids, Emerald Rapids, Granite Rapids
- AMD EPYC / Ryzen: Zen 4 이상
- ARM64: 비해당(벡터 경로가 ARM엔 없다)
그럼 인트린식 자체는 내 JVM에서 켜져 있을까. 플래그를 본다.
java -XX:+PrintFlagsFinal -version 2>&1 | grep -iE 'UseBASE64Intrinsics|UseAVX '
재미있는 지점이다. UseBASE64Intrinsics=true로 인트린식은 기본 켜져 있다. 하지만 UseAVX=2가 이 CPU의 상한이라, AVX-512 경로는 애초에 선택되지 않는다. 뒤에서 다룰 완화책 -XX:UseAVX=2가 이 N100에서는 이미 기본 상태인 셈이다. 인트린식이 켜져 있어도 CPU가 벡터 경로를 안 주면 안전하다 — 이 취약점이 "버전"만이 아니라 "CPU + JVM 플래그"의 교집합이라는 걸 그대로 보여준다.
JIT 가열 — 인트린식은 데워야 발화한다
조건이 하나 더 있다. 인트린식은 메서드가 충분히 뜨거워져 C2로 컴파일된 뒤에만 실제로 쓰인다. 인터프리터로 도는 동안에는 decodeBlock의 자바 스칼라 구현(캡쳐 07의 그 몸통)이 돌고, 그건 안전하다. 공격자 입장에서는 벡터 스텁이 치환되도록 먼저 Base64 디코드를 대량으로 유발해 JIT를 데운 뒤 트리거를 날려야 한다.
이 경로를 직접 확인한다. 공격자 입력이 실제로 인트린식으로 치환되는지만 보고, 크래시는 내지 않는다(랩 CPU엔 벡터 경로가 없으니 정상 입력만 반복한다).
import java.util.Base64;
// 공격자 입력이 어떻게 Base64 디코더 인트린식 경로로 흘러드는지 "경로만" 확인하는 하니스.
// 크래시를 유발하지 않는다 — 정상 길이의 안전한 입력만 반복해서,
// HotSpot C2 가 java.util.Base64$Decoder.decodeBlock 을 인트린식으로 치환하는지 본다.
public class Harness {
static volatile long sink;
public static void main(String[] args) {
// "Authorization: Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==" 의 뒷부분과 동일한,
// 지극히 평범한 자격증명 문자열. 외부에서 받은 값이 그대로 디코더로 들어가는 모양.
byte[] attackerControlled = "QWxhZGRpbjpvcGVuIHNlc2FtZQ==".getBytes();
Base64.Decoder dec = Base64.getDecoder();
// C2 가 decodeBlock 을 컴파일하도록 충분히 가열한다.
for (int i = 0; i < 400_000; i++) {
sink += dec.decode(attackerControlled).length;
}
System.out.println("decoded ok, sink=" + sink);
}
}java -XX:+UnlockDiagnosticVMOptions -XX:+PrintInlining -Xbatch Harness.java 2>&1 | grep -E 'Base64.(Decoder::)?(decodeBlock|decode0|decodedOutLength|getDecoder)'
java.util.Base64$Decoder::decodeBlock (186 bytes) (intrinsic) — 이 한 줄이 증거다. C2가 가열된 decodeBlock을 인트린식으로 치환했다. 호출 사슬도 그대로 보인다 — getDecoder → decode → decode0 → decodeBlock(intrinsic). 공격자 입력이 평범한 디코드 호출을 타고 결국 네이티브 스텁에 닿는 경로가 확인된다.
그래서 공개 PoC/탐지룰은 워밍업 신호를 공격의 일부로 본다 — 같은 출발지에서 분당 수백에서 1000회 이상 Base64를 품은 요청을 몰아 인트린식을 데운 뒤 트리거를 날린다는 것이다. 인트린식이 C2 산출물이라는 사실은 소스/런타임으로 확인되지만, 구체적 요청 빈도 수치는 공개 PoC/탐지룰 기준으로 둔다(소스로 확정할 수 있는 값이 아니다).
공격 표면 — 인증 전에 Base64를 푸는 지점
공격자가 노릴 곳은 "인증을 끝내기 전에 공격자 문자열을 Base64로 푸는" 모든 지점이다. HTTP Basic 인증이 교과서적 예다. OpenJDK 자체 HTTP 서버에서도 그 패턴이 그대로 보인다.
grep -rn 'Base64.getDecoder().decode' ../jdk17u-src/src | grep -iE 'auth'; echo '--- BasicAuthenticator: Authorization 헤더를 인증 전에 디코드 ---'; sed -n '96,108p' ../jdk17u-src/src/jdk.httpserver/share/classes/com/sun/net/httpserver/BasicAuthenticator.java
BasicAuthenticator는 Authorization 헤더를 읽고(97행), Basic 접두어를 확인한 뒤(104행), 아직 아무도 인증하지 않은 상태에서 Base64.getDecoder().decode(auth.substring(sp+1))로 자격증명을 푼다(107행). 공격자가 보낸 malformed Base64가 인증 전에 디코더로 들어가는 전형적 통로다. NTLM·Negotiate 핸드셰이크도 같은 패턴으로 토큰을 디코드한다.
실제 프레임워크로 가면 표면은 더 넓다. Calif.io가 기본 구성에서 인증 전 RCE를 시연했다고 밝힌 대상은 다음과 같다.
- Keycloak — IdP, Basic/Bearer 처리
- Atlassian Jira / Confluence
- JFrog Artifactory
- Jenkins
- PingFederate
사후 인증(post-auth)으로 시연된 대상도 있다 — Apache Kafka Broker, Apache Solr, Elasticsearch, Gerrit, Spinnaker 등(모두 Calif.io 기준, 비망라적). 공통점은 하나다 — 공격자가 넣을 수 있는 Base64 필드가 어딘가에 있고, 그걸 인증 전/후에 Base64.getDecoder().decode로 푼다는 것.
트리거가 요청에 실리는 모양은 이렇다. **실제 무기화 익스가 아니라 "트리거 형태"**라는 점을 분명히 한다 — 값만 malformed Base64일 뿐, 겉보기엔 평범한 인증 시도다.
POST /auth/realms/master/protocol/openid-connect/token HTTP/1.1
Host: idp.target.example
Authorization: Basic QUFBQUFB...(A 64~128개)...QUE=
Content-Type: application/x-www-form-urlencoded
grant_type=client_credentialsJWT를 쓰는 경로라면 Bearer 토큰의 Base64url 세그먼트가 같은 역할을 한다.
GET /api/me HTTP/1.1
Host: app.target.example
Authorization: Bearer eyJhbGciOiJIUzI1NiJ9.QUFBQUFB...QUE.c2ln둘 다 "비정상적으로 길고 단조로운 Base64 + 꼬리 패딩"이라는 공통 지문을 남긴다. 이건 방어자에게 기회다 — 뒤 탐지 절에서 그 지문을 룰로 잡는다.
왜 Log4Shell보다 넓고, 또 다른가
Log4Shell과 비교하면 이 취약점의 성격이 분명해진다.

더 넓은 축: Log4Shell은 log4j를 쓰는 앱만의 문제였다. Java4Shell의 취약 코드는 JVM 런타임에 있으니, 특정 라이브러리를 쓰든 안 쓰든 Base64를 디코드하기만 하면 표면이 된다. 그런데 Base64 디코드는 거의 모든 웹 Java 앱이 인증·토큰·멀티파트에서 한다. 범위가 "특정 라이브러리 사용자"에서 "그 JVM에서 도는 거의 모든 앱"으로 넓어진다.
더 좁은 축: 대신 CPU를 탄다. AVX-512 VBMI 벡터 경로가 있는 x86-64에서만 발화한다. ARM64 서버, 구형/저전력 x86은 비해당이다. Log4Shell엔 그런 제약이 없었다. 공격자는 "이 Java 앱이 취약 CPU 위에서 도는가"라는 추가 조건을 통과해야 한다.
대응의 무게도 다르다. Log4Shell은 라이브러리 하나를 올리면 끝이었다. Java4Shell은 JVM 자체를 패치해야 한다. 컨테이너 베이스 이미지, 앱 서버 번들 JRE, 임베디드 런타임까지 전부 교체 대상이라 재배포 범위가 훨씬 넓다.
AI가 한 시간에 찾은 취약점
이 CVE의 서사에서 빠뜨릴 수 없는 게 발견 방식이다. 1차 출처인 Calif.io 디스클로저에 따르면, 이 취약점은 AI 보조 연구로 발견됐다.

Source: Calif.io — Java4Shell
Calif.io의 Quang Luong이 Codex(OpenAI)에 JIT·인트린식·API·암호 코드를 감사하라고 지시했고, 그 과정에서 이 버그가 나왔다고 한다. 글의 표현을 빌리면 "취약점을 찾는 데 한 시간, 첫 동작 익스플로잇을 만드는 데 두 시간이 더 걸렸고", "토큰 비용은 200달러 미만"이었다. 같은 팀이 앞서 공개한 게 PHP2Shell(관련 분석)이고, 이번엔 "PHP가 뭔지 모르는 사람이 많아서 더 친숙한 Java로 갔다"는 농담까지 붙였다.

Source: oss-security — CVE-2026-114938 (2026-11-17)
공격자 관점에서 이 서사의 함의는 불편하다. 인트린식 어셈블리 같은 "사람 눈이 잘 안 가는 저수준 코드"를 AI가 한 시간 만에 훑어 메모리 손상을 집어냈다. 비용은 커피 몇 잔 값이다. 방어 측이 "여긴 아무도 안 본다"고 믿던 저수준 영역이 더는 안전지대가 아니다. 다만 발견 과정의 세부(시간·비용·프롬프트 분량)는 모두 Calif.io 기준으로, 독립 검증된 수치는 아니다.
노출 규모 — 수치는 짓지 않는다
"얼마나 많은 서버가 취약한가"는 함부로 숫자를 댈 수 없다. 이유가 분명하다.
- JDK 버전은 인터넷 배너에 잘 안 드러난다. HTTP
Server헤더로는 앱 서버(Jetty/Tomcat)까지만 보통 보이고, 그 아래 JRE 버전은 직접 노출되지 않는다. - 결정적으로 취약 조건인 "호스트 CPU에 AVX-512 VBMI가 있는가"는 네트워크 밖에서 알 수 없다. 외부에서 그 교집합을 세는 건 불가능에 가깝다.
그래서 수치 대신 핑거프린트 쿼리만 소개한다(스캔도, 집계도 하지 않았다 — 없는 숫자는 짓지 않는다).
# Shodan — 취약 "대상이 될 수 있는" 앱의 인터넷 지문 (수치 제시 안 함)
http.component:"keycloak"
http.title:"Jenkins"
http.component:"atlassian confluence"
product:"Jetty"
# Censys — 같은 맥락 (앱 레이어 지문)
services.http.response.html_title: "Jenkins"
services.software.product: "Keycloak"이 쿼리로 나오는 건 "취약할 수도 있는 후보"일 뿐이다. 실제 취약 여부는 그 호스트의 JDK 버전과 CPU, JIT 가열 여부가 모두 맞아야 결정된다. 공격자 입장에서도 이 불확실성은 그대로라, "무차별 스캔"보다 "특정 대상의 버전·CPU를 아는 상황"에서 의미가 커진다.
공개 PoC와 사칭 스캐너 경고
공개 직후의 전형적 패턴이 이번에도 반복되고 있다. 트리거 구조·탐지룰·픽스 버전이 공개되기 시작했고, 동시에 "Java2Shell 스캐너", "원클릭 익스플로잇" 류의 사칭 스크립트가 돌 수 있는 시점이다. Log4Shell 때도 그랬다.
분명히 경고한다 — GitHub 등에서 도는 "Java4Shell/Java2Shell 스캐너·익스플로잇"을 받아서 돌리지 마라. 이유는 셋이다.
- 발견자(Calif.io)는 애플리케이션별 무기화 체인을 의도적으로 보류했다. 지금 "완성 익스"를 자처하는 임의 스크립트는 그 출처가 의심스럽다.
- 그런 스크립트는 당신 쪽에서 트리거를 날리는 코드라, 취약 호스트를 실제로 크래시내거나(서비스 중단) 백도어를 심을 수 있다.
- "스캐너"를 가장한 악성코드가 자격증명·토큰을 털어 가는 건 공개 직후마다 반복된 수법이다.
검증이 필요하면 공개된 1차 자료의 바운드 PoC 개념만 참고한다. 공개 분석/탐지룰 저장소로는 github.com/ikow/java4shell-poc(저자 Qi Deng, MIT)가 알려져 있고, 1차 기술 분석은 Calif.io 디스클로저다. 이 글은 그 코드를 받지도 실행하지도 않았다 — 사실관계와 트리거 구조만 소개하고, 실제 발화 검증은 CPU·트리거가 갖춰진 환경에서 후속글(B)로 다룬다. 공개 payload는 일단 불신하고 소스로 교차검증하는 게 이 블로그의 원칙이다.
탐지 — 방어자 관점 시그니처
재현이 어렵다고 방어까지 손 놓을 이유는 없다. 트리거는 네트워크에 또렷한 지문을 남긴다 — "정상 인코더가 만들 수 없는 malformed Base64". 아래는 그 지문을 잡는 탐지 로직을, 공개 PoC/탐지룰 저장소(github.com/ikow/java4shell-poc)의 접근을 공격자 관점에서 재구성한 것이다(정확한 임계값은 그 저장소 기준이며, 운영 환경에 맞춰 튜닝해야 한다).
먼저 Basic 인증 헤더의 malformed padding을 잡는다. 정상 자격증명은 길이가 4의 배수라 이 패턴에 안 걸린다.
# (1) Basic 인증 헤더에 malformed Base64 (길이 나머지 1, 꼬리에 단독 '=')
alert http any any -> $HOME_NET any ( \
msg:"Java4Shell: Basic auth malformed base64 padding (len%4==1)"; \
flow:to_server,established; \
http.header; content:"Authorization|3a| Basic "; nocase; \
pcre:"/Basic\s+(?:[A-Za-z0-9+\/]{4})+=\s*(?:\r?\n|$)/Hi"; \
classtype:attempted-admin; sid:2026114938; rev:1; )(?:[A-Za-z0-9+/]{4})+= — 4글자 묶음이 반복된 뒤 단독 = 하나로 끝나는 모양, 즉 길이를 4로 나눈 나머지가 1인 malformed 토큰이다. 정상 Base64는 이 모양이 안 나온다.
다음은 단조로운 긴 블록 — "A"가 64개 또는 128개 이어지는 트리거 특유의 저엔트로피 지문이다.
# (2) 단조로운 긴 Base64 런 (트리거 특유의 'A' 반복)
alert http any any -> $HOME_NET any ( \
msg:"Java4Shell: long monotonic base64 run in auth material"; \
flow:to_server,established; http.header; \
pcre:"/(?:Basic|Bearer)\s+[^\r\n]*?A{64,}=/Hi"; \
classtype:attempted-admin; sid:2026114939; rev:1; )JWT Bearer 토큰의 세그먼트에도 같은 검사를 건다.
# (3) Bearer 토큰 세그먼트의 malformed base64url
alert http any any -> $HOME_NET any ( \
msg:"Java4Shell: Bearer token malformed base64url segment"; \
flow:to_server,established; http.header; \
content:"Authorization|3a| Bearer "; nocase; \
pcre:"/Bearer\s+[A-Za-z0-9_\-]+\.(?:[A-Za-z0-9_\-]{4})+[.=]/Hi"; \
classtype:attempted-admin; sid:2026114940; rev:1; )행위 상관으로는 JIT 가열을 잡는다 — 같은 출발지가 짧은 시간에 Base64를 품은 인증 요청을 비정상적으로 많이 보내는 패턴이다.
# (4) JIT warm-up — 단일 출발지의 고빈도 인증 요청 (임계값은 환경에 맞춰 조정)
alert http any any -> $HOME_NET any ( \
msg:"Java4Shell: possible intrinsic warm-up burst"; \
flow:to_server,established; http.header; content:"Authorization|3a|"; nocase; \
threshold:type both, track by_src, count 600, seconds 60; \
classtype:attempted-dos; sid:2026114941; rev:1; )마지막으로 결과 지표 — 트리거가 실제로 발화하면 JVM이 죽는다. 요청 직후의 연결 리셋이나 5xx 급증, 그리고 서버에 남는 크래시 로그가 그 지표다. 취약 호스트에서 기대되는 hs_err_pid 머리말은 구조상 이런 모양이다(개념 예시 — 랩 CPU엔 벡터 경로가 없어 실제 크래시가 아니다).
# 개념 예시: AVX-512 경로가 있는 취약 호스트에서 기대되는 hs_err_pid 머리말
# A fatal error has been detected by the Java Runtime Environment:
# SIGSEGV (0xb) at pc=0x00007f..., pid=..., tid=...
# Problematic frame:
# v ~StubRoutines::base64_decodeBlock
# ... decodeBlock 벡터 스텁에서 저장 중 세그먼트 폴트탐지 룰과 별개로, "malformed Base64가 인증 자재에 들어왔는가"는 로그로도 사후 사냥이 된다. 실제로 그런 판정을 하는 작은 방어자용 휴리스틱을 만들어 봤다.
#!/usr/bin/env python3
# Java4Shell(CVE-2026-114938) 프로브 탐지 — 방어자용 휴리스틱.
# 익스플로잇은 "비정상적으로 길고 단조로운 Base64" 를 디코더에 먹인다
# (64자 또는 128자 이상의 'A' + 패딩). 정상 자격증명/JWT 와 구분한다.
import base64
import collections
import math
import re
B64 = re.compile(r'^[A-Za-z0-9+/_-]+={0,2}$')
def shannon_bits(s):
counts = collections.Counter(s)
n = len(s)
return abs(-sum((c / n) * math.log2(c / n) for c in counts.values()))
def judge(label, token):
if not B64.match(token):
print(f"[ok ] {label:12} base64 형식 아님")
return
body = token.rstrip('=')
reasons = []
if len(token) >= 64:
reasons.append(f"len={len(token)}(>=64)")
ent = shannon_bits(body)
if ent < 2.0:
reasons.append(f"entropy={ent:.2f}bit")
if len(set(body)) <= 2:
reasons.append(f"distinct={len(set(body))}")
verdict = "FLAG" if reasons else "ok "
print(f"[{verdict}] {label:12} " + (" ".join(reasons) if reasons else "정상 토큰"))
samples = [
("normal_cred", "QWxhZGRpbjpvcGVuIHNlc2FtZQ=="), # Aladdin:open sesame
("normal_jwt ", "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9"), # JWT 헤더
("trigger_65 ", "A" * 64 + "="), # 신형 빌드 트리거 모양
("trigger_129", "A" * 128 + "="), # 17.0.6 트리거 모양
]
for label, tok in samples:
judge(label, tok)python3 detect.py
정상 자격증명·JWT 헤더는 통과하고, 두 트리거 모양만 길이·엔트로피·문자 다양성 세 지표로 걸러진다. entropy=0.00bit, distinct=1이 "A" 반복의 저엔트로피 지문을 그대로 드러낸다. 완벽한 룰은 아니지만, "정상 인코더가 만들 수 없는 모양"이라는 본질을 공격자가 피하기는 어렵다 — 피하려면 트리거 구조 자체를 바꿔야 한다.
방어 — 패치 버전과 완화책

Source: NVD — CVE-2026-114938
내가 취약 경로 위에 있나 — 자가 점검
패치를 깔기 전에 "우리 서버가 이 벡터 경로 위에 있는가"부터 3분 만에 가른다. 앞에서 캡쳐로 보여준 명령 세 개를 그대로 복사해 돌리면 된다.
# 1) JVM 버전 — 픽스 전 구간(17.0.6 이상, 픽스 릴리스 미만)인가
java -version
# 2) 취약 벡터 경로(AVX-512 VBMI)가 이 CPU에 있나 — 출력이 비면 이 경로로는 '해당 없음'
lscpu | grep -i avx512_vbmi
# 3) Base64 인트린식이 켜져 있나 (기본 on)
java -XX:+PrintFlagsFinal -version 2>&1 | grep -i base64읽는 법은 간단하다.
- (2)가 비어 있으면 — ARM64, 또는 저전력·구형 x86(앞서 본 N100이 그렇다) — 이 벡터 경로로는 발화하지 않는다. 가장 빠른 "해당 없음" 판정이다.
- (2)에
avx512_vbmi가 뜨고 (1)이 픽스 전 버전이며 (3)의UseBASE64Intrinsics가true라면, 취약 경로가 열려 있을 수 있다. 바로 패치·완화로 넘어간다. - 컨테이너·앱 서버에 번들된 JRE는 호스트
java와 버전이 다를 수 있으니, 실제로 돌아가는 프로세스의 JVM으로 확인한다.
패치 버전
패치는 이미 나왔다. 2026-11-17, OpenJDK 어드바이저리와 Oracle Critical Patch Update(2026-11)가 동시에 공개됐다. 픽스가 담긴 버전은 다음과 같다(Calif.io·Oracle CPU 기준).
| 트랙 | 영향(픽스 전) | 픽스 버전 |
|---|---|---|
| Oracle Java SE 8 | 8u511(b33-perf) | 8u521 계열 |
| JDK 17 | 17.0.6 ~ 17.0.21(.0.3) | 17.0.21.1 |
| JDK 21 | ~ 21.0.13(.0.3) | 21.0.13.1 |
| JDK 25 | ~ 25.0.5(.0.3) | 25.0.5.1 |
| JDK 27 | ~ 27.0.1(.0.3) | 27.0.1.1 |
8 트랙은 NVD가 영향 버전으로 8u511b33-perf를 적시했다(정확한 8 계열 픽스 번호는 Oracle CPU에서 확인되는 대로 갱신한다). Amazon Corretto·Eclipse Temurin 등 다운스트림 빌드도 각자 대응 릴리스를 낸다. 취약↔패치 소스 diff는 아직 공개 전이라(oss-security 공지도 "실제 소스 픽스 링크는 아직 못 봤다"고 적었다), 그 diff 분석은 확인되는 대로 갱신한다.

Source: Oracle Critical Patch Update — November 2026
완화책 (패치가 급할 때)
패치를 당장 적용하기 어렵다면, JVM 플래그로 벡터 경로를 끊는 완화책이 있다(Calif.io·OpenJDK 어드바이저리 기준). 각각 부작용이 다르니 골라 쓴다.
-XX:-UseBASE64Intrinsics— 하드웨어 가속 Base64 인트린식만 끄고 안전한 자바 스칼라 구현으로 되돌린다. 부작용이 가장 좁다: 영향은 Base64 인코딩/디코딩 처리량에만 국한되고 나머지 인트린식은 그대로다. TLS·JWT·멀티파트가 많은 서비스라면 해당 경로가 느려질 수 있으나, 보통은 체감이 작다.-XX:UseAVX=2— AVX-512 벡터화 전체를 상한 AVX2로 낮춘다. Base64뿐 아니라 다른 AVX-512 최적화(일부 벡터 복사·암호 루틴 등)까지 함께 꺼지므로 성능 영향 범위가 더 넓다. 그리고 x86-64 호스트에서만 쓴다 — ARM JVM은 이 플래그를 모르고 기동 자체가 실패한다.
둘 중 하나면 충분하고, 부작용이 좁은 -XX:-UseBASE64Intrinsics가 1순위다. 앞서 봤듯 N100 같은 비-AVX-512 호스트에서는 UseAVX=2가 이미 기본값이라, 이 완화책이 유효한지는 결국 CPU가 결정한다. 어느 쪽이든 임시 조치이고, 근본책은 JVM 교체다.
정리하면 방어 우선순위는 이렇다 — ① JVM 패치가 근본책이다(라이브러리가 아니라 런타임을 올린다). ② 패치 전엔 -XX:-UseBASE64Intrinsics로 임시 차단. ③ 그동안 탐지 룰로 malformed Base64 프로브를 가시화한다. ④ 컨테이너 베이스 이미지·번들 JRE까지 버전 인벤토리를 훑는다 — JVM은 생각보다 많은 곳에 임베드돼 있다.
정리 — 그리고 B 후속 예고
이번 건은 공격면의 층이 한 칸 아래로 내려왔다. 라이브러리가 아니라 JVM 본체, 그중에서도 사람 눈이 잘 안 가던 인트린식 어셈블리에서 정수 언더플로 하나가 힙 경계 밖 쓰기로, 또 pre-auth RCE로 이어졌다. 그걸 AI가 한 시간에, 200달러 미만으로 찾아냈다.
이 글에서 소스로 확정한 것과 외부 출처 기준으로 서술한 것을 다시 갈라 둔다.
- 소스로 교차검증:
output_size = (1 >> 2) * 3 = 0→ 패딩=로-1언더플로 →bzhi의 64 이상 인덱스 특성으로 저장 마스크 전부 1 →evmovdqub가 64바이트 OOB write. AVX-512 VBMI 게이트. JDK 17의 128 임계값.@IntrinsicCandidate치환 경로. 인증 전BasicAuthenticator디코드. - 외부 출처 기준(Calif.io / 공개 PoC): JDK 21의 64자 트리거 길이, JIT 가열 요청 빈도 수치, CVSS 4.0 9.2, AI 발견 서사(시간·비용), 시연 대상 앱 목록, 사후 패치 버전 번호.
- 아직 미확인: 취약↔패치 소스 diff, 제어 흐름 탈취까지의 완전 익스플로잇.
후속글(B)은 세 가지 중 하나라도 공개되면 착수한다 — ① 신뢰할 수 있는 PoC, ② OpenJDK 패치 커밋(취약↔패치 diff), ③ 벤더 딥다이브의 트리거 바이트 구조. 그때는 취약 CPU 경로를 가진 타겟에 격리 환경을 꾸려, 크래시(hs_err 생성)로 메모리 손상을 실증하는 것부터 단계적으로 간다. 지금 당장은, 당신 인프라의 JVM 버전과 호스트 CPU를 함께 훑는 것 — 그게 이 분석에서 가져갈 가장 실용적인 한 가지다.
Comments
댓글
댓글을 남기려면 로그인이 필요해요. (네이버 · 구글 계정)
댓글 불러오는 중…