Threat hunting briefing — Microsoft Defender and Sentinel
Hunting Java4Shell (CVE-2026-114938) in Microsoft Defender and Sentinel
The exploit leaves no process, file or thread event. Here is what you can still see, and how to hunt it.

TL;DR
Java4Shell (CVE-2026-114938) is a reported memory-corruption flaw in the JDK's hardware-accelerated Base64 decoder, and the exploit itself leaves no process, file or thread event for your EDR to see. You can still scope your exposure and catch the indirect traces with Defender for Endpoint telemetry in Microsoft Sentinel. Public reporting is thin: as of 18 November 2026 the CVE record is reserved, no exploitation or public proof of concept is reported, and vendors have not confirmed the details.
The approach in five steps:
- Find every Java runtime by path and version from 30 days of process events.
- Keep the versions in the reported range: 17.0.6 and later, 21, 25 and 27. Java 8 and 11 appear in no report.
- Rank hosts by exposure, but never exclude internal ones, because an attacker who has landed elsewhere can reach any internal listener.
- Detect what is visible: a burst of inbound connections followed by a JVM crash, new shells spawned by Java, and new outbound destinations.
- Apply the vendor update, or the interim JVM flag, and verify it took effect.
What is known, and what is not
Treat everything below as reported, not confirmed, until the OpenJDK project and the researchers publish their full write-ups.
| Topic | What is reported | Confidence |
|---|---|---|
| Bug | A heap out-of-bounds write in the x86-64 AVX-512 Base64 decoding intrinsic. Malformed padding makes the computed output length wrong, and the decoder writes 64 bytes where 2 are expected, 62 bytes past the end of the array. | Researcher analysis, not vendor confirmed |
| What the attacker controls | Timing and location of the write. The overwritten bytes are a fixed pattern. | Researcher analysis |
| Trigger | Base64 decoded before validation: HTTP Basic credentials, JWT headers and payloads, and similar fields. The decoder must be JIT-compiled first, about 10,000 decodes in one reported test. | Researcher analysis |
| CPU condition | x86-64 with AVX-512 VBMI (Intel Ice Lake and later, AMD Zen 4 and later). ARM and older Intel run a different path. | Researcher analysis |
| Versions | Java 17.0.6 and later, 21, 25 and 27. Java 8 and 11 appear in no report. Reports on 21 and later vary in confidence. | The 17.0.6 boundary matches the OpenJDK tracker, where the AVX-512 decoder was backported to 17 in 17.0.6 |
| Code execution | Not proven. It would need precise heap shaping. | Unproven |
| Exploitation | None reported, no public proof of concept, not in CISA KEV as of 18 November 2026. | Reported |
| Fixes | Oracle shipped new builds on 17 November (17.0.21.1, 21.0.13.1, 25.0.5.1, 27.0.1.1, 11.0.33.1, 8u513) but has not said which of its fixes covers this CVE. Other distributions had not published fixed builds at time of writing. | Check your vendor's advisory |
The practical read: a reliable crash is plausible, remote code execution is unproven, and the exposure is wide because the flaw is in the runtime, not a library. Dependency scanners that read application packages will not see it. Look for the runtime itself.
What endpoint telemetry can and cannot see
The overwrite happens inside the JVM's own memory, as part of a normal in-process operation. The operating system sees no new process, no file write and no network connection tied to the corruption itself, so there is nothing for Defender to record at that step.
Two things people often ask:
- Will the command line show the request? No. A process command line is fixed when the process starts. A header that arrives later over the network is handled in memory and never written back into it. Command lines help in two other places: a child process the JVM spawns, and proof that a mitigation flag is set.
- Can I find the 62 bytes? No. That figure is how far the overwrite runs past the buffer inside the heap. It is not the size of the request, and the attacker does not control its content. The request itself is a short malformed Base64 token in an HTTP header, visible only in proxy, WAF or application logs.
So the hunt targets the indirect traces: who accepts inbound connections, connection bursts, JVM crashes and restarts, and what the JVM does afterwards.

Figure 1. Defender records the stages around the exploit, not the exploit itself.
Steps 1 to 3: find, filter and rank the exposure
The sample results below come from a mid-sized Windows-heavy environment. Hostnames, domains, usernames and application names that could identify it are removed, and roles are generalized.
Step 1: inventory every Java runtime
Start with process events, not the vulnerability-management inventory. Inventory tools miss runtimes bundled inside applications, while a running binary always shows its own path. Use 30 days, because a long-running service logs a process start only when it launches.
DeviceProcessEvents
| where Timestamp > ago(30d) and FileName in~ ('java.exe','javaw.exe')
| summarize runs=count(), LastSeen=max(Timestamp)
by DeviceName, FolderPath, ProcessVersionInfoCompanyName, ProcessVersionInfoProductVersion
| sort by ProcessVersionInfoProductVersion descProcessVersionInfoProductVersion reads the version from the binary's own metadata, so you get the exact runtime without trusting a folder name. Remember that java.exe is the launcher name for every OpenJDK vendor (Temurin, Corretto, Zulu, Oracle and others), so the filename tells you nothing about vendor or version. Applications that wrap their own runtime may run under another name. Find those by the module they load:
DeviceImageLoadEvents | where Timestamp > ago(1d) and FileName =~ 'jvm.dll' | summarize by DeviceName, InitiatingProcessFileName, InitiatingProcessCommandLine, FolderPath
Step 2: keep only the reported range
DeviceProcessEvents
| where Timestamp > ago(30d) and FileName in~ ('java.exe','javaw.exe')
| extend maj = toint(split(ProcessVersionInfoProductVersion,'.')[0]),
upd = toint(split(ProcessVersionInfoProductVersion,'.')[2])
| where maj in (21,25,27) or (maj == 17 and upd >= 6)
| summarize runs=count() by DeviceName, FolderPath, ProcessVersionInfoCompanyName, ProcessVersionInfoProductVersionOne trap: Corretto uses four-part versions such as 21.0.12.1, where the last digit is its own build number. Do not read it as a patched build.

Figure 2. Redacted inventory from the sample environment. Six of ten host groups are in the reported range.
In this sample, the in-range hosts were a single-sign-on server, four bundled runtimes inside an IT service management integration agent, and a handful of test, CI and developer-tool installs. Java 8, 11 and a legacy Java 6 install were out of range.
Step 3: rank by exposure, but exclude nobody
Ask which in-range JVMs accept inbound connections, since the reported trigger arrives over the network.
let inRange = DeviceProcessEvents
| where Timestamp > ago(30d)
| where FileName in~ ('java.exe','javaw.exe')
| extend maj = toint(split(ProcessVersionInfoProductVersion,'.')[0]),
upd = toint(split(ProcessVersionInfoProductVersion,'.')[2])
| where maj in (21,25,27) or (maj == 17 and upd >= 6)
| distinct DeviceName, ProcessVersionInfoProductVersion, InitiatingProcessFolderPath = tolower(FolderPath);
DeviceNetworkEvents
| where Timestamp > ago(30d)
| where ActionType in ('ListeningConnectionCreated','InboundConnectionAccepted')
| where InitiatingProcessFileName in~ ('java.exe','javaw.exe')
| extend InitiatingProcessFolderPath = tolower(InitiatingProcessFolderPath)
| join kind=inner inRange on DeviceName, InitiatingProcessFolderPath
| summarize conns=count(), ports=make_set(LocalPort,10), remotes=dcount(RemoteIP)
by DeviceName, ProcessVersionInfoProductVersion, InitiatingProcessFolderPathIn the sample, only the single-sign-on server appeared, with one service port and three distinct client addresses. That is the host to patch first, because identity services decode Basic credentials and tokens before they trust a request.
Two cautions. Absence from this result means "not observed", not "not listening", because Defender does not capture every listener. And internal hosts are not safe by default: an attacker who has already landed on one machine can reach any internal listener. Use exposure to order the work, never to exclude a host.
To see which in-range services accept connections from public addresses, patch these first:
DeviceNetworkEvents
| where Timestamp > ago(14d)
| where ActionType == 'InboundConnectionAccepted'
| where InitiatingProcessFileName in~ ('java','java.exe','javaw.exe')
| where RemoteIPType == 'Public'
| summarize Connections=count(), Sources=dcount(RemoteIP), Ports=make_set(LocalPort, 20), LastSeen=max(Timestamp)
by DeviceName, InitiatingProcessFolderPath
| order by Sources descStep 4: three detections you can run today
These are starting points. Run each in the Logs blade first, baseline your own environment, then promote the useful ones to scheduled analytics rules.
Detection 1: connection burst followed by a JVM crash
The reported flaw only triggers after the decoder has been JIT-compiled, which took roughly 10,000 decodes in one test. An attacker probing a service would therefore likely send a high-volume burst from one source, then the JVM would crash. This rule looks for that sequence on in-range hosts.

Figure 3. The correlation: a burst from one source, then a crash signal on the same host within 30 minutes.
let lookback = 1h;
let burstThreshold = 500; // placeholder: tune against your baseline
let inRange = DeviceProcessEvents
| where Timestamp > ago(30d)
| where FileName in~ ('java.exe','javaw.exe')
| extend maj = toint(split(ProcessVersionInfoProductVersion,'.')[0]),
upd = toint(split(ProcessVersionInfoProductVersion,'.')[2])
| where maj in (21,25,27) or (maj == 17 and upd >= 6)
| summarize JavaVersion = take_any(ProcessVersionInfoProductVersion)
by DeviceId, InitiatingProcessFolderPath = tolower(FolderPath);
let bursts = DeviceNetworkEvents
| where Timestamp > ago(lookback)
| where ActionType == 'InboundConnectionAccepted'
| where InitiatingProcessFileName in~ ('java.exe','javaw.exe')
| extend InitiatingProcessFolderPath = tolower(InitiatingProcessFolderPath)
| summarize Conns = count(), BurstStart = min(Timestamp), BurstEnd = max(Timestamp)
by DeviceId, DeviceName, LocalPort, RemoteIP, InitiatingProcessFolderPath, bin(Timestamp, 5m)
| where Conns >= burstThreshold;
let crashFiles = DeviceFileEvents
| where Timestamp > ago(lookback + 30m)
| where ActionType == 'FileCreated' and FileName startswith 'hs_err_pid' and FileName endswith '.log'
| project DeviceId, CrashTime = Timestamp, CrashSignal = 'hs_err file', CrashDetail = FolderPath;
let restarts = DeviceProcessEvents
| where Timestamp > ago(lookback + 30m)
| where FileName in~ ('java.exe','javaw.exe')
| where not(ProcessCommandLine has_any ('-version','-fullversion'))
| summarize Starts = count(), CrashTime = max(Timestamp) by DeviceId, ProcessCommandLine, bin(Timestamp, 10m)
| where Starts >= 3
| project DeviceId, CrashTime, CrashSignal = 'restart burst', CrashDetail = ProcessCommandLine;
let crashes = union crashFiles, restarts;
bursts
| join kind=inner inRange on DeviceId, InitiatingProcessFolderPath
| join kind=inner crashes on DeviceId
| where CrashTime between (BurstStart .. (BurstEnd + 30m))
| project TimeGenerated = CrashTime, DeviceName, DeviceId, SourceIP = RemoteIP, TargetPort = LocalPort,
Conns, JavaVersion, JavaPath = InitiatingProcessFolderPath, CrashSignal, CrashDetailThree lessons from running it:
- The 500 threshold is a placeholder. HTTP keep-alive reuses connections, so a real burst can show as far fewer connection events than requests. Baseline each service first.
- Some agents run
java -versionhundreds of times a day as health probes. Without the-versionexclusion, the restart signal floods. - Map the source address as an IP entity in the analytics rule, so an alert points you at the machine the traffic came from, not only the victim.
Detection 2: shell-spawn drift
A Java process that suddenly starts a shell is worth a look, but build tools, schedulers and integration agents do this legitimately all day. Hardcoding exclusions for each product is brittle and blinds you on exactly the hosts that matter. Instead, learn what each Java process normally spawns on each host, and alert on anything new.
The query normalizes command lines (GUIDs and numbers become placeholders, so cloneScript6397.ps1 and cloneScript1504.ps1 are the same pattern), builds a baseline from patterns seen on at least three different days, and flags last-hour activity that is not in it.
let lookback = 1h;
let minDays = 3;
let shells = dynamic(['cmd.exe','powershell.exe','pwsh.exe','sh','bash','curl.exe','certutil.exe','bitsadmin.exe','wmic.exe']);
let inRange = DeviceProcessEvents
| where Timestamp > ago(30d)
| where FileName in~ ('java.exe','javaw.exe')
| extend maj = toint(split(ProcessVersionInfoProductVersion,'.')[0]),
upd = toint(split(ProcessVersionInfoProductVersion,'.')[2])
| where maj in (21,25,27) or (maj == 17 and upd >= 6)
| summarize JavaVersion = take_any(ProcessVersionInfoProductVersion)
by DeviceId, ParentPath = tolower(FolderPath);
let javaChildren = materialize(
DeviceProcessEvents
| where Timestamp > ago(30d)
| where InitiatingProcessFileName in~ ('java.exe','javaw.exe')
| where FileName in~ (shells)
| extend ParentPath = tolower(InitiatingProcessFolderPath),
Child = tolower(FileName),
NormCmd = replace_regex(
replace_regex(tolower(ProcessCommandLine),
'[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}', '<guid>'),
'[0-9]+', '<n>')
);
let baseline = javaChildren
| where Timestamp < ago(lookback)
| summarize DaysSeen = dcount(bin(Timestamp, 1d)), BaselineCount = count()
by DeviceId, ParentPath, Child, NormCmd
| where DaysSeen >= minDays;
let hostBaseline = baseline | summarize HostBaselineRows = sum(BaselineCount) by DeviceId;
javaChildren
| where Timestamp >= ago(lookback)
| join kind=inner inRange on DeviceId, ParentPath
| join kind=leftanti baseline on DeviceId, ParentPath, Child, NormCmd
| join kind=leftouter hostBaseline on DeviceId
| extend DriftType = iff(isnull(HostBaselineRows), 'NoBaselineForHost', 'NewParentChildPattern')
| project TimeGenerated = Timestamp, DeviceName, DriftType, JavaVersion, ParentPath,
InitiatingProcessCommandLine, FileName, ProcessCommandLineCaveats worth knowing before you rely on it:
- Sentinel scheduled rules cap how far back they can read (14 days when I last checked), so a 30-day baseline may be truncated. Use a 14-day baseline, or store the baseline in a summary rule or watchlist.
- An attacker who repeats the same command on three or more days becomes normal. Review the baseline periodically.
- Some agents feed PowerShell commands over stdin, so the command line shows only the interpreter, not the commands. Treat those hosts as lower confidence for this rule.
Detection 3: new outbound destinations
A compromised JVM may call out somewhere new. This flags public destinations contacted this week but not in the previous 30 days. Expect noise from services that call cloud APIs, so scope it to the in-range hosts once you have the list.
let Baseline = DeviceNetworkEvents
| where Timestamp between (ago(37d) .. ago(7d))
| where InitiatingProcessFileName in~ ('java','java.exe','javaw.exe')
| where ActionType == 'ConnectionSuccess' and RemoteIPType == 'Public'
| distinct DeviceName, RemoteIP;
DeviceNetworkEvents
| where Timestamp > ago(7d)
| where InitiatingProcessFileName in~ ('java','java.exe','javaw.exe')
| where ActionType == 'ConnectionSuccess' and RemoteIPType == 'Public'
| join kind=leftanti Baseline on DeviceName, RemoteIP
| summarize Connections=count(), FirstSeen=min(Timestamp), Ports=make_set(RemotePort, 10)
by DeviceName, RemoteIP, RemoteUrl, InitiatingProcessFolderPath
| order by FirstSeen descTriage: when a detection fires
- Note the source IP, target host, port and time window from the alert.
- Find the source machine. A connection source is often an internal host, and that is where the investigation should widen.
DeviceNetworkInfo | where Timestamp > ago(7d) and IPAddresses has '<source ip>' | summarize arg_max(Timestamp, *) by DeviceName
- Look at what the source host was doing around the burst: scanning tools, new accounts, remote logons, unusual child processes of its own.
DeviceProcessEvents | where DeviceName =~ '<source host>' | where Timestamp between (datetime('<burst start>') - 1h .. datetime('<burst end>') + 1h) | project Timestamp, FileName, ProcessCommandLine, InitiatingProcessFileName, AccountName | sort by Timestamp asc - On the target, open the
hs_err_pidlog. A crash in a Base64 or StubRoutines frame matches the reported flaw and should be treated as a possible exploitation attempt. A crash elsewhere is more likely unrelated. Also check for Java restarts, shells spawned after the burst, and new outbound connections. - A burst from an unfamiliar source followed by a crash is a probable attempt. A crash with no preceding burst is more likely a bug or a resource problem.
- If you cannot rule out success, preserve the
hs_errlog and a memory image before restarting anything, isolate the host, and rotate the secrets the JVM could read: database passwords, API keys, signing keys, and client secrets. Rebuild the host or container if code execution is confirmed or cannot be ruled out.
Mitigate, verify and close the gaps
Mitigate
- Install your Java vendor's update as soon as it names this CVE, restart every JVM, and rebuild container images. A running process keeps the old runtime in memory until it restarts. Do not assume a build is fixed until the vendor's advisory says so.
- Where you cannot update yet, the interim option is
-XX:-UseBASE64Intrinsics, which makes Java use its plain Base64 decoder. It costs a little decoding speed, and it only helps if the public reports about the Base64 decoder are right, which vendors have not confirmed. Test it, restart the service, and treat it as a stopgap. - Do not use
-XX:DisableIntrinsic=_base64_decodeBlockon its own. Without-XX:+UnlockDiagnosticVMOptions, the JVM refuses to start.
Verify
The mitigation only takes effect after a restart, and the flag shows in the new process's command line:
DeviceProcessEvents
| where Timestamp > ago(1d) and FileName in~ ('java.exe','javaw.exe')
| extend Mitigated = ProcessCommandLine has 'UseBASE64Intrinsics'
| summarize by DeviceName, FolderPath, MitigatedTo confirm a host actually meets the reported conditions, check the JVM's own flags. The host matches if UseAVX is 3 and UseBASE64Intrinsics is true:
Windows: java -XX:+PrintFlagsFinal -version | findstr /i "UseAVX UseBASE64Intrinsics" Linux: java -XX:+PrintFlagsFinal -version 2>/dev/null | grep -E ' (UseAVX|UseBASE64Intrinsics) ' Running JVM: jcmd <pid> VM.flags
Use the exact java.exe path from your inventory, since the Java on the PATH is often not the one a service loaded.
Gaps worth closing
- No HTTP-level visibility. Defender cannot see request headers. If a reverse proxy, WAF or application log sits in front of a service, log the shape of the Authorization header (length and last character, never the credential) so you can match the reported pattern: a Base64-alphabet token of 32 or more characters, ending in
=, with a length that is not a multiple of 4. - Bundled runtimes and containers. Inventory tools miss runtimes shipped inside applications, and a running container keeps its old runtime until it is rebuilt. Ask product vendors for updated runtimes.
- Baselines age. Review the drift baseline now and then, and revisit the burst threshold after a few weeks of data.
- Details will change. Treat the version range and workaround as provisional until vendors and researchers publish. Re-run the in-range query when they do.
The exploit leaves nothing to see, so hunt the traces around it: know where Java runs, watch who can reach it, and patch the hosts that matter first.