Skip to content

Threat Hunt Plan: ABB Ability OPTIMAX — Linux Kernel IPv4 Use-After-Free Remote Code Execution

Date: 2026-11-16 | Revision A

Hunt Objective and Scope

This hunt determines whether any ABB Ability OPTIMAX host running an affected version (6.4.x or 6.5.x) has been targeted by, or compromised through, the Linux-kernel IPv4 use-after-free vulnerability CVE-2026-98432. The flaw is a race condition in the kernel's handling of socket option memory (inet_opt / ireq_opt) during concurrent processing of retransmitted TCP connection requests or socket migrations; a remote, unauthenticated attacker who wins the race can execute arbitrary code at kernel privilege or crash the host. The hunt looks for three things: internet-facing exposure of affected OPTIMAX instances, network-level exploitation attempts (inbound IPv4 packets carrying IP options and anomalous retransmitted-SYN activity against OPTIMAX service ports), and post-exploitation effects on OPTIMAX hosts (kernel crashes, unexpected reboots, new processes or listeners, outbound C2, and lateral movement into adjacent OT/IT segments).

Environment in scope: all OPTIMAX 6.4.x/6.5.x hosts and the Linux appliance operating systems beneath them; the network segments those hosts sit in and the segments reachable from them; any perimeter where an OPTIMAX service could be internet-reachable. Because OPTIMAX runs on Linux, Windows Event Log collection is not applicable to the OPTIMAX host itself — Linux equivalents (auditd, journald/syslog, kernel ring buffer) are used instead; Windows collection applies only to Windows hosts reached by lateral movement from a compromised OPTIMAX host.

Time window: 2026-10-15 (earliest public awareness of the underlying kernel flaw / upstream fix) through the present. A root exploit was demonstrated on 2026-10-27 but was not released, and ABB reported no in-the-wild exploitation at advisory issuance (2026-11-11); exploitation before public disclosure by an opportunistic actor is implausible, so 2026-10-15 is the conservative start. The underlying defect predates this window (it dates to kernel 4.4), so state-based clauses below (a host that exists now, a listener that exists now, a current exposure) are re-queried as current state and are not bounded by the floor; event-based clauses (connections, process starts, crash log lines) are bounded by the data floor measured in the pre-flight.

Data-floor pre-flight (run before any event-based leg; record the oldest retained date per family, never a duration — a time-picker range is not retention):

#event_simpleName=/^(ProcessRollup2|NetworkConnectIP4|NetworkReceiveAcceptIP4|NetworkListenIP4|DnsRequest)$/ event_platform=Lin
| groupBy([#event_simpleName], function=min(@timestamp, as=oldest), limit=max)

 

The portion of the window earlier than the measured floor is Non-Conclusive for event-based clauses. For OT sensors, read each platform's own retention floor the same way (Tenable OT: Network > Packet Captures header shows the oldest capture; xDome Communication Analysis is capped at ~one month; confirm before quoting any negative).

Hypotheses and Hunt Procedures

Hypothesis 1: an external actor can reach an internet-facing instance of ABB Ability OPTIMAX, observable as an exposed service in passive internet-scan indices. Execute FIRST; its output scopes the internal hypotheses.

MITRE ATT&CK: Reconnaissance | T1595 Active Scanning (defender-side: passive discovery of what an actor would enumerate) · Initial Access | T1133 External Remote Services · ICS | T0883 Internet Accessible Device — an internet-reachable OPTIMAX host is directly exploitable by an unauthenticated remote attacker, so exposure is load-bearing for every downstream hypothesis.

Collection Queries — passive external indices (STRICTLY passive; never probe target infrastructure). Author unscoped first (proves the filter matches the product), then scope with the reader's own anchors:

Shodan:
http.title:"OPTIMAX"
http.html:"ABB Ability"
ssl.cert.subject.CN:"OPTIMAX"
// scope to your own space (one anchor per query — never AND two ownership anchors):
http.title:"OPTIMAX" net:<your_public_CIDR>
http.title:"OPTIMAX" org:"<Your Org Name>"
http.title:"OPTIMAX" asn:AS<your_ASN>

 

Censys (CenQL — host.services.* form; do NOT cross with the legacy services.* form):
host.services.software.product: "OPTIMAX"
host.services: (software.vendor: "ABB" and endpoints.http.html_title: "OPTIMAX")
// scope:
host.services.software.product: "OPTIMAX" and (host.autonomous_system.asn = <your_ASN> or host.ip: "<your_public_CIDR>")

 

Netlas:
http.title:"OPTIMAX" AND host:<your_public_CIDR>

 

// Cross-reference every exposed instance + version banner against the CISA Known Exploited Vulnerabilities catalog
// (https://www.cisa.gov/known-exploited-vulnerabilities-catalog) and CVE-2026-98432; a KEV match = presumptive
// actor-associated initial-access risk. Rank by ransomware ratio, not entry count.
→ Expected Positive shape: one or more hosts in your attributed address space returning an OPTIMAX UI title or ABB-signed certificate on a web/management port, with a version banner in the affected 6.4.x/6.5.x range.

 

API keys are referenced by environment-variable name only (SHODAN_API_KEY, CENSYS_API_SECRET, CENSYS_ORG_ID, NETLAS_API_KEY) — never inlined; a missing key is non-blocking (skip that engine and record the coverage gap).

Analysis Queries:

  • Attribute each hit with at least two independent ownership signals (PTR, ASN, certificate CN/SAN, WHOIS/RDAP, your own cloud/public-IP inventory) before reporting; shared hosting and CDN break attribution in both directions, and an unattributable hit is inconclusive, not negative.
  • Version-triage each banner against the affected 6.4.x/6.5.x range and record the index scan timestamp — a banner is stale in both directions, so an in-range banner is a prompt to verify current state and a fixed-version banner is not proof of safety if the scan predates the window.
  • Corroborate in at least two of Shodan / Censys / Netlas before escalating; absence from one index is only evidence that that index did not observe the host.
  • Historical pivot — establish whether the exposure spans the 2026-10-15-to-present window; continuous exposure across it means the host was presumptively enumerable throughout.
  • Pivot every confirmed-owned in-range instance in as a priority target for Hypotheses 2 and 3 and hunt it exhaustively; internet reachability of a host that serves an energy-management control environment is itself a finding under IEC 62443 and NERC CIP, independent of confirmed exploitation.

Control — unscoped population proves the filter matches the product: run each engine's unscoped query first; a non-zero global result with a zero scoped result is a real Negative for your space, while a zero unscoped result means the filter string is wrong (silent false zero), not that nothing is exposed.

Verdict criteria: Positive — at least one two-engine-corroborated, two-anchor-attributed host in your address space exposes an affected-range OPTIMAX service; Negative — the product filter returns hosts globally (unscoped control non-zero) but none attributable to your space across the window; Non-Conclusive — only one engine observed the host, attribution has fewer than two anchors, or no API key was available for the corroborating engine; missing an authoritative public-IP/cloud inventory prevents determining whether an exposed host is yours.

Hypothesis 2: a remote attacker is attempting to trigger the use-after-free by sending crafted IPv4 traffic to an OPTIMAX host, observable as inbound IPv4 packets carrying IP options and as anomalous retransmitted-connection activity against OPTIMAX service ports in packet capture and OT flow telemetry.

MITRE ATT&CK: Initial Access | T1190 Exploit Public-Facing Application | the exploit is delivered as crafted TCP/IPv4 connection traffic to a network-reachable service, so the attempt is observable at the packet layer before any host effect.

Collection Queries:

CrowdStrike Falcon LogScale (CQL) — inbound connections accepted by the OPTIMAX host (attacker -> host is NetworkReceiveAcceptIP4; LocalPort is the service reached, RemoteAddressIP4 is the peer). CQL has no IP-header/option visibility, so it baselines WHO is connecting, not the malformed-packet detail — the packet-level detection is the PCAP/OT leg below:

#event_simpleName=NetworkReceiveAcceptIP4 event_platform=Lin
| cidr(LocalAddressIP4, subnet=["10.20.0.0/16"]) // replace with your OPTIMAX management CIDR
| groupBy([LocalAddressIP4, LocalPort, RemoteAddressIP4], function=count(), limit=max)
| sort(_count, order=desc, limit=200)
→ Expected Positive shape: inbound accepted connections to an OPTIMAX host from an external or previously-unseen source address clustered around the exploitation window.

 

BPF packet capture (VLAN-aware — in real OT exports every frame carried an 802.1Q tag and an untagged filter matched nothing; repeat the whole primitive in each branch). Capture IPv4 packets carrying IP options (IHL > 5, i.e. the low nibble of byte 0 of the IP header > 5) to the OPTIMAX host, plus an unscoped control:

tcp​dump -i any -n -w optimax_ipopts_%Y%m%d_%H%M%S.pcap -G 3600 -C 100 '((ip[0] & 0x0f) > 5 and dst host 10.20.0.11) or (vlan and (ip[0] & 0x0f) > 5 and dst host 10.20.0.11)'

 

tcp​dump -i any -n -w ipopts_control_%Y%m%d_%H%M%S.pcap -G 3600 '((ip[0] & 0x0f) > 5) or (vlan and (ip[0] & 0x0f) > 5)'
→ Expected Positive shape: inbound TCP packets to the OPTIMAX host whose IP header length exceeds 20 bytes (options present) — the inet_opt code path the Red Hat RHSB-2026-016 workaround drops.

 

Datadog — OPTIMAX is an on-prem Linux appliance, so there are no cloud API (CloudTrail) events for this hypothesis; use host/syslog log search where the Datadog Agent is installed, and note the gap where it is not:

source:syslog host:optimax-* @network.destination.port:(443 OR 8443) @network.client.ip:*
// time range: 2026-10-15T00:00Z to current; Analytics: Table view, group by @network.client.ip; a positive term (@network.client.ip:*) is required so the query does not match every log lacking the attribute

 

Windows Event IDs: not applicable to the OPTIMAX host (Linux). On the Linux host, collect inbound-connection and firewall telemetry from journald/auditd instead:

journalctl -k --since "2026-10-15" | grep -iE 'martian|ip options|source route'
nft list ruleset | grep -A3 cve_2026_98432 // if the RHSB-2026-016 workaround is deployed, read its drop counter

 

OT/ICS data collection (cover every deployed OT monitoring platform; an OPTIMAX host is an OT asset and these sensors see its traffic even when no endpoint agent is present):

OT Data Collection: Claroty xDome — Network > Communication > Communication Analysis: Side A = external/IT network, Side B = the OPTIMAX host's network (scope by Network/VLAN, not by Category), Protocol/Port = the OPTIMAX service port, Time Frame = a custom range covering the window (Past Quarter silently exports 30 days; the Communication Analysis ceiling is ~one month, so segment and reconcile). Export CSV; correlate each peer to its device by asset_id, never by hostname.

OT Data Collection: Dragos Platform — Communications Hub: source-zone = external/IT AND dest-zone = the OPTIMAX zone AND protocol = TCP over the service port, across the window; pivot each flagged session to its asset record and export the event PCAP from SiteStore for offline analysis.

OT Data Collection: Nozomi Guardian — run via the OpenAPI (GET /api/open/query/do?query=<N2QL>), scripted not clicked:

links | where to == "10.20.0.11" | where protocol == tcp | expand transport_protocols | where tcp_connection_attempts.total >= 1 | select from to tcp_connection_attempts.total tcp_handshaked_connections.total last_activity_time | sort dst_tcp_connection_attempts_total desc

 

OT Data Collection: Tenable OT — Events: filter to Intrusion Detection / network event categories touching the OPTIMAX asset over the window (POST /graphql eventAggregations); for each hit open Rule Details for the Suricata rule that fired, and confirm eventType.canCapture before planning a per-event PCAP pull.

OT Data Collection: Armis Centrix — connections into the OPTIMAX host from external sources (ASQ; omit timeFrame — set the window in the UI picker):

in:ipConnections role:Server networkLocation:External protocol:TCP

 

OT Data Collection: Forescout eyeInspect — Command Center > Alerts filtered to the hunt window and the OPTIMAX host (GET /api/v1/alerts with dst_ip and start_timestamp/end_timestamp); read sensor health first (an unhealthy sensor or stopped module makes any negative Non-Conclusive) and retrieve the per-alert PCAP where sensor capture is enabled.

Analysis Queries:

Wireshark / tshark — confirm IP options on the captured frames and read the specific option type (source-route options are the classic abuse of this path); tls.record.version is unreliable for the negotiated version, so judge the service, not the port:

tsh​ark -r optimax_ipopts_*.pcap -Y "ip.hdr_len > 20 && ip.dst == 10.20.0.11" -T fields -e frame.time -e ip.src -e ip.dst -e ip.opt.type -e tcp.flags
→ Expected Positive shape: frames to the OPTIMAX host with ip.hdr_len greater than 20 and an ip.opt.type present (e.g. 0x83/0x89 source routing, 0x07 record route), concentrated from one or a few sources.

 

CrowdStrike Falcon LogScale (CQL) — rate/rarity of inbound sources to the OPTIMAX service, rarest-first (a single new high-volume source is the exploitation-attempt shape):

#event_simpleName=NetworkReceiveAcceptIP4 event_platform=Lin
| cidr(LocalAddressIP4, subnet=["10.20.0.0/16"]) // your OPTIMAX management CIDR
| top([RemoteAddressIP4], limit=50)
→ Expected Positive shape: a source address with a sharp, out-of-baseline count of accepted connections to the OPTIMAX host in the window.

 

Datadog Log Analytics — Timeseries view, group by @network.client.ip, time range 2026-10-15T00:00Z to current; base query source:syslog host:optimax-* @network.client.ip:* — a sudden spike in distinct or repeated inbound sources is the attempt signal.

Control — family presence on the same family/window/scope: #event_simpleName=NetworkReceiveAcceptIP4 event_platform=Lin | head(1) proves the OPTIMAX host reports inbound-connection telemetry at all; pair the host-scoped BPF capture with the unscoped control capture above (a zero on the scoped capture is Negative only if the control is non-zero). An OPTIMAX appliance with no Falcon sensor has no CQL telemetry of its own — name that as a coverage gap and lean on the PCAP/OT legs.

Verdict criteria: Positive — inbound IPv4 packets carrying IP options to an OPTIMAX host (confirmed in PCAP/tshark) and/or an out-of-baseline inbound-source spike corroborated by an OT sensor; Negative — the IP-options control capture is non-zero yet no IP-options packet reached any OPTIMAX host and inbound-source rates stayed within baseline across the window; Non-Conclusive — capture did not run for the full window, the OPTIMAX host lacks an endpoint sensor, or an OT sensor was unhealthy; missing packet capture at the OPTIMAX segment prevents determining whether crafted IP-options traffic arrived.

Hypothesis 3: an attacker who won the race has executed code on, or crashed, an OPTIMAX host, observable as a kernel oops in the TCP/IPv4 path, an unexpected reboot, new processes or listeners, outbound C2, or lateral movement from the OPTIMAX host into adjacent segments.

MITRE ATT&CK: Execution | T1203 Exploitation for Client Execution · Impact | T1499 Endpoint Denial of Service (the crash outcome) · Lateral Movement | T1021 Remote Services · Credential Access | T1003 OS Credential Dumping — kernel-level RCE gives the attacker arbitrary code and a pivot into the OT estate.

Collection Queries:

CrowdStrike Falcon LogScale (CQL) — unexpected child processes of the OPTIMAX service on the Linux host (reverse shells, interpreters, recon):

#event_simpleName=ProcessRollup2 event_platform=Lin
| cidr(LocalAddressIP4, subnet=["10.20.0.0/16"]) // your OPTIMAX management CIDR
| FileName = /^(bash|sh|dash|nc|ncat|python3?|perl|curl|wget)$/i
| groupBy([ComputerName, ParentBaseFileName, FileName, CommandLine], function=count(), limit=max)
→ Expected Positive shape: a shell or interpreter spawned by an OPTIMAX service process with a network-redirection or download command line, outside any maintenance activity.

 

CrowdStrike Falcon LogScale (CQL) — new outbound connections and new listeners originating FROM the OPTIMAX host (host-initiated is NetworkConnectIP4; a new service is NetworkListenIP4):

#event_simpleName=/^(NetworkConnectIP4|NetworkListenIP4)$/ event_platform=Lin
| cidr(LocalAddressIP4, subnet=["10.20.0.0/16"]) // your OPTIMAX management CIDR
| groupBy([#event_simpleName, LocalAddressIP4, RemoteAddressIP4, RemotePort, LocalPort], function=count(), limit=max)
→ Expected Positive shape: an outbound connection from the OPTIMAX host to an external/untrusted peer, or a new listening port, appearing after inbound IP-options traffic.

 

Linux host logs (the OPTIMAX host is Linux — kernel ring buffer, journald, auditd; Windows Event IDs apply only to Windows hosts reached laterally):

journalctl -k -b --since "2026-10-15" | grep -iE 'Oops|BUG: unable to handle|general protection fault|tcp_v4_rcv|inet_opt|use-after-free|kasan'
last -F reboot // unexpected reboots since the window start
ausearch -i -ts 10/15/2026 00:00:00 -k optimax_exec // if an auditd exec rule keyed 'optimax_exec' is in place

 

SNMP — detect an exploit-induced reboot of an OPTIMAX host that exposes an SNMP agent, and read the trap receiver:

snmpwalk -v3 -l authPriv -u <user> -a SHA-256 -A <authpass> -x AES-256 -X <privpass> 10.20.0.11 system
// baseline sysUpTime; a reset indicates an unexpected restart. Prefer SNMPv3 authPriv; treat any v1/v2c community access to an OT asset as a finding in its own right.
// At the trap receiver, filter the window for coldStart (OID 1.3.6.1.6.3.1.1.5.1) and warmStart (1.3.6.1.6.3.1.1.5.2) traps from the OPTIMAX host address range.

 

YARA — file-system scan of the OPTIMAX host for Linux post-exploitation artifacts (dropped tools, staged payloads, /proc credential dumps):

ya​ra -r rules/linux_post_exploitation.yar / >​>​ optimax_yara_disk_hits.txt

 

OT/ICS data collection — lateral movement FROM the OPTIMAX host into other zones:

OT Data Collection: Dragos Platform — Communications Hub: source-zone = the OPTIMAX zone AND dest-zone = any other OT/IT zone AND protocol IN [RDP, SSH, VNC, SMB] over the window; pivot each cross-zone session to its asset and event PCAP.

OT Data Collection: Nozomi Guardian — egress and remote-access from the OPTIMAX host:

links | where from == "10.20.0.11" | join nodes to ip | where joined_node_to_ip.is_public | select from to joined_node_to_ip.label protocol tcp_handshaked_connections.total | sort dst_tcp_handshaked_connections_total desc | head 25

 

Analysis Queries:

CrowdStrike Falcon LogScale (CQL) — DNS requests from the OPTIMAX host to rare or algorithmically-generated domains (DnsRequest lacks process context; join ProcessRollup2 via ContextProcessId with aid to attribute, and remember DnsRequest resolves to IP4Records/IP6Records, not RemoteAddressIP4):

#event_simpleName=DnsRequest event_platform=Lin
| cidr(LocalAddressIP4, subnet=["10.20.0.0/16"]) // your OPTIMAX management CIDR
| groupBy([DomainName], function=count(), limit=max)
| sort(_count, order=asc, limit=50)
→ Expected Positive shape: a low-count, high-entropy domain resolved only by the OPTIMAX host during the window — candidate C2 beaconing.

 

Windows Event Log PowerShell (applies only to a Windows host reached by lateral movement from the OPTIMAX host — logon hunting around the window):

Get-WinEvent -FilterHashtable @{LogName='Security';Id=4624,4625;StartTime='2026-10-15'} | Where-Object { $_.Properties[18].Value -like '10.20.0.11' } | Select-Object TimeCreated,Id,@{n='SrcIP';e={$_.Properties[18].Value}},@{n='User';e={$_.Properties[5].Value}} | Export-Csv optimax_lateral_logons.csv -NoTypeInformation

 

YARA — process-memory scan on the OPTIMAX host and on any laterally-reached Windows host (classic YARA takes the PID as the positional target; there is no -p PID flag — -p sets directory-scan threads). On CrowdStrike-managed hosts, Falcon RTR can execute YARA remotely:

ya​ra rules/linux_post_exploitation.yar <pid>​ // OPTIMAX host suspect process
ya​ra rules/credential_dump_tools.yar <pid>​ // laterally-reached Windows host; requires SeDebugPrivilege

 

Datadog — Live Process Monitoring (Infrastructure > Processes, not a log source) for shells under the OPTIMAX service user, with a log-search fallback where Live Process Monitoring is not enabled:

command:bash user:optimax
// Fallback log search: source:syslog host:optimax-* "/dev/tcp/" // time range: 2026-10-15T00:00Z to current

 

Datadog Monitor (one per hypothesis):

Type: Log Alert
Query: source:syslog host:optimax-* ("tcp_v4_rcv" OR "use-after-free" OR "/dev/tcp/")
Evaluation window: last 5 minutes
Alert condition: count > 0
Message: "ALERT: possible CVE-2026-98432 exploitation/crash on an OPTIMAX host — investigate immediately @oncall-ot-soc"
Prerequisites: Datadog Agent installed on the OPTIMAX host with syslog/journald log collection enabled
Create via: Monitors > New Monitor > Log Alert OR POST /api/v1/monitors

 

Control — field/family presence on the same scope: #event_simpleName=ProcessRollup2 event_platform=Lin | cidr(LocalAddressIP4, subnet=["10.20.0.0/16"]) | FileName=/./ | count() proves the OPTIMAX host reports process telemetry with a populated FileName (a family-presence control does not cover the FileName filter). For the kernel-log leg, confirm journald is persistent (Storage=persistent) — a volatile journal lost at the reboot the exploit caused turns a clean grep into a silent zero. For the OT legs, confirm sensor/collection health before any negative.

Verdict criteria: Positive — a kernel oops in the TCP/IPv4 path or an unexpected reboot on an OPTIMAX host, OR a new shell/listener/outbound-C2/lateral-movement artifact from an OPTIMAX host corroborated across two sources; Negative — process, network, kernel-log and OT telemetry all present (controls non-zero) and none of the above artifacts appear across the window; Non-Conclusive — the OPTIMAX host lacks an endpoint sensor, the journal was non-persistent, an OT sensor was unhealthy, or capture did not span the window; missing endpoint or kernel-log coverage on the OPTIMAX host prevents determining whether code executed.

Threat Actor Profile

No threat actor is attributed in the source material, and ABB reported no in-the-wild exploitation at advisory issuance. The realistic actor classes for a remote, unauthenticated, network-reachable kernel RCE are: (1) opportunistic/criminal actors who weaponize a publicly disclosed kernel flaw once a reliable exploit circulates — a root exploit was demonstrated on 2026-10-27 but not released, which lowers immediate mass-exploitation likelihood while raising it over time as independent exploit development catches up; (2) ransomware operators, for whom an internet-reachable host that bridges into an energy-management control environment is a high-value initial-access and lateral-movement foothold; and (3) a capable state-aligned actor interested in energy/decarbonization operations, for whom a kernel-level, unauthenticated foothold on an OT-adjacent host is attractive for pre-positioning. These are activity-class profiles, not attributions: no vendor cluster name or government attribution exists for CVE-2026-98432, so treat any future naming with the usual caveats — a vendor cluster name is not a government attribution, aliases are overlaps rather than identities, and the exposure/behavioral evidence from this hunt governs the verdict, not a presumed actor. The highest-probability path across all three classes is the same one this hunt measures: an internet-reachable or weakly-segmented OPTIMAX host reached directly over the network.

Data Sources Required

Network: full packet capture at the OPTIMAX host segment (for IP-options and retransmission detection — the determinative source for Hypothesis 2), firewall/NetFlow logs, and the nftables drop counter if the RHSB-2026-016 workaround is deployed. Endpoint: CrowdStrike Falcon telemetry on the OPTIMAX Linux host where the sensor is deployed (ProcessRollup2, NetworkReceiveAcceptIP4, NetworkConnectIP4, NetworkListenIP4, DnsRequest with event_platform=Lin), plus the host's own kernel ring buffer, journald/auditd, and reboot records; Windows Security Event Logs only on hosts reached by lateral movement. OT/ICS: the deployed OT monitoring platforms (Claroty xDome, Dragos, Nozomi Guardian, Tenable OT, Armis Centrix, Forescout eyeInspect), their flow records, per-alert PCAP where capture is enabled, and the SNMP trap receiver for coldStart/warmStart traps. Vendor/device: the OPTIMAX version inventory to identify 6.4.x/6.5.x hosts and confirm patch state. External attack surface: the passive internet-scan indices queried read-only (Shodan / Censys / Netlas), the CISA KEV catalog, and the organization's authoritative public-IP and cloud asset inventories — the last is required for attribution, and without it the exposure determination in Hypothesis 1 cannot be made.

Detection Signatures

SIGMA rule 1 — a shell or interpreter spawned by the OPTIMAX service process on Linux (post-exploitation execution):

title: OPTIMAX Service Spawning Shell or Interpreter (Possible CVE-2026-98432 Post-Exploitation)
id: 6f2a1b4c-9d3e-4a7f-8c21-0e5b7a9d4c13
status: experimental
description: Detects an OPTIMAX service process spawning a shell, netcat, or scripting interpreter, consistent with code execution following the kernel IPv4 use-after-free.
references:
- https://nvd.nist.gov/vuln/detail/CVE-2026-98432
author: 1898 & Co.
date: 2026-11-16
logsource:
product: linux
category: process_creation
detection:
selection:
ParentImage|contains: 'optimax'
Image|endswith:
- '/bash'
- '/sh'
- '/dash'
- '/nc'
- '/ncat'
- '/python3'
- '/perl'
condition: selection
falsepositives:
- Maintenance scripts and operator sessions launched through the OPTIMAX service account during an approved change window
level: high

 

SIGMA rule 2 — kernel oops/use-after-free in the TCP/IPv4 receive path (attempted or successful exploitation crash). The match is a regex over the kernel log message so it catches the oops header and the TCP/IPv4 symbol together:

title: Linux Kernel Oops in TCP IPv4 Path (Possible CVE-2026-98432 Trigger)
id: 2c8e5f10-7b4a-49d6-9f3c-1a6d8b2e4f90
status: experimental
description: Detects a kernel oops, page fault, or KASAN use-after-free report referencing the TCP IPv4 receive path or inet_opt handling on an OPTIMAX host.
references:
- https://access.redhat.com/security/vulnerabilities/RHSB-2026-016
author: 1898 & Co.
date: 2026-11-16
logsource:
product: linux
service: syslog
detection:
selection:
message|re: '(?i)(Oops|BUG: unable to handle|general protection fault|KASAN).*(tcp_v4_rcv|inet_opt|ireq_opt|use-after-free)'
condition: selection
falsepositives:
- Unrelated kernel faults in other subsystems that happen to co-occur with networking symbols in the same log line
level: critical

 

SIGMA rule 3 — new outbound connection from an OPTIMAX host to an external address (C2 / egress):

title: OPTIMAX Host Outbound Connection to External Address (Possible C2)
id: 9a4d7e62-3f18-4b0c-a5d9-2c7f1b6e8a05
status: experimental
description: Detects an OPTIMAX host initiating an outbound network connection to a non-RFC1918 destination, consistent with post-exploitation C2 or exfiltration.
references:
- https://nvd.nist.gov/vuln/detail/CVE-2026-98432
author: 1898 & Co.
date: 2026-11-16
logsource:
product: linux
category: network_connection
detection:
selection:
Initiated: 'true'
SourceHostname|contains: 'optimax'
filter_internal:
DestinationIp|cidr:
- '10.0.0.0/8'
- '172.16.0.0/12'
- '192.168.0.0/16'
condition: selection and not filter_internal
falsepositives:
- Sanctioned OPTIMAX cloud telemetry, licensing, or update endpoints — baseline and allowlist before enabling
level: high

 

Snort/Suricata rule 1 — inbound IPv4 packets carrying a loose-source-route IP option to an OPTIMAX host (the inet_opt code path; record-route 0x07 and strict-source-route can be added as sibling rules). An IP-options rule needs no decryption and fires on the packet header directly:

alert ip $EXTERNAL_NET any -> $OPTIMAX_HOSTS any (msg:"OT CVE-2026-98432 inbound IPv4 loose-source-route option to OPTIMAX host"; ipopts:lsrr; classtype:attempted-admin; reference:url,access.redhat.com/security/vulnerabilities/RHSB-2026-016; sid:2100001; rev:1;)

 

Snort/Suricata rule 2 — anomalous volume of TCP connection requests (repeated SYNs) to an OPTIMAX service port, the race precondition; detection_filter alerts only after the burst threshold so ordinary connections do not fire:

alert tcp $EXTERNAL_NET any -> $OPTIMAX_HOSTS [443,8443] (msg:"OT CVE-2026-98432 SYN burst to OPTIMAX service port (possible UAF race attempt)"; flags:S; detection_filter:track by_src, count 30, seconds 5; classtype:attempted-dos; reference:cve,2026-98432; sid:2100002; rev:1;)

 

YARA explanation (rule Linux_Post_Exploitation_Artifacts): this rule targets the disk and process-memory artifacts of a successful Linux foothold — reverse shells, in-memory stagers, and /proc-based credential theft (T1003.007) — since CVE-2026-98432 yields code execution on a Linux host and the advisory publishes no sample. The condition ORs independent artifact families so any one match fires, and each string is a concrete command/path form rather than a generic word to hold down false positives; the /proc/PID/mem read is anchored with a dump redirection so ordinary /proc monitoring does not match.

rule Linux_Post_Exploitation_Artifacts
{
meta:
description = "Linux reverse-shell, in-memory stager, and /proc credential-access artifacts following CVE-2026-98432 RCE"
author = "1898 & Co."
date = "2026-11-16"
reference = "https://nvd.nist.gov/vuln/detail/CVE-2026-98432"
strings:
$rev1 = "/dev/tcp/" ascii // bash /dev/tcp reverse shell
$rev2 = /bash\s+-i\s+>&\s+\/dev\/tcp\// ascii // interactive reverse shell one-liner
$rev3 = "python -c 'import socket,subprocess,os" ascii // python reverse-shell stager
$proc1 = /cat\s+\/proc\/[0-9]+\/mem/ ascii // /proc memory read (credential access)
$proc2 = "/proc/self/mem" ascii // self-mem write (in-memory patching)
$stager = "memfd_create" ascii // fileless ELF staging
condition:
any of them
}

 

YARA explanation (rule Credential_Dump_Tool_Memory_Artifacts): this standing rule covers Windows LSASS credential-dumping tooling that an attacker would run on a Windows host reached by lateral movement (T1021/T1003) from a compromised OPTIMAX host; it is retained here with that scoping because the OPTIMAX host itself is Linux. Each branch targets a distinct tool (mimikatz, WCE, gsecdump, comsvcs MiniDump) plus a catch-all pairing a memory-read API with lsass.exe and a tool indicator, so renamed binaries still match on behavior; the lsass.exe co-requirement on the catch-all holds down false positives from benign memory-API use.

rule Credential_Dump_Tool_Memory_Artifacts
{
meta:
description = "Windows LSASS credential-dumping tool artifacts on a host laterally reached from a compromised OPTIMAX host"
author = "1898 & Co."
date = "2026-11-16"
reference = "https://attack.mitre.org/techniques/T1003/"
strings:
$mk1 = "sekurlsa::logonpasswords" ascii wide nocase // mimikatz
$mk2 = "lsadump::sam" ascii wide nocase // mimikatz
$mk3 = "privilege::debug" ascii wide nocase // mimikatz
$mk4 = "mimikatz" ascii wide nocase // mimikatz name
$wce1 = "wce.exe" ascii wide nocase // Windows Credential Editor
$gs1 = "gsecdump" ascii wide nocase // gsecdump
$cs1 = "MiniDump" ascii wide nocase // comsvcs MiniDump
$api1 = "NtReadVirtualMemory" ascii wide // memory-read API (catch-all)
$api2 = "ReadProcessMemory" ascii wide // memory-read API (catch-all)
$lsass = "lsass.exe" ascii wide nocase // LSASS target
condition:
any of ($mk*) or $wce1 and $lsass or $gs1 or ($cs1 and $lsass) or (any of ($api*) and $lsass)
}

 

Indicators of Compromise

Network: inbound IPv4 packets to an OPTIMAX host whose IP header length exceeds 20 bytes (IP options present) — especially source-route (LSRR 0x83 / SSRR 0x89) and record-route (0x07) options; bursts of retransmitted TCP SYNs from one source to an OPTIMAX service port; new outbound connections from an OPTIMAX host to external or untrusted peers and low-count high-entropy DNS resolutions from that host. Host: a kernel oops / page fault / KASAN report on an OPTIMAX host referencing tcp_v4_rcv, inet_opt, ireq_opt, or use-after-free; an unexpected reboot (coldStart/warmStart SNMP trap, sysUpTime reset, reboot record) with no change-window justification; a shell or interpreter child of the OPTIMAX service process; a new listening port; Linux reverse-shell, memfd_create stager, or /proc/PID/mem dump artifacts. OT/operational: any cross-zone session (SSH/RDP/VNC/SMB) originating from an OPTIMAX host into another OT/IT zone after the exploitation window; the RHSB-2026-016 nftables drop counter incrementing (packets with IP options actually arriving). No attacker IPs, domains, or file hashes were published in the source material — these behavioral indicators, not atomic IoCs, are the basis of this hunt.

False Positive Baseline

1. Sanctioned OPTIMAX cloud telemetry, licensing, and software-update endpoints — the OPTIMAX host legitimately initiates outbound connections to these; baseline and allowlist them before treating any egress as C2.

2. Approved maintenance windows — operator sessions and update scripts launched through the OPTIMAX service account spawn shells and interpreters legitimately; correlate every process hit against the change calendar.

3. Network and vulnerability scanners (the organization's own and sanctioned third parties) generate inbound connection bursts and unusual TCP flags that resemble SYN-burst and option-probe signals; identify scanner source addresses and suppress them.

4. Legitimate use of IP options by specific network equipment or path-MTU/route-recording diagnostics — rare, but record-route and timestamp options can appear in sanctioned diagnostics; confirm the source before escalating an ip-options hit.

5. Planned reboots for patching or maintenance — a coldStart trap or sysUpTime reset during an approved window is expected; reconcile reboot records against the maintenance schedule.

6. EASM misattribution — a shared-hosting, CDN, or carrier address that resolves an OPTIMAX-like banner is not necessarily yours; an exposure hit without two independent ownership anchors is a false positive for your estate, not a finding (easm_pitfalls.md §7).

Escalation Criteria

1. Any confirmed inbound IPv4 IP-options packet (PCAP/tshark) reaching an OPTIMAX host from an external or untrusted source — engage IR to preserve capture and isolate the host.

2. Any kernel oops / page fault / KASAN report on an OPTIMAX host referencing tcp_v4_rcv / inet_opt / ireq_opt / use-after-free (SIGMA rule 2 fires) — treat as attempted or successful exploitation and escalate immediately.

3. An unexpected OPTIMAX-host reboot (coldStart/warmStart trap or sysUpTime reset) with no change-window justification, especially if preceded by inbound IP-options traffic.

4. Any YARA hit from rule Linux_Post_Exploitation_Artifacts on an OPTIMAX host disk scan or process-memory scan — a reverse shell, memfd stager, or /proc/PID/mem dump indicates an active foothold; isolate and begin forensic capture.

5. Any YARA hit from rule Credential_Dump_Tool_Memory_Artifacts on a Windows host reached by lateral movement from an OPTIMAX host — credential theft in progress; reset exposed credentials and expand the hunt to the broader domain.

6. Any cross-zone remote-access session (SSH/RDP/VNC/SMB) originating from an OPTIMAX host into another OT/IT zone within the window — presumptive lateral movement; open a case and contain.

7. A two-engine-corroborated, two-anchor-attributed internet-facing OPTIMAX instance in the affected range (Hypothesis 1 Positive), or a KEV match against an exposed instance — remove the exposure and hunt that host exhaustively before anything else.

Hunt Completion Criteria and Reporting

The hunt is complete when each hypothesis has been run across the full window with its controls, every OPTIMAX 6.4.x/6.5.x host has been scoped, and Hypothesis 1 has been executed first so its confirmed-exposed hosts have been fed as priority targets into Hypotheses 2 and 3. The report gives a verdict per hypothesis using that hypothesis's Verdict criteria — a residual finding in one leg does not downgrade another hypothesis's verdict. Make absence claims only from a single-predicate filter (filter for the artifact and count), never by reading a distribution table, and quote only queries whose LogScale status reads Done (a progressively-rendering aggregate looks final when it is partial — screenshots must include the status bar). Record every limitation with its direction: packet capture that did not span the window under-reports attempts; an OPTIMAX host without a Falcon sensor has no endpoint telemetry of its own; a non-persistent journal is lost at the reboot the exploit may have caused; an IDS sees only what the sensor can decode and only inbound where positioned; the xDome Communication Analysis ~one-month ceiling bounds any flow negative; an unhealthy OT sensor or stopped module makes any negative Non-Conclusive. Report any leg whose control was zero or not run as Non-Conclusive, naming the missing input, never as clean. For the EASM leg, record each hit's two ownership anchors, the corroborating engines, the scan timestamps, and the version triage, and recommend that the passive external-exposure sweep become a recurring control rather than a one-time check.

Advisory IoC Reference

IOC Type IOC
CVE CVE-2026-98432 | CVSS v3.1 9.8 / v4.0 9.2 | ABB Ability OPTIMAX 6.4.x, 6.5.x | Linux-kernel IPv4 use-after-free (inet_opt/ireq_opt); remote, unauthenticated TCP race -> RCE or crash; fixed in OS Patch don_osupdate_v6.4.1-261107 (6.4.x) and don_osupdate_v6.5.1-261106 (6.5.x)
Threat Actor None attributed in source material — monitor CISA advisories (https://www.cisa.gov/news-events/cybersecurity-advisories) and the NVD entry for CVE-2026-98432
Malware None published in source material — no exploit or implant family named; a root exploit was demonstrated but not released
Network IOC None published in source material — no attacker IPs, domains, or C2 observed; monitor the NVD entry (https://nvd.nist.gov/vuln/detail/CVE-2026-98432) and the Red Hat RHSB-2026-016 record for indicators
File IOC None published in source material — no exploit hashes available; patch/fixed-version identifiers (not indicators): don_osupdate_v6.4.1-261107, don_osupdate_v6.5.1-261106
Behavioral Inbound IPv4 packets carrying IP options (IP header length > 20 bytes / IHL > 5) to an OPTIMAX host — the vulnerable inet_opt code path; Red Hat RHSB-2026-016 workaround drops them (nft: ip protocol tcp ip hdrlength > 5 counter drop)
Behavioral Anomalous volume of retransmitted TCP connection requests (repeated SYNs) or socket-migration activity to an OPTIMAX service port — the race precondition
Behavioral Kernel oops / panic on an OPTIMAX host referencing the TCP/IPv4 receive path (tcp_v4_rcv, inet_opt) — a failed or successful exploit crash
Behavioral Unexpected reboot of an OPTIMAX host (SNMP coldStart trap OID 1.3.6.1.6.3.1.1.5.1 / sysUpTime reset) with no change-window justification
Behavioral New listening service or outbound connection originating FROM an OPTIMAX host to an untrusted/external peer following inbound IP-options traffic — post-exploitation foothold or C2
Behavioral Lateral movement (SSH/RDP/SMB) FROM an OPTIMAX host into other OT/IT segments after the exploitation window