Back to Intelligence

SAP 'OVERPASS' Kernel Vulnerability: Maximum-Severity Memory Corruption — Detection and Remediation Guide

SA
Security Arsenal Team
September 8, 2026
12 min read

SAP's September 2026 Security Patch Day delivered 20 corrections across its product portfolio — but one towers above the rest: a maximum-severity (CVSS 10-class) memory corruption vulnerability in the SAP Kernel, which SAP has internally labeled 'OVERPASS'. If you run SAP, this is not an item for next quarter's maintenance window. The SAP Kernel is the shared runtime foundation of virtually every ABAP-based product SAP ships — S/4HANA, ECC, BW/4HANA, Solution Manager, and the NetWeaver stack all sit on top of it. A flaw in the kernel is a flaw in the entire estate.

Maximum-severity kernel flaws in SAP are rare, and when they appear they historically attract both criminal and state-aligned attention. SAP systems hold the financial ledgers, HR records, supplier master data, and production schedules of the world's largest organizations. Defenders need to treat this as a Priority-1 patch event.

Technical Analysis

What Is Affected

The vulnerable component is the SAP Kernel itself — the compiled C/C++ runtime that implements the dispatcher (disp+work), work processes, the SAP Gateway (gwrd/gateway reader), the Message Server, and sapstartsrv. Because the kernel is shared across products, the affected scope effectively includes:

  • SAP S/4HANA (on-premise ABAP application servers)
  • SAP ECC / SAP Business Suite on NetWeaver AS ABAP
  • SAP BW, BW/4HANA
  • SAP Solution Manager (a frequent initial-access pivot point)
  • Any standalone Gateway or Message Server installations, including internet-adjacent Web Dispatchers built on the same kernel release line

The kernel ships on Linux, Windows, AIX, and other UNIX platforms — all OS platforms running an unpatched kernel patch level are affected. The fix is delivered as an updated kernel patch (disp+work package) in the September 2026 kernel release line, per SAP's Security Patch Day notes.

How the Vulnerability Works (Defender's View)

Memory corruption in the SAP Kernel classically means one of three attack surfaces, and OVERPASS sits in kernel-level code reachable through the kernel's own network services:

  1. The dispatcher / work process protocol (ports 32xx) — attacker-controlled input parsed by disp+work reaches a memory-unsafe code path, enabling corruption of heap or stack structures.
  2. The SAP Gateway (ports 33xx) — the gateway processes RFC and CPI-C traffic and has been the target of numerous memory-safety bugs precisely because it parses complex binary protocols.
  3. The Message Server (ports 36xx/81xx) — load-balancing and internal registration traffic.

A maximum-severity rating on kernel code implies remote exploitation without valid SAP credentials — network-level reachability to a kernel service is the primary precondition. Successful exploitation of this bug class yields code execution in the context of the kernel process — typically the <sid>adm operating-system user on Linux/UNIX, or the SAP service account on Windows. From there, an attacker owns the application server: they can read the SAP secure store, extract stored credentials, manipulate business transactions (payment runs, purchase orders, payroll), and pivot into the database tier.

Exploitation Status

At publication, SAP has not reported confirmed in-the-wild exploitation of OVERPASS, and no public proof-of-concept has been observed. That status should be treated as temporary. Historically, maximum-severity SAP flaws are reverse-engineered from patched binaries within days of release — the kernel patch delta between the vulnerable and fixed disp+work packages gives researchers a direct map to the vulnerable code path. Assume a working exploit will exist before your next maintenance window. Internet-exposed Gateways, Message Servers, or Web Dispatchers are at acute risk.

Detection & Response

Why Detection Is Hard — and Where to Look

You cannot signature the overflow itself; the payload rides inside legitimate SAP binary protocols. What you can detect is the post-exploitation behavior: a kernel process doing things a kernel process never does. disp+work, gwrd, and sapstartsrv should never spawn shells, download files, or open reverse connections. That is your highest-fidelity signal.

Baseline your landscape now: know which processes each app server normally runs, which hosts talk to ports 32xx/33xx/36xx, and what <sid>adm normally executes. Every detection below keys on deviation from that baseline.

Sigma Rules

YAML
---
title: SAP Kernel Process Spawning Shell or Script Interpreter
id: 3f8a1c94-7b2e-4d61-a9f3-5c8e2b1d4a67
status: experimental
description: Detects SAP kernel processes (disp+work, gwrd, msg_server, sapstartsrv, sapwebdisp) spawning shells or script interpreters, consistent with post-exploitation activity following memory corruption in the SAP Kernel (OVERPASS).
references:
  - https://www.bleepingcomputer.com/news/security/sap-warns-of-maximum-severity-overpass-kernel-vulnerability/
  - https://attack.mitre.org/techniques/T1059/
author: Security Arsenal
date: 2026/09/09
tags:
  - attack.execution
  - attack.t1059
logsource:
  category: process_creation
  product: linux
detection:
  selection_parent:
    ParentImage|endswith:
      - '/disp+work'
      - '/gwrd'
      - '/msg_server'
      - '/sapstartsrv'
      - '/sapwebdisp'
  selection_child:
    Image|endswith:
      - '/sh'
      - '/bash'
      - '/dash'
      - '/zsh'
      - '/python'
      - '/python3'
      - '/perl'
      - '/curl'
      - '/wget'
      - '/nc'
      - '/ncat'
      - '/socat'
  condition: selection_parent and selection_child
falsepositives:
  - SAP start/stop scripts invoking shells via sapstartsrv during legitimate instance lifecycle events (review CommandLine for startsap/stopsap wrappers)
level: high
---
title: Windows SAP Kernel Process Spawning Command Shell
id: 8c2d5e71-4a9b-4f38-b6d2-1e7a9c3f5b28
status: experimental
description: Detects SAP kernel executables on Windows (disp+work.exe, gwrd.exe, msg_server.exe, sapstartsrv.exe) spawning cmd.exe, PowerShell, or download utilities, indicating possible post-exploitation of the SAP Kernel OVERPASS vulnerability.
references:
  - https://www.bleepingcomputer.com/news/security/sap-warns-of-maximum-severity-overpass-kernel-vulnerability/
  - https://attack.mitre.org/techniques/T1059/
author: Security Arsenal
date: 2026/09/09
tags:
  - attack.execution
  - attack.t1059.001
  - attack.t1059.003
logsource:
  category: process_creation
  product: windows
detection:
  selection_parent:
    ParentImage|endswith:
      - '\disp+work.exe'
      - '\gwrd.exe'
      - '\msg_server.exe'
      - '\sapstartsrv.exe'
      - '\sapwebdisp.exe'
  selection_child:
    Image|endswith:
      - '\cmd.exe'
      - '\powershell.exe'
      - '\pwsh.exe'
      - '\wscript.exe'
      - '\cscript.exe'
      - '\certutil.exe'
      - '\bitsadmin.exe'
  condition: selection_parent and selection_child
falsepositives:
  - Rare SAP administrative wrappers; validate against change records
level: high
---
title: Unexpected External Connection to SAP Gateway or Message Server Ports
id: 5b7e3a29-9d4c-4f18-a2e6-8c1b7d5f3e94
status: experimental
description: Detects network connections from non-trusted sources to SAP Gateway (33xx), Message Server (36xx), or dispatcher (32xx) ports, which are the likely ingress surface for the SAP Kernel OVERPASS memory corruption flaw.
references:
  - https://www.bleepingcomputer.com/news/security/sap-warns-of-maximum-severity-overpass-kernel-vulnerability/
  - https://attack.mitre.org/techniques/T1190/
author: Security Arsenal
date: 2026/09/09
tags:
  - attack.initial_access
  - attack.t1190
logsource:
  category: network_connection
detection:
  selection_ports:
    DestinationPort|startswith:
      - '32'
      - '33'
      - '36'
  filter_rfc1918:
    DestinationIp|startswith:
      - '10.'
      - '192.168.'
      - '172.16.'
      - '172.17.'
      - '172.18.'
      - '172.19.'
      - '172.2'
      - '172.30.'
      - '172.31.'
  condition: selection_ports and not filter_rfc1918
falsepositives:
  - Legitimate SAP router (saprouter) deployments bridging trusted external networks
  - Load balancer health checks from cloud public ranges
level: medium

Note on the network rule: port-prefix matching is intentionally broad because SAP instance numbers vary (3200–3299, 3300–3399, 3600–3699). Deploy it against your asset inventory — alert only on new source/destination pairs not in your known-baseline of legitimate SAP clients and interfaces.

KQL (Microsoft Sentinel / Defender)

This hunt assumes Syslog/CEF ingestion from SAP hosts and Defender for Endpoint on Windows app servers. It looks for kernel processes executing abnormal children and for crashes of kernel processes (a failed exploitation attempt of a memory corruption bug frequently crashes the service before the attacker gets the offsets right — crash telemetry is an early-warning tripwire):

KQL — Microsoft Sentinel / Defender
// Hunt 1: Abnormal child processes of SAP kernel binaries + kernel crash events
let sapKernelProcs = dynamic(["disp+work", "gwrd", "msg_server", "sapstartsrv", "sapwebdisp", "disp+work.exe", "gwrd.exe", "msg_server.exe", "sapstartsrv.exe", "sapwebdisp.exe"]);
let suspiciousChildren = dynamic(["sh", "bash", "dash", "python", "python3", "perl", "curl", "wget", "nc", "ncat", "socat", "cmd.exe", "powershell.exe", "pwsh.exe", "certutil.exe", "bitsadmin.exe"]);
let ProcEvents = union isfuzzy=true
    (DeviceProcessEvents
     | where InitiatingProcessFileName in~ (sapKernelProcs)
     | where FileName in~ (suspiciousChildren)
     | project TimeGenerated, Host = DeviceName, Parent = InitiatingProcessFileName, Child = FileName, Command = ProcessCommandLine, Account = AccountName, Source = "MDE"),
    (Syslog
     | where Facility =~ "user" or Facility =~ "auth" or SyslogMessage has_any (sapKernelProcs)
     | extend IsCrash = SyslogMessage has_any ("segmentation fault", "SIGSEGV", "core dumped", "signal 11")
     | where IsCrash
     | project TimeGenerated, Host = HostName, Parent = ProcessName, Child = "", Command = SyslogMessage, Account = "", Source = "Syslog-Crash");
ProcEvents
| summarize Events = count(), FirstSeen = min(TimeGenerated), LastSeen = max(TimeGenerated) by Host, Parent, Child, Source
| order by FirstSeen asc;

// Hunt 2: New external sources reaching SAP kernel service ports via CEF/firewall logs
CommonSecurityLog
| where DestinationPort in (3200..3299) or DestinationPort in (3300..3399) or DestinationPort in (3600..3699)
| where ipv4_is_private(SourceIP) == false
| summarize Connections = count(), DestHosts = dcount(DestinationHost), FirstSeen = min(TimeGenerated), LastSeen = max(TimeGenerated) by SourceIP, DestinationIP, DestinationPort
| order by Connections desc;

Treat any disp+work or gwrd crash around this patch cycle as a potential exploitation attempt, not an operational nuisance. Capture the core dump and preserve it for forensic review before the kernel patch wipes the evidence.

Velociraptor VQL

This artifact hunts SAP application servers for kernel processes with suspicious children, unexpected listening ports, and recently modified kernel binaries (in case an attacker dropped a tampered disp+work after gaining code execution):

VQL — Velociraptor
-- Hunt SAP app servers: kernel process anomalies post-OVERPASS
LET procs = SELECT Pid, Ppid, Name, CommandLine, Exe, Username, CreateTime
FROM pslist()
WHERE Name =~ '(?i)(disp\+work|gwrd|msg_server|sapstartsrv|sapwebdisp)'

LET suspicious_kids = SELECT Pid, Ppid, Name, CommandLine, Username, CreateTime
FROM pslist()
WHERE Name =~ '(?i)^(sh|bash|dash|python3?|perl|curl|wget|nc|ncat|socat|cmd\.exe|powershell\.exe|pwsh\.exe)$'

SELECT Pid, Name AS KernelProc, Username AS KernelUser, CommandLine AS KernelCmd,
       suspicious_kids.Name AS SuspiciousChild, suspicious_kids.CommandLine AS ChildCmd,
       suspicious_kids.Username AS ChildUser, suspicious_kids.CreateTime AS ChildStart
FROM procs
JOIN suspicious_kids ON procs.Pid = suspicious_kids.Ppid
VQL — Velociraptor
-- Enumerate listening SAP service ports and flag bindings on unexpected interfaces
SELECT Pid, Name, LocalAddress, LocalPort, RemoteAddress, RemotePort, Status
FROM netstat()
WHERE Status =~ 'LISTEN'
  AND (LocalPort >= 3200 AND LocalPort <= 3399 OR LocalPort >= 3600 AND LocalPort <= 3699)
  AND NOT LocalAddress =~ '^(127\.|::1)'
ORDER BY LocalPort
VQL — Velociraptor
-- Check kernel binary modification times against the last authorized patch deployment
SELECT FullPath, Size, Mtime, Ctime
FROM glob(globs='/usr/sap/*/D*/exe/disp+work')
ORDER BY Mtime DESC

Remediation Verification Script

Run this on each Linux/UNIX application server to inventory kernel patch levels and flag unpatched instances. Schedule it via your CMDB or Ansible until every system reports the September 2026 kernel level:

Bash / Shell
#!/bin/bash
# sap-kernel-inventory.sh — Inventory SAP Kernel patch levels for OVERPASS exposure
# Run as root or <sid>adm on each SAP application server

echo "=== SAP Kernel Inventory: $(hostname) — $(date -u) ==="

# Locate all disp+work binaries (one per instance)
for exe in $(find /usr/sap -maxdepth 5 -name 'disp+work' -type f 2>/dev/null); do
    echo ""
    echo "[*] Kernel binary: $exe"
    # Extract kernel release and patch level
    version_out=$("$exe" -version 2>/dev/null | grep -Ei 'kernel release|patch number|patch level|compilation' )
    echo "$version_out"
    # Check binary modification time vs. last known good patch date
    echo "[*] Last modified: $(stat -c '%y' "$exe" 2>/dev/null || stat -f '%Sm' "$exe")"
done

echo ""
echo "=== Exposed kernel service listeners ==="
# Dispatcher 32xx, Gateway 33xx, Message Server 36xx — flag any on public interfaces
ss -tlnp 2>/dev/null | awk 'NR==1 || /:32[0-9][0-9]|:33[0-9][0-9]|:36[0-9][0-9]/'

echo ""
echo "=== Gateway ACL check (secinfo / reginfo) ==="
find /usr/sap -maxdepth 6 \( -name 'secinfo' -o -name 'reginfo' \) 2>/dev/null | while read -r acl; do
    echo "[*] $acl"
    # Flag dangerously permissive wildcard entries
    grep -nE 'PERMIT|HOST=\*|TP=\*' "$acl" | head -5
done

echo ""
echo "[!] ACTION: Compare patch levels above against the September 2026 SAP Security Notes."
echo "[!] Any kernel below the September 2026 patch level is exposed to OVERPASS."

Remediation

  1. Apply the September 2026 SAP Kernel patch immediately. Download the corrected disp+work package from the SAP Software Download Center and deploy per the associated SAP Security Note (check the September 2026 Security Patch Day page at support.sap.com/securitynotes and the BleepingComputer coverage at the source URL). A kernel patch requires an instance restart — schedule rolling restarts across dialog instances to preserve availability, but do not defer past days. This is a maximum-severity, remotely exploitable flaw.

  2. Patch in dependency order. Patch Solution Manager and any standalone Gateways/Web Dispatchers first — they are the most exposed and the most common pivot points — then production S/4HANA/ECC, then non-production. Do not leave DEV/QAS unpatched; attackers use unpatched lower environments to harvest credentials that work in production.

  3. Eliminate network exposure now, as a compensating control. Ports 32xx/33xx/36xx should never be reachable from the internet or from untrusted internal segments. Enforce ACLs at the firewall and at the SAP layer: tighten secinfo and reginfo gateway ACLs (remove HOST=* / TP=* wildcards), and ensure ms/acl_info restricts Message Server registration. If a gateway must serve external partners, route it through saprouter with hardened ACLs — never direct exposure.

  4. Harden kernel parameters. Verify gw/monitor is restricted, ms/monitor is disabled or restricted to admin, and ICF services you do not use are deactivated (transaction SICF). Every unnecessary listener is attack surface for the next kernel bug.

  5. Preserve forensic evidence before patching. If any disp+work or gwrd crashes appear in work process traces (dev_w*, dev_rd) around this window, capture core dumps, work process traces, and gateway logs (dev_rd, gateway logging) before the kernel update overwrites binaries and rotates logs. Failed exploitation attempts of a memory corruption bug look like service instability — assume breach and investigate if your crash telemetry spiked.

  6. Hunt retrospectively. Use the queries above against 30–90 days of telemetry. If OVERPASS was privately known before patch day — and maximum-severity findings often are — determined actors may have used it pre-disclosure.

  7. Monitor for post-patch reverse engineering. Expect exploit development against the patch delta. Keep your SAP-facing detections (child process, crash, and network anomalies) active permanently, not just this month.

Related Resources

Security Arsenal Penetration Testing Services AlertMonitor Platform Book a SOC Assessment vulnerability-management Intel Hub

Is your security operations ready?

Get a free SOC assessment or see how AlertMonitor cuts through alert noise with automated triage.