SolarWinds has released security updates addressing a high-severity vulnerability in Access Rights Manager (ARM), tracked as CVE-2026-28326 with a CVSS score of 8.8 out of 10.0. The flaw stems from a hard-coded cryptographic key embedded in the product — a weakness that, if successfully exploited, allows an unauthenticated remote attacker to execute code on the ARM server. The vulnerability affects all versions of Access Rights Manager 2026.2 and prior.
Let me be blunt: a hard-coded key enabling unauthenticated code execution in a product that sits at the heart of your identity and access governance is about as bad as it gets. ARM integrates directly with Active Directory, file servers, and Exchange. It typically runs with elevated service privileges and holds a map of who can access what across your environment. An attacker who lands code execution on the ARM host is one pivot away from domain dominance.
If your organization runs ARM, treat this as a priority-one patch event. Inventory every ARM deployment today, apply the vendor update, and hunt for signs of exploitation going back weeks — because if the key is hard-coded in the shipped binary, it has been recoverable by anyone with a copy of the software since release.
Technical Analysis
Affected Products and Versions
| Item | Detail |
|---|---|
| Product | SolarWinds Access Rights Manager (ARM) |
| Affected versions | 2026.2 and all prior versions |
| CVE | CVE-2026-28326 |
| CVSS | 8.8 (High) |
| Attack vector | Network-accessible ARM service, no authentication required |
| Root cause | Hard-coded cryptographic key in the product |
| Impact | Unauthenticated remote code execution |
How the Vulnerability Works (Defender's Perspective)
Hard-coded key flaws follow a depressingly predictable pattern, and this one is no exception. The ARM application ships with a static cryptographic key compiled into its binaries. That key is used to protect some sensitive operation — typically signing or encrypting tokens, validating serialized requests between components, or authenticating inter-service communication.
The defensive implications:
- The key is identical across all installations. Anyone who obtains a licensed copy, trial copy, or leaked installer of ARM 2026.2 or earlier can extract the key through static analysis of the binaries. There is no per-customer entropy.
- Possession of the key bypasses authentication. An attacker who can reach the ARM web interface or API endpoint can craft requests that the server trusts as legitimate — signed tokens, validly encrypted payloads, or properly "authenticated" sessions — because the material needed to forge trust ships with the product.
- The endpoint processes attacker-controlled input with service-level privileges. ARM services commonly run as a dedicated service account with rights into Active Directory. Code executed through this flaw inherits those privileges.
- No user interaction or stolen credentials are required. The "unauthenticated" designation is what pushes this into emergency-patch territory. Exposure of the ARM service to any network segment an attacker can reach — including via a phished workstation on a flat network — is sufficient.
Exploitation Status
At the time of the vendor advisory, this flaw has been publicly disclosed with the patch release. Historically, hard-coded key vulnerabilities in enterprise management software attract rapid reverse engineering: the patch diff itself tells researchers exactly where the key lived and how it was used. Assume working exploit code will exist within days of patch availability, if it does not already. Even absent confirmed in-the-wild exploitation at disclosure, the preconditions for mass exploitation (static key, unauthenticated vector, widely deployed enterprise product) are all present. Check CISA's Known Exploited Vulnerabilities catalog daily until your fleet is patched.
Detection & Response
Detection here focuses on the two most reliable post-exploitation observables: (1) the ARM service processes spawning unexpected child processes, and (2) anomalous network connections to the ARM server from sources that have no business talking to it. Pre-exploit detection of forged-key requests is not realistically achievable at the application layer without vendor telemetry, so concentrate on what execution looks like after the fact.
---
title: SolarWinds ARM Service Spawning Suspicious Child Processes
id: 3c8f2a41-7b19-4e5d-9a06-2f4c8d1e6b7a
status: experimental
description: Detects the SolarWinds Access Rights Manager service or web processes spawning command interpreters, scripting engines, or download utilities — consistent with post-exploitation following CVE-2026-28326 unauthenticated code execution.
references:
- https://thehackernews.com/2026/09/solarwinds-patches-arm-hard-coded-key.html
- https://attack.mitre.org/techniques/T1059/
author: Security Arsenal
date: 2026/09/15
tags:
- attack.execution
- attack.t1059
- attack.t1190
logsource:
category: process_creation
product: windows
detection:
selection_parent:
ParentImage|contains:
- '\SolarWinds\'
- 'w3wp.exe'
- '\ARM\'
selection_child:
Image|endswith:
- '\cmd.exe'
- '\powershell.exe'
- '\pwsh.exe'
- '\wscript.exe'
- '\cscript.exe'
- '\mshta.exe'
- '\rundll32.exe'
- '\certutil.exe'
- '\bitsadmin.exe'
- '\curl.exe'
condition: selection_parent and selection_child
falsepositives:
- Legitimate ARM administrative scripts or scheduled maintenance tasks invoking command interpreters
level: high
---
title: ARM Service Account Performing Anomalous Network Connections
id: 8d4e6b12-3a57-4c8f-b291-9e7a5d3f1c04
status: experimental
description: Detects SolarWinds ARM server processes initiating outbound network connections to uncommon external destinations, potentially indicating payload retrieval or C2 after exploitation of CVE-2026-28326.
references:
- https://thehackernews.com/2026/09/solarwinds-patches-arm-hard-coded-key.html
- https://attack.mitre.org/techniques/T1071/
author: Security Arsenal
date: 2026/09/15
tags:
- attack.command_and_control
- attack.t1071.001
logsource:
category: network_connection
product: windows
detection:
selection:
Image|contains:
- '\SolarWinds\'
- '\ARM\'
Initiated: 'true'
filter_internal:
DestinationIp|startswith:
- '10.'
- '192.168.'
- '172.16.'
condition: selection and not filter_internal
falsepositives:
- ARM telemetry, licensing, or update check-ins to SolarWinds infrastructure — baseline known-good destinations and alert on deviations
level: medium
---
title: Web Server Process Writing Executables to ARM Directories
id: 5f1a9c37-2d84-4b6e-8f13-7c2b4e9a0d58
status: experimental
description: Detects executable or script file creation within SolarWinds ARM installation directories by non-installer processes, indicating webshell deployment or payload staging following unauthenticated RCE.
references:
- https://thehackernews.com/2026/09/solarwinds-patches-arm-hard-coded-key.html
- https://attack.mitre.org/techniques/T1505/003/
author: Security Arsenal
date: 2026/09/15
tags:
- attack.persistence
- attack.t1505.003
logsource:
category: file_event
product: windows
detection:
selection:
TargetFilename|contains:
- '\SolarWinds\'
- '\Access Rights Manager\'
TargetFilename|endswith:
- '.aspx'
- '.ashx'
- '.asmx'
- '.exe'
- '.dll'
- '.ps1'
- '.bat'
filter_installer:
Image|endswith:
- '\msiexec.exe'
- '\setup.exe'
condition: selection and not filter_installer
falsepositives:
- Legitimate ARM product updates — correlate file creation timestamps with approved change windows
level: high
// Hunt for suspicious child processes spawned by SolarWinds ARM components
// on Windows endpoints monitored by Defender for Endpoint.
// Tune the parent process names to match your actual ARM deployment paths.
let armProcesses = dynamic(["w3wp.exe", "SolarWinds.ARM", "ARMService"]);
let suspiciousChildren = dynamic([
"cmd.exe", "powershell.exe", "pwsh.exe", "mshta.exe",
"wscript.exe", "cscript.exe", "rundll32.exe",
"certutil.exe", "bitsadmin.exe", "curl.exe"
]);
DeviceProcessEvents
| where TimeGenerated > ago(30d)
| where InitiatingProcessFileName has_any (armProcesses)
or InitiatingProcessCommandLine has_any ("SolarWinds", "Access Rights Manager")
| where FileName in~ (suspiciousChildren)
| project TimeGenerated, DeviceName, InitiatingProcessFileName,
InitiatingProcessCommandLine, FileName, ProcessCommandLine,
AccountName, RemoteIP, SHA256
| order by TimeGenerated desc;
-- Hunt SolarWinds ARM servers for post-exploitation process execution
-- and recently created script/executable artifacts in install directories.
-- Deploy against ARM hosts; adjust install paths to match your environment.
SELECT Pid, Name, CommandLine, Exe, Username, CreateTime
FROM pslist()
WHERE CommandLine =~ '(?i)(powershell|cmd\.exe|mshta|certutil|bitsadmin)'
AND (
Exe =~ '(?i)SolarWinds'
OR CommandLine =~ '(?i)SolarWinds|Access Rights Manager'
)
-- Also review recently written web-accessible payloads in ARM directories
SELECT FullPath, Size, Mtime, Ctime
FROM glob(globs='C:/Program Files*/SolarWinds/**/*.as*', accessor='ntfs')
WHERE Mtime > now() - 2592000
ORDER BY Mtime DESC
# Verify SolarWinds ARM version and flag unpatched installs (CVE-2026-28326)
# Run on each ARM server. Requires local admin.
$armPaths = @(
"${env:ProgramFiles}\SolarWinds",
"${env:ProgramFiles(x86)}\SolarWinds"
)
$found = $false
foreach ($path in $armPaths) {
if (Test-Path $path) {
$found = $true
Write-Host "[+] ARM installation directory found: $path" -ForegroundColor Yellow
Get-ChildItem -Path $path -Recurse -Filter *.exe -ErrorAction SilentlyContinue |
ForEach-Object {
$v = $_.VersionInfo.ProductVersion
Write-Host " $($_.Name) ProductVersion: $v"
}
}
}
if (-not $found) {
Write-Host "[-] No SolarWinds ARM installation detected on this host." -ForegroundColor Green
exit 0
}
# Enumerate ARM-related services and their run-as accounts for blast-radius assessment
Write-Host "`n[+] ARM-related services and service accounts:" -ForegroundColor Yellow
Get-CimInstance Win32_Service |
Where-Object { $_.PathName -match 'SolarWinds|ARM' } |
Select-Object Name, State, StartName, PathName |
Format-List
# Check listening ports bound by ARM processes (exposure assessment)
Write-Host "`n[+] Listening ports owned by SolarWinds processes:" -ForegroundColor Yellow
Get-NetTCPConnection -State Listen -ErrorAction SilentlyContinue |
ForEach-Object {
$proc = Get-Process -Id $_.OwningProcess -ErrorAction SilentlyContinue
if ($proc.Path -match 'SolarWinds') {
" {0}:{1} -> {2}" -f $_.LocalAddress, $_.LocalPort, $proc.ProcessName
}
}
Write-Host "`n[!] ACTION REQUIRED: If ProductVersion is 2026.2 or earlier, the host is vulnerable" -ForegroundColor Red
Write-Host "[!] to CVE-2026-28326. Apply the SolarWinds security update immediately," -ForegroundColor Red
Write-Host "[!] restrict network access to ARM ports, and review child-process telemetry." -ForegroundColor Red
Remediation
1. Patch immediately. Apply the SolarWinds security update that remediates CVE-2026-28326 to every Access Rights Manager instance running 2026.2 or earlier. Pull the current fixed release directly from the SolarWinds customer portal and security advisories page — do not rely on third-party mirrors. Verify the applied version against the vendor advisory after installation; do not assume success from installer exit codes alone.
2. Treat unpatched exposure as a potential compromise. Because the key is hard-coded and recoverable from any copy of the vulnerable software, assume exploitation attempts may predate your patch. On any ARM server that was network-reachable while unpatched:
- Review process-creation telemetry for child processes of ARM services over the past 30–90 days.
- Audit web-accessible file changes in ARM installation directories.
- Review the ARM service account's activity in Active Directory — permission changes, group membership modifications, anomalous authentications.
3. Restrict network exposure — permanently, not as a workaround. ARM management interfaces should be reachable only from designated admin subnets and jump hosts. Enforce this with host firewall rules and network segmentation. An unauthenticated RCE on a management plane should never be exploitable from a general user VLAN. This is CIS Control 12 (Network Infrastructure Management) and basic blast-radius containment.
4. Reduce the ARM service account's privilege. If ARM runs with Domain Admin or equivalent rights, scope it down to the minimum required for its access-governance functions. Post-exploitation impact of this CVE is directly proportional to the service account's standing privileges.
5. Rotate secrets the service can reach. If compromise cannot be ruled out, rotate the ARM service account credentials and any directory or database credentials ARM stores. An attacker with code execution on the ARM host had access to everything ARM could decrypt.
6. Monitor CISA KEV. Given the exploitation characteristics, this CVE is a strong candidate for KEV listing. If added, federal civilian agencies will face a Binding Operational Directive deadline — and you should hold yourself to the same clock regardless of sector.
7. Fix the procurement lesson. Hard-coded keys are a software supply chain failure, not a configuration failure. Raise this in your next vendor security review with SolarWinds and every management-plane vendor: ask how cryptographic material is generated, whether it is per-installation, and whether it survives binary extraction. Your VM program should track vendor secure-development attestations alongside patch SLAs.
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.