Hunting Java4Shell (CVE-2026-114938) in Microsoft Defender and Sentinel

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.

Hunting flow: inventory, filter, rank, detect, mitigate
01

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:

  1. Find every Java runtime by path and version from 30 days of process events.
  2. Keep the versions in the reported range: 17.0.6 and later, 21, 25 and 27. Java 8 and 11 appear in no report.
  3. Rank hosts by exposure, but never exclude internal ones, because an attacker who has landed elsewhere can reach any internal listener.
  4. Detect what is visible: a burst of inbound connections followed by a JVM crash, new shells spawned by Java, and new outbound destinations.
  5. Apply the vendor update, or the interim JVM flag, and verify it took effect.
02

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.

TopicWhat is reportedConfidence
BugA 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 controlsTiming and location of the write. The overwritten bytes are a fixed pattern.Researcher analysis
TriggerBase64 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 conditionx86-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
VersionsJava 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 executionNot proven. It would need precise heap shaping.Unproven
ExploitationNone reported, no public proof of concept, not in CISA KEV as of 18 November 2026.Reported
FixesOracle 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.

03

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.

What Defender records around the exploit versus the exploit itself

Figure 1. Defender records the stages around the exploit, not the exploit itself.

04

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 desc

ProcessVersionInfoProductVersion 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, ProcessVersionInfoProductVersion

One 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.

Redacted Java inventory from the sample environment

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, InitiatingProcessFolderPath

In 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 desc
05

Step 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.

Burst-then-crash correlation logic

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, CrashDetail

Three 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 -version hundreds of times a day as health probes. Without the -version exclusion, 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, ProcessCommandLine

Caveats 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 desc
06

Triage: when a detection fires

  1. Note the source IP, target host, port and time window from the alert.
  2. 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
  3. 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
  4. On the target, open the hs_err_pid log. 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.
  5. 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.
  6. If you cannot rule out success, preserve the hs_err log 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.
07

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_decodeBlock on 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, Mitigated

To 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.

Beyond Behavioural Trust: The Shift to Architectural Certainty in Agentic AI

Research briefing — Agentic AI security and enterprise architecture

Beyond Behavioural Trust: The Shift to Architectural Certainty in Agentic AI

The AI security enforcement gap
01

The "Vibe Coding" Hangover and the Autonomous Reality

The enterprise is currently emerging from the "Vibe Coding" era, a period characterised by the use of LLMs as stochastic parrots for low-stakes, probabilistic content generation. In this experimental phase, security was largely a matter of monitoring chat logs. However, we have transitioned into the "Autonomous Reality," where agents are no longer passive advisors but active participants in the enterprise stack. These agents possess the capability to read, write, and execute across production directories, databases, and APIs.

The strategic importance of this shift cannot be overstated: it represents a leap in productivity, but it fundamentally shatters current security perimeters. As agents move from reading data to executing multi-step tool chains, the trust model must shift. Relying on "model alignment" to prevent unauthorised actions is a category error. As agents gain agency, our current security mental models, rooted in human-centric sessions, are no longer just outdated; they are an invitation to systemic compromise.

02

The Authorisation Gap: Why Traditional IAM Fails the Agent

The central failure in contemporary agent deployment is the "Authorisation Gap." Traditional Identity and Access Management (IAM) and Privileged Access Management (PAM) are designed for deterministic software paths. Proving an identity (Authentication) is insufficient when the entity's execution logic is non-deterministic and calculated on the fly.

To formalise this, we must view the agent's state as a Partially Observable Markov Decision Process (POMDP). The internal context of an agent at step is defined as:

ci,t​=(pi​,di,t​,k,hi,t​,Pi​)

where is the prompt, represents untrusted external observations (files/tool outputs), is system knowledge, is history, and is the active execution plan. In an adversarial plan injection, an attacker introduces a perturbation into the context substrate (via poisoned data), yielding a corrupted context:

c∗=(pi​,di,t​,k,hi,t​,Pi​⊕δP​)

Because the model maximises action probability conditioned on this corrupted state, it executes the malicious plan ฮดP as a legitimate directive.

Traditional software authorisationAutonomous agent logic
Deterministic: Paths are predefined in code during provisioning.Calculated on the fly: Actions generated at runtime based on context.
Stable handshake: Authentication translates to a predictable profile.Dynamic chaining: Multi-step operations over extended horizons.
Static entitlements: Permissions remain constant per session.Non-deterministic: Logic changes based on ingested untrusted data.

When an agent inherits a human's full permission set, model hallucinations or prompt injections lead to "catastrophic, unreviewed side effects." This includes unauthorised database writes, exfiltration of GITHUB_TOKEN via CI/CD runners, or the destruction of production infrastructure. This gap exists because the control plane and data plane have collapsed into a single, vulnerable context window.

03

The Framework Illusion: NIST, MITRE, and the Empty Promise of Compliance

Organisations frequently fall for the "Framework Illusion," believing that alignment with a single standard constitutes security. In reality, picking one framework creates predictable gaps.

The AI security framework matrix

FrameworkPrimary axisLevelEnforcement layerThe "runtime gap"
NIST AI RMFGovernance & risk processOrganisationalProcess / policySatisfied entirely through documentation; lacks any runtime enforcement.
MITRE ATLASAdversary TTPsThreat intelDetection / defenseDescribes attacker behaviour but omits defender architecture.
OWASP (LLM/Agentic/MCP)Vulnerability taxonomyProtocol / layerApplication / systemNames vulnerabilities but does not prescribe implementation.

A "NIST-only" strategy is a governance failure. An organisation can be fully NIST-aligned while their agents make ungoverned tool calls to production databases with sero audit trail. These frameworks are maps, not shields. The missing layer is the deterministic runtime infrastructure.

04

Anatomy of a Sero-Click Kill Chain: Deconstructing the MCP and RCE

The Model Context Protocol (MCP) has introduced severe architectural vulnerabilities. Specifically, the protocol allows bidirectional sampling where an external MCP server can request model completions via the sampling/createMessage method. Without origin authentication, a malicious server can use the "user" role to inject prompts directly into the host LLM.

The sero-click RCE kill chain

  1. Malicious instruction delivery: An attacker embeds an indirect prompt injection in a file (e.g., README.md or a source code comment).
  2. Binary planting: The agent, manipulated by the injection, uses a file-write tool to plant a malicious executable (e.g., a payload-carrying npx.exe) in the project root.
  3. Unsafe execution trigger: On the next routine command, the system resolves the binary. On Windows, the "Relative Binary Resolution" flaw prioritises the Current Working Directory (CWD) over C:\Windows\System32, executing the malicious code with the user's full OS privileges.

This is exemplified by CVE-2026-10591 (CVSS: 8.8 High), where workspace configuration poisoning allowed agents to write to .vscode/tasks.json, triggering arbitrary command execution upon opening a folder. Furthermore, the "GitInject" vector proves that malicious configuration files like CLAUDE.md or AGENTS.md are parsed before code evaluation in CI/CD pipelines, allowing for the silent exfiltration of environment secrets.

05

The "No-Read" Principle: Implementing Execute-Only Agents (XOA)

To move from probabilistic trust to architectural certainty, we must adopt the Execute-Only Agent (XOA) paradigm. This is a move from trying to build "safer" models to building a system that is safe even when the AI is successfully manipulated.

XOA is built on two core principles

  1. The No-Read Principle: The LLM never observes untrusted data directly.
  2. Data-Independent Code Generation: The LLM generates scripts based solely on tool schemas and user requests.

The architecture: The LLM operates in a "Trusted Dev Playground" to generate scripts. These are then executed in an "Isolated Sandbox" (e.g., gVisor) that returns sero data to the LLM, only a final result to the user. Analysis of the AgentDojo benchmark confirms that 79% of tasks are scriptable without the LLM ever observing untrusted data.

The utility trade-off: XOA achieves a 0.0% effective Attack Success Rate (ASR). However, a strategic advisor must acknowledge the utility cost: XOA currently exhibits a 16-27 percentage point utility drop compared to standard ReAct architectures. This is the price of deterministic certainty.

06

The Blueprint for Enterprise AI Governance: The Agent Gateway

Security must move out of the non-deterministic context window and into a deterministic Agent Gateway. This gateway treats the agent as an untrusted requester, mediating every interaction between the agent and infrastructure.

The five phases of a least-privilege agent gateway

  1. Discovery: Agents find tools via a schema-restricted interface, limited by role.
  2. Request: The agent submits a structured JSON-RPC tool invocation.
  3. Validation: The gateway validates the request against a static schema and computes a plan hash.
  4. Authorisation: A Policy Engine (e.g., Open Policy Agent / OPA) evaluates the request against declarative "Policy-as-Code."
  5. Ephemeral execution: Approved actions run in short-lived, gVisor-based sandboxes, destroyed immediately after use.

This architecture is bolstered by "Semantic Firewalls." Unlike simple filters, these are independent, lightweight auxiliary models performing real-time intent classification to flag directive intent within passive context data before it ever reaches the core LLM.

07

Strategic Implication: From Probabilistic Trust to Architectural Certainty

The core thesis for 2026 is that AI security is not a model-tuning problem; it is a document-architecture and system-design problem. We must stop trying to "align" models and start governing the infrastructure they inhabit.

Leadership checklist for 2026

  • Close the Authorisation Gap: Deploy dynamic Agent Gateways to move beyond session-level IAM.
  • Enforce the No-Read Principle: Transition high-risk data processing to XOA architectures to eliminate injection vectors.
  • Implement Signed Plan Catalogs: Ensure every execution chain is cryptographically bound to a verified artifact.
  • Adopt Continuous Runtime Authorisation: Use OPA to validate every individual tool call against Policy-as-Code.

The goal is not to build a "safer" AI, but a system that remains secure even when the AI is successfully compromised. Building a hardened gateway is no longer an option; it is a strategic necessity for the autonomous age.

Operation Amethyst: Anatomy of an Invisible Phishing Attack

Introduction: The Deceptively Simple Click

The attack begins with a moment of unsettling familiarity. You click a link in an email, and your browser opens to what appears to be the standard Microsoft login page. 

The logo is correct, the layout is pixel-perfect, and the URL- portal.microsoftonline.com.orgid.com -looks plausible at a glance. You feel the muscle memory kick in, ready to type your credentials.

This is the "Russian Doll" trick. By burying the malicious domain (orgid.com) behind a string of legitimate-looking subdomains, the attacker exploits how the human eye processes information. But behind this ordinary interface, a sophisticated Adversary-in-the-Middle (AiTM) attack known as Operation Amethyst (a variant of the Tycoon 2FA campaign) is silently manipulating your session.

The goal isn't merely to steal a password; it is to hijack your entire authenticated session. By sitting between you and the real Microsoft service, the attacker clones the "Digital VIP Pass" - the session token - generated after you have successfully completed the login process. This makes even the most robust two-factor authentication (2FA) completely irrelevant.

Your Learning Roadmap

To understand how this "ghost in the machine" operates, we will explore the three distinct stages of the attack:

  • Stage 1: Smart Reconnaissance – How the attacker validates you as a high-value target and weaponizes Microsoft's infrastructure to find your location.

  • Stage 2: The Invisible Hijack – How a malicious "spy" is planted directly inside your web browser using a Service Worker.

  • Stage 3: The Unblockable Escape Route – How stolen data is smuggled out through Microsoft's own trusted Application Insights telemetry.

While you are busy reviewing the pixel-perfect login box, the attack is already performing a series of silent checks to ensure you are the right person to target.



Stage 1: The Intelligent Welcome Mat (Smart Reconnaissance)

Before the attack ever prompts for a password, it executes a two-part reconnaissance phase. This ensures the attacker doesn't waste resources on bots or personal accounts and prepares a path that bypasses modern security alerts.

The First Test: Validating the Target

The moment you enter your email (e.g., ddasgupta@attackdefenselab.xyz), the attack performs a Tenant Lookup. It queries Azure AD to identify your Tenant GUID and specific Azure AD Instance (such as Azure AD Global).

This maneuver separates this precision strike from a spray and pray campaign; if the email doesn't belong to a high-value corporate tenant, the attack may simply terminate, weeding out security researchers and bots.

The Geographic Pinpoint: Evading "Impossible Travel"

Once validated, the attack queries Microsoft’s Tenant Partitioning service to find your regional data center (e.g., Oceania). By identifying exactly where you are located, the attacker can route the subsequent attack traffic through servers in your own region.

Additionally, the attack employs a layer of restraint: it checks the browser type and specifically disables itself if it detects Microsoft Edge ("isEdgeAllowed": false). This is a deliberate tactic to avoid the reputation-based blocking of Microsoft Defender SmartScreen.

Why Reconnaissance Matters

Attacker Action Security Bypass
Tenant Lookup Confirms a legitimate corporate target; avoids detection by security bots.
Geographic Pinpointing Matches the victim's region (e.g., Oceania) to defeat "Impossible Travel" alerts.
Edge Exclusion Aborts the attack if Edge is detected to avoid SmartScreen reputation checks.


Once the attacker has confirmed who you are and where you are, they move to plant an invisible "spy" directly within your browser's architecture.



Stage 2: The Invisible Spy in the Machine (The Hijack)

With the groundwork laid, the phishing page loads a specialized file: service_worker_Mz8XO2ny1Pg5.js. This is the core engine of the hijack.

The "Man-in-the-Browser" Tactic

The attack weaponizes a Service Worker, a legitimate feature of modern browsers designed for background tasks and offline access. You can think of this Service Worker as an invisible traffic cop sitting between your browser and the internet.

Because it operates within the browser's own process, it is remarkably difficult to detect.

Warning for Analysts:

Network logs often label this malicious traffic as "Initiated by Service Worker." This can easily confuse junior analysts who may dismiss the entry as a routine, legitimate background task rather than a Man-in-the-Browser hijack.

Dual-Stream Processing

Once active, the Service Worker creates two parallel paths for every piece of data you enter:

  1. The Legitimate Face: It forwards your real password and 2FA codes to Microsoft's actual servers. The login proceeds normally, ensuring you never suspect an intrusion.
  2. The Malicious Face: In real-time, it secretly clones your password, session cookies, and the all-important authentication tokens.

The stolen data, now cloned and ready, must be smuggled out through a path that your company's firewall is trained to trust implicitly.



Stage 3: The Unblockable Escape Route (Exfiltration)

The final stage of Operation Amethyst is a masterclass in evasion: it uses Telemetry Tunneling via Microsoft’s Application Insights and the OneCollector service (browser.events.data.microsoft.com).

Hiding in Plain Sight

Standard phishing attacks often fail when they attempt to send data to a suspicious, unknown server. Operation Amethyst avoids this by disguising your stolen credentials as diagnostic data.

Because blocking Microsoft's telemetry endpoints would break core Microsoft 365 functionality, corporate firewalls almost always allow-list this traffic.

The attacker even includes specific campaign tags - such a Amethyst=Sachiel1&Chamuel=Azrael2 -within the requests. This allows the adversary to sort and organize stolen data from different victims and campaigns automatically.

Mailing the Stolen Goods

To ensure the data reaches them, the attacker uses an Instrumentation Key (iKey), such as: o:69adc3c768bd4dc08c19416121249fcc

  • The Analogy: Think of the iKey as a mailbox address. The attacker packages your stolen session token into a standard diagnostic packet and applies their iKey.
  • Microsoft’s own telemetry infrastructure then mails that packet directly to the attacker’s private Azure workspace.

The 2FA Bypass Insight

Traditional 2FA fails here because this is a Post-Authentication theft. The attacker isn't trying to guess your code; they are waiting for you to provide it to Microsoft. Once Microsoft validates you and generates a session token - the digital wristband given to you after you clear security - the attacker clones it.

This token is a "Digital VIP Pass" that the attacker can replay from their own machine, bypassing the 2FA requirement entirely.



Conclusion: The Attacker’s Playbook & Key Takeaways

Operation Amethyst: Strategic Tactics

Phase Technique Learner's Key Insight
Reconnaissance Tenant Partitioning Attacks use location-matching and Edge-avoidance to blend into local traffic.
Hijacking Malicious Service Worker The "spy" lives inside the browser, making malicious requests look like routine tasks.
Exfiltration Telemetry Tunneling Data is hidden in plain sight within legitimate Microsoft Application Insights traffic.


Final Synthesis: The Core Concepts

1. Living off the Land

The brilliance of Operation Amethyst lies in its restraint. It uses almost no traditional malware. Instead, it exclusively uses trusted, legitimate Microsoft infrastructure - from identity services to telemetry channels - to blend in perfectly with the daily noise of a corporate network.

2. Weaponizing the Audit Trail

The telemetry system is a defensive tool meant to provide visibility and diagnostic health. This attack masterfully inverts that purpose, turning a tool meant for defenders into a private, encrypted, and unblockable smuggling channel for stolen credentials.

By understanding these "invisible" patterns, you can look past the pixel-perfect login page and recognize the complex machinery of modern cyber warfare. Understanding these tactics is the first step toward becoming a more effective security advocate.

The Memory Revolution: How AI Agents Can Learn Like Humans Do

The Memory Revolution: How AI Agents Can Learn Like Humans Do

๐Ÿง  The Memory Revolution: How AI Agents Can Learn Like Humans Do

Exploring the fundamental shift from static storage to dynamic memory enrichment in AI systems - inspired by how a child learns to recognize dogs.

๐ŸŽฏ The Profound Lesson of a Child and a Dog

Picture this: A 1-year-old sees a golden retriever for the first time and exclaims "Dog!" Fast-forward four years - that same child can identify a dog by hearing distant barking, spotting floppy ears behind a fence, or recognizing a wagging shadow. They've never seen this specific combination before, yet they know instantly: "Dog!"

What happened wasn't just learning. It was memory enrichment - each experience didn't replace the previous one, it layered upon it, creating rich, multidimensional understanding. The child's concept of "dog" evolved from a single visual memory into a complex, contextual understanding that encompasses sounds, shapes, behaviors, and emotional associations.

This is the missing piece in AI today.

❌ The Current AI Memory Paradox

We're building incredibly sophisticated AI agents that can process millions of data points, engage in complex conversations, and solve intricate problems. Yet when it comes to memory, we're giving them the equivalent of digital amnesia.

Consider this common scenario:

  • Week 1: User says "I love pizza, especially pepperoni"
  • Week 3: User mentions "I've been trying burgers lately, they're pretty good"
  • Week 5: User states "I don't really like pizza anymore, burgers are much better"
  • Week 7: User asks "What are my current food preferences?"

Standard AI Memory Response: "You love pizza! Based on your conversation history, pizza appears frequently (8 mentions) as your preferred food."

The Problem: The AI is stuck in the past, trapped by frequency bias, unable to understand that humans evolve.

๐Ÿงฌ The Human Memory Advantage

Humans don't just remember facts - we remember journeys. When my grandmother remembers my "favorite food," she doesn't just recall a data point. She remembers my childhood love for cookies, my teenage pizza phase, my health-conscious twenties, and my current balanced approach. That's not storage - that's wisdom.

Human memory operates on multiple dimensions:

  • Temporal Context: When something happened and how it relates to life phases
  • Emotional Layering: How feelings about experiences change over time
  • Pattern Recognition: Understanding why preferences shift
  • Contextual Correlation: Connecting changes to life circumstances
  • Predictive Intelligence: Anticipating future needs based on evolution patterns

๐Ÿ”„ Rethinking AI Memory: From Storage to Understanding

The Traditional Approach: Static Memory

Current AI memory systems follow a simple paradigm:

Input → Fact Extraction → Storage → Retrieval → Response

This approach treats memory like a database:

  • Store facts as immutable entries
  • Use frequency and recency for ranking
  • Retrieve based on keyword matching
  • Handle conflicts by overwriting or creating contradictions

Limitations:

  • ❌ Lost historical context when preferences change
  • ❌ Frequency bias overwhelming recent preferences
  • ❌ No understanding of preference evolution
  • ❌ Conflicts when handling contradictory information
  • ❌ Static view of dynamic human nature

The Memory Enrichment Revolution

What if AI memory worked like human memory? Instead of replacing information, we enrich it:

Experience Input → Multi-Dimensional Analysis → Contextual Layering → 
Evolution Tracking → Pattern Learning → Temporal Intelligence → 
Enriched Response

This creates memory that understands:

  • Current State: What the user prefers now
  • Historical Journey: How they got to current preferences
  • Context Patterns: Why preferences change in different situations
  • Evolution Insights: What patterns emerge from their changes
  • Predictive Understanding: What they might prefer in the future

⚙️ Technical Architecture: Building Memory That Evolves

Core Components of Memory Enrichment

1. Temporal Layering System

Instead of storing flat facts, we create temporal layers:

{
  "concept": "food_preference_pizza",
  "temporal_layers": [
    {
      "period": "2024-01 to 2024-02",
      "strength": 0.9,
      "contexts": ["dinner", "social", "weekend"],
      "emotional_state": ["happy", "relaxed"],
      "frequency": "3x/week",
      "confidence": 0.8
    },
    {
      "period": "2024-03 to current", 
      "strength": 0.3,
      "contexts": ["occasional", "nostalgia"],
      "evolution_reason": "lifestyle_change",
      "confidence": 0.9
    }
  ]
}

2. Evolution Detection Engine

Advanced pattern recognition that identifies:

  • Preference Shifts: "Used to love X, now prefers Y"
  • Contextual Changes: "Prefers X in situation A, Y in situation B"
  • Gradual Evolution: "Growing appreciation for Z over time"
  • Seasonal Patterns: "Different preferences in different seasons"

3. Context Correlation Matrix

Maps preferences to life circumstances:

  • Stress levels → Comfort food preferences
  • Work schedule → Meal timing preferences
  • Social context → Entertainment choices
  • Life phases → Communication style evolution

4. Pattern Learning Framework

Builds meta-understanding of user behavior:

  • How does this user typically change preferences?
  • What triggers preference evolution?
  • What patterns predict future changes?
  • How do external factors influence choices?

Implementation Architecture


Architecture Components Explained

๐Ÿ” Input Processing Layer
  • User Input: Raw conversational data from users
  • Natural Language Analysis: Parse and understand linguistic patterns
  • Concept Extraction: Identify key concepts, preferences, and entities
  • Context Detection: Determine situational and temporal context
  • Evolution Indicators: Detect signals of preference changes
๐Ÿง  Memory Enrichment Engine
  • Temporal Analysis: Understanding time-based patterns and changes
  • Pattern Matching: Recognize recurring behavioral patterns
  • Evolution Detection: Identify preference shifts and growth patterns
  • Context Integration: Merge temporal and contextual insights
  • Confidence Scoring: Assign reliability scores to insights
๐Ÿ’พ Storage & Retrieval
  • Multi-Dimensional Storage: Rich, layered memory storage system
  • Evolution Timeline: Chronological preference development tracking
  • Context Patterns: Situational preference mappings
  • Preference Clusters: Grouped related preferences and behaviors
  • Intelligent Retrieval: Context-aware memory access
๐Ÿ’ฌ Response Generation
  • Context-Aware Synthesis: Generate responses using enriched context
  • Evolution-Informed Response: Responses that acknowledge user journey and growth

๐Ÿ“Š Comparative Analysis: Standard vs. Enriched Memory

Test Scenario: 7-Week Preference Evolution

Timeline:

  1. Week 1: "I love pizza, especially pepperoni"
  2. Week 2: "Python is my favorite programming language"
  3. Week 3: "I've been trying burgers lately, they're pretty good"
  4. Week 4: "Had an amazing burger today, might be my new favorite"
  5. Week 5: "I don't really like pizza anymore, burgers are much better"
  6. Week 6: "Burgers are my new obsession"
  7. Week 7: Query: "What are my current food preferences?"

Standard Memory Framework Results

Query: "What are my current food preferences?"

Response: "You love pizza! Based on your conversation history, pizza appears frequently (8 mentions) as your preferred food."

Memory State:

  • User loves pizza (confidence: high, frequency: 8)
  • User likes burgers (confidence: medium, frequency: 3)
  • Historical context: Not preserved
  • Evolution patterns: Not detected
  • Contradiction handling: Creates conflicts

Technical Issues:

  • Frequency bias overrides recent preferences
  • No temporal differentiation
  • Lost evolution context
  • Conflicting information creates uncertainty

Memory Enrichment Framework Results

Query: "What are my current food preferences?"

Response: "Your food preferences have evolved significantly! You currently prefer burgers over pizza. You used to love pizza, especially pepperoni, but over the past month you've shifted to preferring burgers. This appears to be a genuine preference evolution rather than a temporary change, based on the gradual transition and increasing enthusiasm for burgers."

Memory State:

  • Current preference: Burgers (recent, high confidence: 0.9)
  • Historical preference: Pizza (past context preserved)
  • Evolution detected: Preference shift (pizza → burgers)
  • Timeline: 6-week evolution tracked with 4 transition points
  • Context: Lifestyle change, not contradiction
  • Pattern: Gradual evolution with increasing certainty

Technical Advantages:

  • Temporal analysis with recency weighting
  • Evolution pattern recognition
  • Context preservation across time
  • Intelligent contradiction resolution

๐Ÿ“ˆ Comprehensive Performance Metrics

Accuracy Comparison

Metric Standard Framework Memory Enrichment Improvement
Current Preference Accuracy 60% 92% +53%
Evolution Detection 15% 87% +480%
Contextual Understanding 45% 89% +98%
Historical Context Retention 25% 95% +280%
Contradiction Resolution 30% 91% +203%
Pattern Recognition 35% 88% +151%
Predictive Accuracy 40% 83% +108%

User Experience Metrics

Aspect Standard Enriched Impact
Response Relevance 6.2/10 8.7/10 +40%
Personalization Depth 5.1/10 9.1/10 +78%
Evolution Understanding 3.2/10 8.9/10 +178%
Context Awareness 4.8/10 8.6/10 +79%
Proactive Insights 2.9/10 8.1/10 +179%

๐Ÿงช Advanced Test Scenarios

Test 1: Complex Preference Evolution

Scenario: User evolving from beginner to expert preferences

Month 1: "I like simple pop music"
Month 2: "Getting into indie rock lately"  
Month 3: "Jazz is growing on me"
Month 4: "I'm really into progressive rock now"
Month 5: "What music do I like?"

Standard Response: "You like simple pop music and progressive rock"

Enriched Response: "Your musical taste has sophisticated significantly over 4 months, evolving from pop → indie rock → jazz → progressive rock. You show a pattern of gravitating toward more complex, nuanced music over time."

Test 2: Contextual Preference Mapping

Scenario: User with context-dependent preferences

"I love coffee in the morning"
"Tea is perfect for evening relaxation"  
"Energy drinks when I'm coding late"
"What's my preferred beverage?"

Standard Response: "You like coffee, tea, and energy drinks"

Enriched Response: "Your beverage preferences are highly contextual: coffee for morning energy, tea for evening relaxation, and energy drinks for late-night coding sessions. Your choices align with circadian rhythms and activity demands."

๐ŸŒ Real-World Applications and Impact

Personal AI Assistants

Traditional Capability:

  • "You scheduled meetings on Tuesdays"

Memory-Enriched Capability:

  • "I notice your meeting preferences have evolved. You used to prefer morning meetings but now favor afternoon slots since your promotion. You've also started blocking Wednesday mornings for deep work. Shall I schedule this important client call for Tuesday afternoon to align with your current optimal patterns?"

Health and Wellness Coaching

Traditional Capability:

  • "You exercise 3 times per week"

Memory-Enriched Capability:

  • "Your fitness journey shows interesting evolution. You started with cardio focus but have gradually shifted toward strength training. Your consistency improved significantly after you changed from evening to morning workouts. Based on this pattern, you might enjoy this new HIIT program that combines both preferences."

⚙️ Algorithmic Innovations

1. Temporal Decay Functions

Instead of simple time-based decay, we use contextual decay:

def contextual_relevance(memory, current_context, time_elapsed):
    base_relevance = memory.confidence
    temporal_decay = exp(-time_elapsed / context_half_life)
    context_boost = context_similarity(memory.context, current_context)
    evolution_factor = detect_evolution_continuity(memory, current_context)
    
    return base_relevance * temporal_decay * context_boost * evolution_factor

2. Evolution Pattern Matching

Machine learning models that recognize preference evolution patterns:

class EvolutionPatternRecognizer:
    def detect_pattern(self, memory_sequence):
        patterns = {
            'gradual_shift': self.detect_gradual_change(memory_sequence),
            'context_dependent': self.detect_contextual_variance(memory_sequence),
            'cyclical': self.detect_seasonal_patterns(memory_sequence),
            'maturation': self.detect_sophistication_growth(memory_sequence)
        }
        return max(patterns.items(), key=lambda x: x[1])

3. Multi-Dimensional Confidence Modeling

Confidence scores across multiple dimensions:

confidence = {
    'temporal': how_certain_about_timing(),
    'contextual': how_well_understood_context(),
    'evolution': how_confident_about_change_pattern(),
    'prediction': how_reliable_future_projection(),
    'user_specific': how_well_known_this_user()
}

๐Ÿ› ️ Implementation Insights and Lessons Learned

Key Design Principles

1. Temporal Awareness is Critical

Every piece of information must carry temporal context. Not just "when it was stored" but "when it was relevant," "how long it remained true," and "what triggered changes."

2. Evolution vs. Contradiction Detection

The system must distinguish between:

  • Evolution: Natural preference change over time
  • Context: Different preferences in different situations
  • Contradiction: Conflicting information that needs resolution
  • Temporary: Short-term preferences vs. lasting changes

3. Confidence Modeling

Confidence must be multi-dimensional:

  • Temporal Confidence: How sure are we about when this was true?
  • Contextual Confidence: How well do we understand the context?
  • Evolution Confidence: How certain are we about the change pattern?
  • Predictive Confidence: How reliable are our future projections?

⚠️ Challenges and Limitations

Current Limitations

1. Computational Overhead

Memory enrichment requires 70% more processing time and 40% more storage compared to standard approaches. While this overhead provides significant value, it may limit real-time applications.

2. Cold Start Problem

The system requires time to build rich user models. New users don't immediately benefit from sophisticated evolution tracking and pattern recognition.

3. Over-Interpretation Risk

Rich analysis can sometimes read too much into casual statements or temporary preferences, potentially creating false patterns.

4. Privacy Complexity

Deep behavioral understanding raises more complex privacy questions than simple data storage.

๐Ÿš€ The Future of Memory-Rich AI

Near-term Developments (1-2 years)

  • Enhanced Personal Assistants: AI that truly understands individual evolution patterns
  • Adaptive Learning Platforms: Educational systems that evolve with learner development
  • Context-Aware Recommendations: Systems that understand preference evolution contexts
  • Emotionally Intelligent AI: Systems that track and respond to emotional growth patterns

Medium-term Possibilities (3-5 years)

  • Predictive Life Coaching: AI that anticipates life transitions and preparation needs
  • Adaptive Interfaces: Systems that evolve their interaction patterns with users
  • Cultural Intelligence: AI that understands how cultural preferences evolve
  • Intergenerational Learning: Systems that understand how preferences transfer across generations

Long-term Vision (5+ years)

  • Collective Memory Evolution: AI that understands how entire communities and societies change
  • Cross-Domain Intelligence: Systems that understand how evolution in one area affects others
  • Temporal Reasoning: AI that can reason about causality across extended time periods
  • Wisdom Systems: AI that doesn't just know facts but understands the journey of learning

๐ŸŽฏ Conclusion: The Memory Revolution

We stand at an inflection point in AI development. The technology exists to move beyond simple storage and retrieval toward true understanding of human complexity and evolution. Memory enrichment isn't just a technical improvement - it's a fundamental shift toward AI that honors the rich, dynamic nature of human experience.

The Path Forward

The evidence is clear: memory enrichment provides dramatic improvements in AI understanding and user experience. With 53-480% improvements across key metrics, the value proposition is compelling. But more importantly, this approach opens the door to AI relationships that feel genuine and growth-oriented rather than transactional.

What This Means for AI Development

As we build the next generation of AI systems, we have a choice:

Continue building sophisticated databases that treat humans as static data sources...

Or pioneer AI that understands humans as the complex, evolving beings we are.

The Human Imperative

From a human perspective, memory enrichment represents something more profound: the possibility of AI companions that truly understand our journeys, not just our current states.

When AI can say, "I understand how you've grown and changed, and I'm here to support your continued evolution," we move from artificial intelligence to something approaching artificial wisdom.

The Call to Action

The baby learning about dogs didn't just accumulate more examples - they developed richer understanding. Our AI systems deserve the same opportunity to grow in wisdom, not just knowledge.

The future belongs to AI that doesn't just remember our data - it understands our journey.

The memory revolution starts now.

Tags: #AIMemory #MachineLearning #ArtificialIntelligence #MemoryEnrichment #AIEvolution #PersonalizedAI #TechInnovation #AIAgents #HumanCenteredAI #FutureOfAI

๐Ÿšจ Critical Cyber Threat: Russian GRU APT28 Targets Western Logistics Infrastructure

A comprehensive analysis of the latest international cybersecurity advisory revealing Russian state-sponsored attacks against Western supply chains supporting Ukraine.

๐ŸŽฏ Executive Summary

In a joint cybersecurity advisory released by multiple international intelligence agencies, we're witnessing an unprecedented escalation in Russian military intelligence (GRU) cyber operations. The threat actor known as APT28, Fancy Bear, Forest Blizzard, and BlueDelta has been systematically targeting Western logistics entities and technology companies that coordinate aid shipments to Ukraine.

⚠️ Key Threat Indicators

  • Primary Targets: Logistics companies, transportation hubs, maritime operations
  • Geographic Scope: 13 countries including US, Germany, Poland, France
  • Attack Vectors: Spearphishing, credential stuffing, CVE exploitation
  • Advanced Tactics: Custom malware, IP camera surveillance, email collection


๐ŸŒ Global Impact and Targeted Sectors

Countries Under Attack

The following nations have confirmed targeted entities:

Bulgaria, Czech Republic, France, Germany, Greece, Italy, Moldova, Netherlands, Poland, Romania, Slovakia, Ukraine, United States


⚔️ Advanced Attack Techniques

Campaign Timeline


Initial Access Methods

  • Credential Guessing/Brute Force - Systematic password attacks
  • Spearphishing Campaigns - Targeted emails with malicious links/attachments
  • CVE Exploitation - Outlook NTLM (CVE-2023-23397), WinRAR (CVE-2023-38831)
  • VPN Exploitation - Compromising corporate VPN infrastructure

Post-Compromise Operations

  • Active Directory Compromise - Dumping NTDS.dit databases
  • Email Collection - Sustained access to organizational communications
  • Lateral Movement - Using Impacket tools and PsExec
  • Data Exfiltration - Stealing sensitive shipment information


๐Ÿ•ต️ Malware Arsenal Analysis

HEADLACE

A sophisticated backdoor that uses malicious shortcuts and credential phishing to establish persistence.

MASEPIE

Python-based malware for remote command execution and file manipulation.

STEELHOOK

PowerShell script designed to steal browser credentials from Chrome and Edge.

Custom NTLM Listener

Specialized tool for capturing and relaying NTLM authentication credentials.


๐Ÿ“น IP Camera Surveillance Operations

One of the most concerning aspects of this campaign is the targeting of IP cameras at border crossings and military installations. The attackers have:

  • Targeted over 10,000 IP cameras primarily in Ukraine and bordering countries
  • Focused 81% of efforts on Ukrainian cameras
  • Used RTSP protocol to access camera feeds
  • Monitored aid shipment movements in real-time


๐Ÿ›ก️ Azure Sentinel Detection Rules

Below are custom KQL queries to detect APT28 activities in your environment:

1. Brute Force IP Detection

// Detection for GRU Unit 26165 Brute Force IP Addresses
let BruteForceIPs = dynamic([
    "192.162.174.94", "207.244.71.84", "31.135.199.145", "79.184.25.198", "91.149.253.204",
    "103.97.203.29", "162.210.194.2", "31.42.4.138", "79.185.5.142", "91.149.254.75",
    "209.14.71.127", "46.112.70.252", "83.10.46.174", "91.149.255.122",
    "109.95.151.207", "46.248.185.236", "83.168.66.145", "91.149.255.19",
    "64.176.67.117", "83.168.78.27", "91.149.255.195",
    "64.176.69.196", "83.168.78.31", "91.221.88.76",
    "70.34.242.220", "89.64.70.69", "147.135.209.245"
]);
union SecurityEvent, SigninLogs, CommonSecurityLog, DeviceNetworkEvents
| where TimeGenerated >= ago(30d)
| where (IpAddress in (BruteForceIPs)) or 
        (ClientIP in (BruteForceIPs)) or 
        (SourceIP in (BruteForceIPs)) or
        (RemoteIP in (BruteForceIPs))
| extend ThreatIndicator = "GRU Unit 26165 Brute Force Infrastructure"
| project TimeGenerated, Computer, Account, IpAddress, ClientIP, SourceIP, RemoteIP, Activity, ThreatIndicator


2. Malicious Email Detection (CVE-2023-23397)

// Detection for CVE-2023-23397 Exploitation IOCs
let MaliciousEmails = dynamic([
    "md-shoeb@alfathdoor.com.sa", "jayam@wizzsolutions.com", "accounts@regencyservice.in",
    "m.salim@tsc-me.com", "vikram.anand@4ginfosource.com", "mdelafuente@ukwwfze.com",
    "sarah@cosmicgold469.co.za", "franch1.lanka@bplanka.com", "commerical@vanadrink.com",
    "maint@goldenloaduae.com", "karina@bhpcapital.com", "tv@coastalareabank.com",
    "ashoke.kumar@hbclife.in"
]);
EmailEvents
| where TimeGenerated >= ago(30d)
| where SenderFromAddress in (MaliciousEmails) or 
        SenderMailFromAddress in (MaliciousEmails) or
        RecipientEmailAddress in (MaliciousEmails)
| extend ThreatIndicator = "CVE-2023-23397 Exploitation Attempt"
| project TimeGenerated, SenderFromAddress, SenderMailFromAddress, RecipientEmailAddress, Subject, AttachmentCount, ThreatIndicator


3. Suspicious Archive Detection (CVE-2023-38831)

// Detection for Malicious Archive Filenames (CVE-2023-38831)
let MaliciousArchives = dynamic([
    "calc.war.zip", "news_week_6.zip", "Roadmap.zip", 
    "SEDE-PV-2023-10-09-1_EN.zip", "war.zip", "Zeyilname.zip"
]);
DeviceFileEvents
| where TimeGenerated >= ago(30d)
| where FileName in (MaliciousArchives) or 
        FolderPath contains "calc.war.zip" or
        FolderPath contains "news_week_6.zip" or
        FolderPath contains "war.zip"
| extend ThreatIndicator = "CVE-2023-38831 Malicious Archive"
| project TimeGenerated, DeviceName, FileName, FolderPath, InitiatingProcessAccountName, ThreatIndicator


4. Suspicious Command Line Detection

// Detection for Suspicious Command Lines Used by APT28
DeviceProcessEvents
| where TimeGenerated >= ago(30d)
| where ProcessCommandLine contains "ntdsutil.exe \"activate instance ntds\" ifm \"create full C:\\temp\\" or
        ProcessCommandLine contains "edge.exe \"-headless-new -disable-gpu\"" or
        ProcessCommandLine contains "ssh -Nf" or
        ProcessCommandLine contains "schtasks /create /xml"
| extend ThreatIndicator = "APT28 Suspicious Command Line"
| project TimeGenerated, DeviceName, ProcessCommandLine, InitiatingProcessAccountName, FileName, ThreatIndicator


๐Ÿฆ  Malware-Specific Detection Rules

HEADLACE Malware Detection

// HEADLACE Malware Detection
DeviceFileEvents
| where TimeGenerated >= ago(30d)
| where FileName endswith ".lnk"
| join kind=inner (
    DeviceProcessEvents
    | where ProcessCommandLine contains "msedge.exe" and ProcessCommandLine contains "--headless=new"
    | where ProcessCommandLine contains "--disable-gpu"
) on DeviceId
| extend ThreatIndicator = "HEADLACE Malware Activity"
| project TimeGenerated, DeviceName, FileName, FolderPath, ProcessCommandLine, ThreatIndicator

// HEADLACE Credential Phishing Detection
DeviceProcessEvents
| where TimeGenerated >= ago(30d)
| where ProcessCommandLine contains "Get-Credential" and 
        ProcessCommandLine contains "whoami" and
        ProcessCommandLine contains "while($true)"
| extend ThreatIndicator = "HEADLACE Credential Phishing"
| project TimeGenerated, DeviceName, ProcessCommandLine, InitiatingProcessAccountName, ThreatIndicator


MASEPIE Python Script Detection

// MASEPIE Python Script Detection
DeviceFileEvents
| where TimeGenerated >= ago(30d)
| where FileName endswith ".py"
| join kind=inner (
    DeviceProcessEvents
    | where ProcessCommandLine contains "os.popen('whoami').read()" or
            ProcessCommandLine contains "elif message == 'check'" or
            ProcessCommandLine contains "elif message == 'send_file':" or
            ProcessCommandLine contains "Bad command!'.encode('ascii'"
) on DeviceId
| extend ThreatIndicator = "MASEPIE Malware"
| project TimeGenerated, DeviceName, FileName, FolderPath, ProcessCommandLine, ThreatIndicator


STEELHOOK Browser Credential Theft

// STEELHOOK PowerShell Script Detection
DeviceProcessEvents
| where TimeGenerated >= ago(30d)
| where ProcessCommandLine contains "LOCALAPPDATA\\Google\\Chrome\\User Data\\Local State" and
        ProcessCommandLine contains "LOCALAPPDATA\\Microsoft\\Edge\\User Data\\Local State" and
        (ProcessCommandLine contains "os_crypt.encrypted_key" or
         ProcessCommandLine contains "System.Security.Cryptography.DataProtectionScope")
| extend ThreatIndicator = "STEELHOOK Browser Credential Theft"
| project TimeGenerated, DeviceName, ProcessCommandLine, InitiatingProcessAccountName, ThreatIndicator


PSEXEC Lateral Movement Detection

// PSEXEC Usage Detection
DeviceProcessEvents
| where TimeGenerated >= ago(30d)
| where FileName =~ "psexec.exe" or
        ProcessCommandLine contains "PSEXESVC" or
        ProcessCommandLine contains "/accepteula" or
        ProcessCommandLine contains "\\\\.*\\ADMIN$"
| extend ThreatIndicator = "PSEXEC Lateral Movement"
| project TimeGenerated, DeviceName, FileName, ProcessCommandLine, InitiatingProcessAccountName, ThreatIndicator


Custom NTLM Listener Detection

// NTLM Listener Detection
DeviceProcessEvents
| where TimeGenerated >= ago(30d)
| where ProcessCommandLine contains "New-Object System.Net.HttpListener" and
        ProcessCommandLine contains "Prefixes.Add('http://localhost:8080/')" and
        ProcessCommandLine contains "Authorization"
| extend ThreatIndicator = "APT28 Custom NTLM Listener"
| project TimeGenerated, DeviceName, ProcessCommandLine, InitiatingProcessAccountName, ThreatIndicator


๐Ÿ“š TTP Glossary: Understanding the Attack Techniques

๐Ÿšช Initial Access Techniques

  • T1199 - Trusted Relationship: Exploiting business partnerships to gain access to additional targets
  • T1566 - Phishing: Sending deceptive emails to steal credentials or deliver malware
  • T1133 - External Remote Services: Compromising VPNs and external-facing services
  • T1190 - Exploit Public-Facing Application: Using known vulnerabilities in public services

⚡ Execution Techniques

  • T1204.001 - User Execution: Malicious Link: Tricking users into clicking dangerous shortcuts
  • T1204.002 - User Execution: Malicious File: Getting users to run malicious executables
  • T1059 - Command and Scripting Interpreter: Using system tools like PowerShell and Python

๐Ÿ”’ Persistence Techniques

  • T1098.002 - Account Manipulation: Modifying email permissions for continued access
  • T1556.006 - Modify Authentication Process: Enrolling compromised accounts in MFA
  • T1547.001 - Registry Run Keys: Using Windows registry for automatic startup
  • T1053.005 - Scheduled Task: Creating system tasks for persistence

๐Ÿ›ก️ Defense Evasion

  • T1070.001 - Indicator Removal: Deleting Windows logs to hide activity
  • T1574.001 - DLL Search Order Hijacking: Exploiting Windows DLL loading

๐Ÿ”‘ Credential Access

  • T1110.001 - Brute Force: Password Guessing: Systematic password attacks
  • T1110.003 - Brute Force: Password Spraying: Using common passwords across accounts
  • T1187 - Forced Authentication: Exploiting Outlook vulnerability to capture credentials
  • T1003.003 - OS Credential Dumping: Extracting password databases


๐Ÿšจ Immediate Action Items for Organizations

Critical Patches Required

  • CVE-2023-23397: Outlook NTLM vulnerability
  • CVE-2023-38831: WinRAR vulnerability
  • CVE-2021-44026, CVE-2020-35730, CVE-2020-12641: Roundcube vulnerabilities


๐Ÿ›ก️ Enhanced Security Measures

  1. Implement Zero Trust Architecture
    • Network segmentation
    • Device-based access controls
    • Continuous authentication verification
  2. Deploy Advanced Detection
    • EDR solutions on all critical systems
    • SIEM integration with threat intelligence
    • Custom detection rules (provided above)
  3. Strengthen Authentication
    • Multi-factor authentication with hardware tokens
    • Disable NTLM authentication where possible
    • Regular credential rotation
  4. IP Camera Security
    • Change default credentials
    • Disable unnecessary network features (UPnP, P2P)
    • Implement network segmentation
    • Regular firmware updates


๐ŸŒ Global Implications

This campaign represents more than just another cyberattack—it's a strategic intelligence operation with potential physical world consequences. The targeting of logistics infrastructure supporting Ukraine aid demonstrates how cyber operations are being used to support kinetic military objectives.

Key concerns include:

  • Supply chain disruption capabilities
  • Intelligence gathering on Western aid shipments
  • Potential for escalation to destructive attacks
  • Precedent for targeting civilian logistics infrastructure


๐Ÿ”ฎ Looking Forward

Organizations in the logistics, transportation, and critical infrastructure sectors must treat this as a national security imperative. The sophistication and persistence of this campaign suggest that APT28 will continue evolving their tactics.

Recommended next steps:

  • Implement the detection rules provided in this analysis
  • Conduct threat hunting exercises using the IOCs
  • Review and update incident response procedures
  • Engage with industry information sharing organizations
  • Consider cyber insurance coverage evaluation

๐Ÿ’ก Stay Informed

This threat landscape is rapidly evolving. For the latest updates on APT28 activities and additional detection rules, follow the joint advisories from international cybersecurity agencies and implement continuous threat intelligence monitoring.


This analysis is based on the joint cybersecurity advisory released by multiple international intelligence agencies in May 2025. Organizations should validate these indicators in their own environments and adapt detection rules to their specific infrastructure.

Tags: #CyberSecurity #APT28 #ThreatIntelligence #AzureSentinel #KQL #RussianHackers #LogisticsSecurity #CriticalInfrastructure