On this page

Cisco SD-WAN Zero-Day and CISA ED 26-03 (February 2026)

On 25 February 2026, Cisco disclosed CVE-2026-20127, a CVSS 10.0 authentication bypass in the control plane of Cisco Catalyst SD-WAN. On the same day CISA added it to the Known Exploited Vulnerabilities (KEV) catalog and issued Emergency Directive 26-03. Cisco Talos said a "highly sophisticated" actor it tracks as UAT-8616 had been exploiting it as a zero-day, with malicious activity going back at least to 2023.

This was not a supply-chain attack or an outage. It was the other big 2026 pattern: an attacker living for years inside the box that runs the network. SD-WAN controllers decide how every branch office talks to every other branch office. Whoever controls them can rewrite routing, read configuration and, as Talos showed in October 2026 with a second actor's KeyDrift malware, harvest the keys that protect data-plane tunnels.

TL;DR

  • What: CVE-2026-20127, a flaw in the peering authentication of Cisco Catalyst SD-WAN Controller (vSmart), Manager (vManage) and, as added in June 2026, Validator (vBond). An unauthenticated remote attacker could get an internal high-privileged (non-root) account and reach NETCONF to change fabric configuration (Cisco advisory).
  • Who: Talos attributes the exploitation to UAT-8616, active since at least 2023. In October 2026 Talos also reported a separate APT, UAT-11473, exploiting the same CVE to plant the KeyDrift framework, whose infrastructure "overlaps considerably" with Volt Typhoon's "Silent Train" network (Talos, Feb, Talos, Oct).
  • How they got root: reportedly by downgrading the software to a version vulnerable to the 2022 bug CVE-2022-20775, using it to escalate to root, then restoring the original version to hide the change.
  • Response: CISA ED 26-03 told federal civilian agencies to inventory, capture forensic evidence, then patch, by 5:00 PM ET on 27 February 2026, then hunt and harden (CISA ED 26-03).
  • Lessons: keep management and control planes off the internet, allowlist peers by IP, ship logs off the box before the attacker deletes them, treat software downgrades as security events, and patch KEV entries on a clock measured in hours.

The Alert

There was no single "the alert" moment that has been made public. The vulnerability was reported to Cisco by the Australian Signals Directorate's Australian Cyber Security Centre (ASD's ACSC), according to the credit in Cisco's advisory (Cisco). Talos refers to "an ACSC-led hunt guide" as the source of the escalation chain it describes, and says that once the active exploitation was found, it found evidence that "the malicious activity went back at least three years (2023)" (Talos).

How ASD's ACSC first noticed the activity, which victim networks were involved, and how long investigators had been working on it before 25 February have not been published.

The uncomfortable part

The exploited bug was a zero-day for years. CISA's supplemental guidance says "malicious activity likely began in 2023" and "there are still unknown elements to the malicious activity" (CISA supplemental direction). Patching closes the door. It does not tell you whether someone has already been inside for three years, which is why the directive put forensic capture before patching.

Impact

What is known, and what is not:

DimensionWhat the sources say
VulnerabilityCVE-2026-20127, CWE-287 Improper Authentication, CVSS 3.1 base 10.0 (AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H)
Affected productsCatalyst SD-WAN Controller, Manager and (from advisory v2.0, 16 June 2026) Validator, "regardless of device configuration"
Deployment typesOn-prem, Cisco Hosted SD-WAN Cloud, Cisco Hosted SD-WAN Cloud – Cisco Managed, and the FedRAMP environment
WorkaroundsNone. Upgrade is required.
ExploitationCisco PSIRT: "aware of limited exploitation". Talos: zero-day exploitation since at least 2023 by UAT-8616
Exposed hostsCensys counted "around 600" internet-reachable SD-WAN Manager instances on 27 Feb 2026, mostly in the US. Nearly a quarter also had SSH (22) and/or NETCONF (830) open to the internet (Censys)
VictimsNot disclosed. Talos speaks of footholds in "high value organizations including Critical Infrastructure (CI) sectors". The October KeyDrift report names target sectors: "space and satellite services, defense and aerospace technology, and policy research"
Data stolenUnknown. For KeyDrift, Talos could not recover the configuration that names the exfiltration endpoint, so whether keys actually left victim networks is not established
Lateral movementCISA: attackers moved laterally beyond the SD-WAN environment, and erased logs, command history, connection history and configurations

Background: What an SD-WAN Control Plane Is

You cannot understand why this mattered without understanding what these boxes do. Cisco Catalyst SD-WAN (the former Viptela product line) splits a wide-area network into planes:

Component (new name)Old namePlaneJob
SD-WAN ManagervManageManagementGUI, API, templates, policy authoring, pushes config to everything
SD-WAN ControllervSmartControlDistributes routes, policies and data-plane keys to edge routers
SD-WAN ValidatorvBondOrchestrationFirst contact for new devices, authenticates them and tells them where the controllers are
WAN EdgevEdge / cEdgeDataBranch routers that build IPsec tunnels to each other
flowchart TB
    subgraph MGMT["Management plane"]
        M["SD-WAN Manager (vManage)"]
    end
    subgraph CTRL["Control and orchestration plane"]
        C["SD-WAN Controller (vSmart)"]
        V["SD-WAN Validator (vBond)"]
    end
    subgraph DATA["Data plane"]
        E1["WAN Edge: HQ"]
        E2["WAN Edge: Branch A"]
        E3["WAN Edge: Branch B"]
    end
    M -->|"NETCONF config push"| C
    M -->|"NETCONF config push"| E1
    C -->|"routes, policy, keys"| E1
    C -->|"routes, policy, keys"| E2
    C -->|"routes, policy, keys"| E3
    V -->|"onboarding / auth"| E2
    E1 <-->|"IPsec data tunnels"| E2
    E2 <-->|"IPsec data tunnels"| E3

Two properties make this a juicy target:

  1. The controllers peer with each other and with every edge over an authenticated control channel. Rapid7's analysis identifies the vdaemon service, which handles control-plane peering for the Controller and Manager (Rapid7). If peering authentication fails open, an outsider becomes a trusted member of the fabric.
  2. The Controller distributes data-plane keying material. The KeyDrift component that Talos calls LittleFilch reads decrypted control messages inside vdaemon and extracts edge public IPs, system IPs and 32-byte values Talos assesses as AES-256 IPsec data-plane keys (Talos). Own the control plane and you can, in principle, read the tunnels you were never on the path of.

Timeline

sequenceDiagram
    participant Attacker as UAT-8616
    participant SDWAN as Victim SD-WAN controllers
    participant ACSC as ASD ACSC
    participant Cisco as Cisco PSIRT and Talos
    participant CISA as CISA
    participant Agencies as Federal agencies

    Note over Attacker,SDWAN: 2023 onward — zero-day exploitation (exact start unknown)
    Attacker->>SDWAN: Authentication bypass, rogue peering
    Attacker->>SDWAN: Downgrade, CVE-2022-20775 to root, restore version
    ACSC->>Cisco: Reports the vulnerability (date not public)
    Note over Cisco,CISA: 25 Feb 2026
    Cisco->>Agencies: Advisory cisco-sa-sdwan-rpa-EHchtZk, Talos UAT-8616 blog
    CISA->>Agencies: KEV entry and Emergency Directive 26-03
    Note over Agencies: 26 Feb 23:59 ET — inventory and forensic capture due
    Note over Agencies: 27 Feb 17:00 ET — patches due
    CISA->>Agencies: 11 Mar — ED 26-03 V1 adds log sharing via CLAW
    Cisco->>Agencies: 14 May — Talos reports CVE-2026-20182, also UAT-8616
    Cisco->>Agencies: 16 Jun — advisory v2.0 adds Validator as affected
    Cisco->>Agencies: 28 Oct — Talos KeyDrift report on UAT-11473
Date (2026 unless stated)EventSource
2023Earliest malicious activity identified ("at least three years"). Exact start date not publicTalos, CISA
UnknownASD's ACSC reports the flaw to CiscoCisco advisory credit
25 Feb, 16:00 GMTCisco advisory v1.0 published (bug ID CSCws52722)Cisco
25 FebTalos publishes "Active exploitation of Cisco Catalyst SD-WAN by UAT-8616" with Snort SIDs 65938 and 65958Talos
25 FebCISA adds CVE-2026-20127 and CVE-2022-20775 to KEV, issues ED 26-03 and a supplemental hunt and hardening directionCISA ED 26-03
26 Feb, 23:59 ETAgencies must submit inventory and collect forensic artifacts (logs off-box, admin tech dump, /home, disk and memory snapshots)CISA ED 26-03
27 FebCisco advisory v1.1 updates the fixed-release table. Censys reports ~600 internet-exposed Manager instancesCisco, Censys
27 Feb, 17:00 ETPatch deadline for federal civilian agenciesCISA ED 26-03
3 MarCisco advisory v1.2 updates mitigation guidanceCisco
5 Mar, 23:59 ETDetailed inventory, artifact, patching and hunting report dueCISA ED 26-03
11 MarED 26-03 updated to V1: adds a requirement to send all SD-WAN syslogs to CISA via the CLAW programCISA ED 26-03
12 Mar, 23:59 ETHardening report dueCISA ED 26-03
23 Mar, 23:59 ETLog-sharing report dueCISA ED 26-03
Mar–AprMultiple unrelated actors exploit older SD-WAN Manager bugs (CVE-2026-20133, -20128, -20122) using a public proof of concept that was "incorrectly attributed to CVE-2026-20127"Talos, May
14 MayTalos attributes exploitation of a new SD-WAN auth bypass, CVE-2026-20182, to UAT-8616Talos, May
16 JunCisco advisory v2.0 adds SD-WAN Validator to the affected productsCisco
28 OctTalos publishes the KeyDrift / UAT-11473 report. Cisco advisory v2.1 (final) links to itTalos, Oct, Cisco

Conflicting secondary reporting

Some news coverage said agencies had "24 hours" to patch and put the hardening deadline at 26 March. The directive text itself gives 17:00 ET on 27 February for patching and 12 March for the hardening report (with the log-sharing report on 23 March). This page follows the directive.

Root Cause

The bug class: trusting what the peer says about itself

Cisco's advisory is short: the "peering authentication mechanism in an affected system is not working properly", and an attacker can exploit it "by sending crafted requests" (Cisco).

Rapid7's later patch analysis describes the defect at a conceptual level, which is the useful part for engineers (Rapid7):

  • It sits in the state machine of the vdaemon peering protocol, not in the cryptography.
  • A message that only an already-authenticated peer should be able to send was allowed before authentication.
  • The handler for that message trusted a status value supplied by the remote peer and marked the session authenticated without the server completing its own identity check.
  • The fix removed that message from the pre-auth allowlist and removed the code path that set "authenticated" from peer input, so only the server's own signature verification can authenticate a session.

That is a pattern worth memorising, because it shows up everywhere from TLS stacks to OAuth flows to game servers:

stateDiagram-v2
    [*] --> Connected
    Connected --> ChallengeSent: server sends challenge
    ChallengeSent --> Verified: server verifies peer signature
    Verified --> Authenticated
    ChallengeSent --> Authenticated: BUG - peer-supplied status accepted
    Authenticated --> [*]

The correct invariant is simple: the only transition into Authenticated is one the server computes from evidence it verified itself. Any message that can move the state machine forward must be rejected if it arrives in the wrong state.

# Illustrative only: a peering state machine that cannot be talked into "authenticated".
import secrets
from enum import Enum, auto

class State(Enum):
    CONNECTED = auto()
    CHALLENGE_SENT = auto()
    AUTHENTICATED = auto()

# Which message types are legal in which state. Everything else is dropped.
ALLOWED = {
    State.CONNECTED: {"HELLO"},
    State.CHALLENGE_SENT: {"CHALLENGE_RESPONSE"},
    State.AUTHENTICATED: {"HELLO", "ROUTE_UPDATE", "KEY_UPDATE", "CONFIG"},
}

class PeerSession:
    def __init__(self, verify_sig):
        self.state = State.CONNECTED
        self._verify_sig = verify_sig   # server-side check against a trusted cert chain
        self._nonce = None

    def handle(self, msg_type: str, payload: dict) -> None:
        if msg_type not in ALLOWED[self.state]:
            raise PermissionError(f"{msg_type} not allowed in {self.state.name}")

        if msg_type == "HELLO" and self.state is State.CONNECTED:
            self._nonce = secrets.token_bytes(32)
            self.state = State.CHALLENGE_SENT
        elif msg_type == "CHALLENGE_RESPONSE":
            # Never read payload["authenticated"] or similar. Compute it.
            if self._verify_sig(payload["cert"], self._nonce, payload["sig"]):
                self.state = State.AUTHENTICATED
            else:
                raise PermissionError("bad signature")

if __name__ == "__main__":
    s = PeerSession(verify_sig=lambda cert, nonce, sig: False)
    s.handle("HELLO", {})
    for bad in ("CONFIG", "KEY_UPDATE"):
        try:
            s.handle(bad, {"authenticated": True})
            raise AssertionError("pre-auth message accepted")
        except PermissionError:
            pass
    try:
        s.handle("CHALLENGE_RESPONSE", {"cert": b"", "sig": b"", "authenticated": True})
        raise AssertionError("bad signature accepted")
    except PermissionError:
        pass
    assert s.state is State.CHALLENGE_SENT
    print("ok: session never reached AUTHENTICATED without a verified signature")

What the attacker got: a privileged non-root account and NETCONF

Per Cisco, a successful bypass yields a login as "an internal, high-privileged, non-root user account", from which the attacker can reach NETCONF and change the fabric's configuration. Exploitation needs network access to TCP 22 (SSH) or TCP 830 (NETCONF) on the management plane (Cisco). ASD's ACSC described the result as a "rogue peer joined to the network management plane, or control plane" (The Hacker News, quoting ASD).

The escalation chain: downgrade, old bug, restore

Talos relays, from the ACSC-led hunt guide, how the actor reportedly went from that account to root (Talos):

flowchart TD
    A["Internet or partner network\nreachable management ports"] --> B["CVE-2026-20127\nrogue peer, auth bypass"]
    B --> C["Internal high-privileged\nnon-root account"]
    C --> D["NETCONF access\nread and change fabric config"]
    C --> E["Software DOWNGRADE\nto an older release"]
    E --> F["CVE-2022-20775\npath traversal, local priv-esc"]
    F --> G["root on the controller"]
    G --> H["RESTORE original version\nhides the downgrade"]
    H --> I["Persistence: SSH keys,\nroot login enabled, new accounts"]
    I --> J["Anti-forensics: wipe wtmp,\nlastlog, bash and CLI history"]
    I --> K["Lateral movement beyond\nthe SD-WAN environment"]

    style B fill:#ff6b6b,color:#fff
    style F fill:#ff6b6b,color:#fff
    style G fill:#ff6b6b,color:#fff
    style J fill:#cc5500,color:#fff

Why the downgrade is clever: vendors fix old bugs, but most appliances let an administrator install an older image. Downgrade is a legitimate operation (rollback after a bad upgrade). An attacker who already has a privileged account can reintroduce a four-year-old, already-patched vulnerability, use it, and then upgrade back so that the running version looks normal to anyone checking "are we on the fixed release?". CVE-2022-20775 itself is a path traversal in the CLI that lets an authenticated local attacker run commands as root (CISA ED 26-03).

The version check lies

A compliance scanner that only reads the current software version would report a fully restored box as "patched for CVE-2022-20775". The evidence of the downgrade lives in upgrade logs and reboot records, which the attacker also tried to delete.

Post-compromise: what Talos and CISA told people to look for

Talos lists the following as potential high-fidelity indicators (Talos), and CISA's supplemental direction gives a matching hunt list (CISA):

BehaviourWhere it shows up
Accounts created, used, then deleted, with missing bash_history / cli-history/home/*, history files
Interactive root sessions. CISA: root "should never be used interactively""Accepted publickey for root", /home/root/.ssh/authorized_keys, /home/root/.ssh/known_hosts
PermitRootLogin yes/etc/ssh/sshd_config
Unknown keys for the internal admin account/home/vmanage-admin/.ssh/authorized_keys
Logs missing or 0, 1 or 2 bytes, signs of truncationsyslog, wtmp, lastlog, cli-history, bash_history, /var/log/
Unexplained peers added or droppedcontrol-connection logs
Unauthorised downgrades/upgrades and reboots, e.g. "Software upgrade not confirmed. Reverting to previous software version."vdebug, sw_script_synccdb.log
Usernames containing path traversal strings (CVE-2022-20775 traces)auth logs

Act two: KeyDrift (October 2026)

On 28 October 2026, Talos reported a different cluster, UAT-11473, "a highly sophisticated advanced persistent threat (APT) actor", that exploited CVE-2026-20127 to install a custom framework it named KeyDrift on SD-WAN Controllers (Talos). At a high level:

ComponentRole (per Talos)
PolyFlame (libdssl.so)Runs in memory inside legitimate vdaemon processes. Backdoor mode (command execution, file read/write) or relay mode (acts as an intermediate C2 for other peers)
LittleFilch (libcommon.so)Hooks TLS reads in vdaemon, parses decrypted control messages, extracts edge IPs and what Talos assesses are AES-256 IPsec data-plane keys, encrypts them into a staging file
aaamgrdPacked ELF masquerading as a legitimate service name, with anti-debugging checks
rsshd, conf_sshdInjector and helper that locate vdaemon and load the library into it
PersistenceModified runit service scripts that launch the injector chain before the real service, plus timestomping
flowchart LR
    X["CVE-2026-20127\ninitial access"] --> R["Modified runit scripts\npersistence at boot"]
    R --> I["Injector loads library\ninto vdaemon"]
    I --> P["PolyFlame\nbackdoor or relay"]
    I --> L["LittleFilch\nreads decrypted control traffic"]
    L --> K["Staged file with edge IPs\nand data-plane keys"]
    K -.->|"exfil endpoint unknown"| Q["Operator"]
    P -.-> Q

What remains unknown, in Talos's own words or by omission:

  • When the intrusions happened. Talos calls the activity "historical" without dates.
  • Whether keys left the networks. Talos has "not been able to recover the 'vdaemon.conf' file" that holds the remote endpoint, and recovered no hardcoded IPs, domains or ports.
  • Attribution. Talos says UAT-11473's infrastructure "overlaps considerably with Volt Typhoon's 'Silent Train' covert access network". That is infrastructure overlap, not a statement that UAT-11473 is Volt Typhoon.
  • Relationship to UAT-8616. The October report does not mention UAT-8616. Whether the two clusters are related is not stated.

Act three: copycats and a misattributed PoC

Once a vulnerability is on KEV and in the news, the population of attackers changes. Talos's May 2026 report found that "the vast majority of observed exploitation attempts" against SD-WAN Manager in March–April used a public proof of concept from ZeroZenX Labs that targeted older Manager bugs (CVE-2026-20133, -20128, -20122) but was "incorrectly attributed to CVE-2026-20127". Talos grouped that activity into ten clusters, dropping webshells, Sliver and AdaptixC2 implants, cryptominers and a credential stealer aimed at admin hashes, JWT key material and vManage AWS credentials (Talos, May). VulnCheck made the same warning: misattributed PoC code "will lead to incomplete detections" (VulnCheck).

The same report attributes a new SD-WAN authentication bypass, CVE-2026-20182, to UAT-8616, which "attempted to add SSH keys, modify NETCONF configurations, and escalate to root privileges".

The lesson in act three

A detection written from one PoC catches that PoC. When you write a rule for a newly public CVE, write it against the behaviour (unknown peer comes up, admin key added, root login, downgrade) rather than a specific request shape, or the first variant walks past it.

Detection

How it was detected

Publicly, the only answer is "by a national cyber agency during a hunt", and the details are not public. What is public is the detection logic that came after, and it is instructive because almost none of it depends on knowing the bug:

  1. Control-connection peering events. Talos: "The most important thing to check is any control connection peering event". Every such event "require[s] manual validation", with "particular focus on vManage peering types". Check the event time against change windows, the public IP against your inventory, the system IP against documented assignments, and the peer type against the device's role (Talos).
  2. Rogue peering heuristics. CISA asks hunters to complete four methods: unusual peer types (such as rare values) coming up with zero uptime; low-frequency clusters of peer type and system IP; a remote colour of (null) or {28 0}; and manual confirmation in the Manager UI that each peered edge is real (CISA).
  3. Null identities. Rapid7 suggests looking for connection-up events where the peer system IP is null (:: or 0.0.0.0) and correlating the source IP with vmanage-admin public-key logins and SSH or NETCONF sessions shortly afterwards (Rapid7).
  4. Authentication events. CISA: alert on "Authentication succeeded for" events and match each one to an authorised user. "If the alert is for a root account, then assume the root account has been compromised."

A peering-event checker you can run

The script below is a defensive starting point: it reads exported control-connection log lines and flags any peer whose system IP, public IP or type is not in your inventory. Adjust the regex to your log format, since Cisco's exact field layout varies between releases.

#!/usr/bin/env python3
"""Flag SD-WAN control-connection peers that are not in the asset inventory.

Usage: python check_peers.py inventory.json vsyslog.log [more logs...]
inventory.json: {"peers": [{"system_ip": "10.255.0.1", "public_ip": "198.51.100.10", "type": "vedge"}, ...]}
"""
import json
import re
import sys

PATTERN = re.compile(
    r"control-connection-state-change.*?new-state:(?P<state>\S+).*?"
    r"peer-type:(?P<type>\S+).*?peer-system-ip:(?P<sysip>\S+).*?public-ip:(?P<pubip>\S+)"
)
NULL_IPS = {"::", "0.0.0.0", "(null)"}
PRIVILEGED = {"vmanage", "vsmart", "vbond"}

def load_inventory(path):
    with open(path) as f:
        peers = json.load(f)["peers"]
    return {(p["system_ip"], p["public_ip"], p["type"]) for p in peers}

def scan(lines, known):
    for n, line in enumerate(lines, 1):
        m = PATTERN.search(line)
        if not m or m["state"] != "up":
            continue
        key = (m["sysip"], m["pubip"], m["type"])
        reasons = []
        if m["sysip"] in NULL_IPS:
            reasons.append("null system-ip")
        if key not in known:
            reasons.append("not in inventory")
        if m["type"] in PRIVILEGED and key not in known:
            reasons.append("UNKNOWN PRIVILEGED PEER")
        if reasons:
            yield n, key, reasons

if __name__ == "__main__":
    if len(sys.argv) < 3:
        # self-check
        known = {("10.255.0.1", "198.51.100.10", "vedge")}
        good = "x control-connection-state-change new-state:up peer-type:vedge peer-system-ip:10.255.0.1 public-ip:198.51.100.10"
        bad = "x control-connection-state-change new-state:up peer-type:vmanage peer-system-ip::: public-ip:203.0.113.9"
        hits = list(scan([good, bad], known))
        assert len(hits) == 1 and "UNKNOWN PRIVILEGED PEER" in hits[0][2], hits
        print("self-check ok")
        sys.exit(0)
    known = load_inventory(sys.argv[1])
    for log in sys.argv[2:]:
        with open(log, errors="replace") as f:
            for n, key, reasons in scan(f, known):
                print(f"{log}:{n} {key} -> {', '.join(reasons)}")

SIEM rules

Because CISA warns that "threat actors could modify logs stored on the device", these rules must run on the forwarded copy. Example Splunk searches, assuming an sdwan index fed by syslog:

# 1. Any privileged peer type coming up from an IP not in the lookup of known controllers
index=sdwan "control-connection-state-change" "new-state:up"
| rex "peer-type:(?<peer_type>\S+).*peer-system-ip:(?<sys_ip>\S+).*public-ip:(?<pub_ip>\S+)"
| search peer_type IN ("vmanage","vsmart","vbond")
| lookup sdwan_known_controllers public_ip AS pub_ip OUTPUT owner
| where isnull(owner)

# 2. Root logins or root key changes: page immediately
index=sdwan ("Accepted publickey for root" OR "PermitRootLogin yes" OR "/home/root/.ssh/authorized_keys")

# 3. Downgrade / revert evidence outside approved change windows
index=sdwan ("Software upgrade not confirmed" OR "system-reboot-issued" OR "master install")
| lookup change_windows host OUTPUT window_open
| where window_open!="true"

# 4. Log clearing: the forwarded stream for a host goes silent
| tstats count where index=sdwan by host _time span=15m
| where count=0

A Sigma-style rule for the root-login signal, which is high fidelity because root should never log in interactively on these appliances:

title: Interactive root login on Cisco SD-WAN appliance
status: experimental
description: CISA ED 26-03 supplemental direction says root should never be used interactively on Cisco SD-WAN.
logsource:
  product: cisco_sdwan
  service: auth
detection:
  selection:
    message|contains:
      - 'Accepted publickey for root'
      - 'Accepted password for root'
  condition: selection
level: critical
tags:
  - attack.initial_access
  - attack.t1190
  - cve.2026-20127

Response

What CISA required, and why the order matters

ED 26-03 made agencies act "in the identified order" (CISA):

flowchart LR
    A["1. Identify\ninventory all Manager\nand Controller systems"] --> B["2. Collect\nlogs off-box, admin tech dump,\n/home, disk and memory snapshots"]
    B --> C["3. Share logs\nsyslog to CISA via CLAW\n(added in V1)"]
    B --> D["4. Update\napply Cisco fixes"]
    D --> E["5. Hunt\nsupplemental IOC list"]
    E --> F{"Root compromise?"}
    F -->|"yes"| G["Report to CISA,\nREBUILD Manager, Controller,\nValidator from patched images,\nmigrate edges, new admin creds"]
    F -->|"no"| H["6. Harden"]
    G --> H

Collect before you patch. Upgrading reboots the box and replaces files. If you patch first, you may overwrite the only evidence of a three-year intrusion. This is the same reasoning as "don't reboot a compromised server before you image memory", applied to a network appliance under a hard deadline.

Rebuild, don't clean. If root was compromised, CISA's instruction is to deploy fresh Manager, Controller and Validator instances from patched images, move edges to the new control plane and create new admin accounts with unique credentials. You cannot trust any file on a box where an attacker had root and a habit of deleting logs. KeyDrift's modified runit scripts, which survive restarts and launch before the real service, show exactly why.

What vendors and others did

  • Cisco shipped fixed releases with no workaround, updated the fixed-release table two days later, added interim ACL guidance on 3 March, added the Validator in June and linked the KeyDrift research in October.
  • Talos published Snort SIDs 65938 and 65958 for CVE-2026-20127 on day one and Snort 2 SIDs 67387–67416 / Snort 3 SIDs 7:44–7:73 for KeyDrift artifacts in October.
  • Censys published internet exposure counts and fingerprint queries within two days.
  • Other national CERTs (Canada's Cyber Centre AL26-004 and the UK NCSC are referenced by Talos) issued their own advisories.

Remediation

Fixed releases

From Cisco's advisory (v2.1). Releases marked † are past End of Software Maintenance, so the "fix" is a migration.

Current releaseFirst fixed
Earlier than 20.9 †Migrate to a fixed release
20.920.9.8.2
20.11 †20.12.6.1
20.1220.12.5.3 or 20.12.6.1
20.13 †, 20.14 †, 20.1520.15.4.2
20.16 †, 20.1820.18.2.1

Note that two months later CVE-2026-20182 required another round of fixes, and the older Manager bugs had their own February patches. "We patched CVE-2026-20127" was not the end of the SD-WAN patching story in 2026.

Interim mitigation while you schedule the upgrade

Cisco's own interim advice for on-prem deployments: use ACLs, security group rules or firewall rules so that ports 22 and 830 accept traffic only from known controller IPs and other specific hosts that need access. Cisco says its hosted, FedRAMP and managed offerings already have these guardrails (with shared responsibility for the managed tier). Cisco also notes this mitigates exposure but does not fix the bug.

What Would Have Prevented It

No customer control prevents a vendor's zero-day from existing. But almost every control below shrinks who can reach the bug, how long an intruder stays undetected, or how much they can do. CISA's supplemental direction effectively lists them.

1. Management and control planes are not internet services

CISA is blunt: allowing dynamic-IP edges means "this is not a secure deployment". It recommends a firewall in front that allowlists only known edge, Controller, Validator and Manager IPs (which requires static IPs on edges), and putting the VPN 512 management interfaces on an isolated internal management VLAN.

An nftables policy for a jump/firewall host in front of on-prem controllers, matching Cisco's interim guidance for TCP 22 and 830:

#!/usr/sbin/nft -f
# Allow SSH and NETCONF to SD-WAN controllers only from known peers and the admin bastion.
table inet sdwan_guard {
  set sdwan_peers {
    type ipv4_addr
    flags interval
    elements = { 198.51.100.10, 198.51.100.11, 198.51.100.12,   # Controllers / Validators
                 203.0.113.0/28 }                                 # static edge public IPs
  }
  set admin_bastion {
    type ipv4_addr
    elements = { 10.20.0.5 }
  }
  set sdwan_mgmt_hosts {
    type ipv4_addr
    elements = { 10.10.0.10, 10.10.0.11, 10.10.0.12 }             # Manager / Controller mgmt IPs
  }

  chain forward {
    type filter hook forward priority 0; policy drop;
    ct state established,related accept

    ip daddr @sdwan_mgmt_hosts tcp dport { 22, 830 } ip saddr @admin_bastion accept
    ip daddr @sdwan_mgmt_hosts tcp dport { 22, 830 } ip saddr @sdwan_peers accept
    ip daddr @sdwan_mgmt_hosts tcp dport { 22, 830 } log prefix "SDWAN-MGMT-DENY " drop
    # Add your control-plane DTLS/TLS ports here, allowlisted the same way.
  }
}

For cloud-hosted controllers you run yourself, the same idea as a Terraform security group. The point is that there is no 0.0.0.0/0 rule anywhere:

variable "sdwan_peer_cidrs" {
  type        = list(string)
  description = "Static public IPs of WAN edges, controllers and validators. Never 0.0.0.0/0."
}

resource "aws_security_group" "sdwan_controller_mgmt" {
  name        = "sdwan-controller-mgmt"
  description = "SSH and NETCONF only from known SD-WAN peers and the admin bastion"
  vpc_id      = var.vpc_id

  ingress {
    description     = "SSH from bastion"
    from_port       = 22
    to_port         = 22
    protocol        = "tcp"
    security_groups = [var.bastion_sg_id]
  }

  ingress {
    description = "NETCONF from known peers"
    from_port   = 830
    to_port     = 830
    protocol    = "tcp"
    cidr_blocks = var.sdwan_peer_cidrs
  }

  egress {
    description = "Only to peers and log collector"
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = concat(var.sdwan_peer_cidrs, [var.log_collector_cidr])
  }

  lifecycle {
    precondition {
      condition     = !contains(var.sdwan_peer_cidrs, "0.0.0.0/0")
      error_message = "SD-WAN management ports must never be open to the internet."
    }
  }
}

And a CI guard that fails the build if anyone opens these ports to the world later:

# Fails if any security group exposes 22 or 830 to 0.0.0.0/0 or ::/0
aws ec2 describe-security-groups \
  --query "SecurityGroups[?IpPermissions[?((FromPort<=\`22\` && ToPort>=\`22\`) || (FromPort<=\`830\` && ToPort>=\`830\`)) && (IpRanges[?CidrIp=='0.0.0.0/0'] || Ipv6Ranges[?CidrIpv6=='::/0'])]].GroupId" \
  --output text | grep -q . && { echo "Management port open to the internet"; exit 1; } || echo "ok"

Censys found roughly a quarter of the ~600 exposed Manager hosts had 22 and/or 830 reachable from the internet. That quarter is the population this control removes from the attack surface.

2. Logs leave the box in real time

The attacker's playbook included wiping wtmp, lastlog and shell histories and blocking log forwarding. CISA's hardening list: send logs to an external SIEM "as threat actors could modify logs stored on the device", and alert on peering from unknown IPs and every "Authentication succeeded for" event.

Configure the remote syslog servers on the appliances through the Manager's logging feature template (the exact template fields vary by release, so follow Cisco's configuration guide for your version). On the collector side, an rsyslog receiver that writes per-host files and forwards to the SIEM:

# /etc/rsyslog.d/10-sdwan.conf on the log collector
module(load="imtcp")
input(type="imtcp" port="6514" ruleset="sdwan")   # use TLS (gtls driver) in production

template(name="PerHost" type="string" string="/var/log/sdwan/%HOSTNAME%/%$YEAR%-%$MONTH%-%$DAY%.log")

ruleset(name="sdwan") {
  action(type="omfile" dynaFile="PerHost")
  action(type="omfwd" target="siem.internal" port="6514" protocol="tcp"
         queue.type="LinkedList" queue.filename="sdwan_fwd" queue.saveOnShutdown="on")
}

Make the collector write-once (object-lock bucket, append-only storage or a separate account the network team cannot delete from). A log you can edit is a log the attacker can edit once they own your admin account. Also alert when a host stops sending: silence is a signal (see rule 4 in the SIEM section).

3. Treat downgrades as security events

The escalation chain only works if the box accepts an older image. Controls, in order of strength:

  • If the platform supports it, disable or restrict downgrade to a break-glass role with two-person approval.
  • Alert on any version change that is not tied to an approved change record.
  • Compare the version history, not just the current version, in your vulnerability scanner. "Running 20.15.4.2" and "ran 20.3 for ten minutes last Tuesday" are different risk states.
# Pseudocode for a CMDB job: flag any version observed in history that is lower than the previous one.
def find_downgrades(history):  # history: list of (timestamp, version_tuple) sorted by time
    return [(t, prev, cur) for (_, prev), (t, cur) in zip(history, history[1:]) if cur < prev]

assert find_downgrades([(1, (20, 15, 4)), (2, (20, 3, 0)), (3, (20, 15, 4))]) == [(2, (20, 15, 4), (20, 3, 0))]

4. Root and admin access are monitored, not just protected

CISA's hunt checks double as standing controls:

  • PermitRootLogin must be no. Root in /etc/passwd should show *, not a hash.
  • File-integrity monitoring on /home/*/.ssh/authorized_keys, /etc/ssh/sshd_config and service run scripts (KeyDrift modified runit scripts for persistence).
  • Session timeouts of about five minutes for client, server and CLI sessions.
  • New local accounts trigger an alert and must map to a ticket.

A minimal integrity baseline you can run from the bastion, if the appliance gives you a supported shell for this (check with your vendor and TAC first, as appliance shells are often restricted):

# Run once on a known-good box to create a baseline, then diff on a schedule.
FILES="/etc/ssh/sshd_config /home/root/.ssh/authorized_keys /home/vmanage-admin/.ssh/authorized_keys"
sha256sum $FILES 2>/dev/null > /secure/baselines/$(hostname).sha256
# Later:
sha256sum -c /secure/baselines/$(hostname).sha256 || logger -p auth.crit "SDWAN integrity drift on $(hostname)"

5. Use the stronger options the platform already has

From CISA's hardening list: DTLS for Manager connections, SNMPv3 only ("Organizations should never use older versions of SNMP"), pairwise keys instead of the default key exchange for the data plane, and a Manager web certificate from an enterprise or trusted CA instead of the self-signed default. Pairwise keying matters more after KeyDrift: it limits what a single stolen key can decrypt.

6. A KEV-driven patch clock

ED 26-03 gave federal agencies about 48 hours from issuance to patch. Most organisations patch on a monthly cycle, which is fine for the long tail and fatal for KEV entries on edge devices. Wire the KEV feed into your inventory so that a match pages someone the day it lands:

#!/usr/bin/env python3
"""Match CISA KEV entries against an internal inventory and print what needs an emergency patch."""
import json
import sys
import urllib.request
from datetime import date, timedelta

KEV_URL = "https://www.cisa.gov/sites/default/files/feeds/known_exploited_vulnerabilities.json"

# inventory.json: [{"vendor": "Cisco", "product": "Catalyst SD-WAN", "host": "vsmart-01", "internet_facing": true}]
def load_inventory(path):
    with open(path) as f:
        return json.load(f)

def matches(entry, asset):
    return (entry["vendorProject"].lower() == asset["vendor"].lower()
            and asset["product"].lower() in entry["product"].lower())

def sla(asset):
    # Edge and management-plane assets: 48 hours. Everything else: 14 days. Tune to your policy.
    return timedelta(hours=48) if asset.get("internet_facing") or asset.get("mgmt_plane") else timedelta(days=14)

def main(inv_path, since_days=7):
    with urllib.request.urlopen(KEV_URL, timeout=30) as r:
        kev = json.load(r)["vulnerabilities"]
    recent = [v for v in kev if date.fromisoformat(v["dateAdded"]) >= date.today() - timedelta(days=since_days)]
    for v in recent:
        for a in load_inventory(inv_path):
            if matches(v, a):
                print(f"{v['cveID']} {v['vendorProject']} {v['product']} -> {a['host']} "
                      f"(added {v['dateAdded']}, our SLA {sla(a)})")

if __name__ == "__main__":
    main(sys.argv[1], int(sys.argv[2]) if len(sys.argv) > 2 else 7)

Pair this with a pre-agreed emergency change process. ED 26-03's order (inventory, capture evidence, patch, hunt, harden) is a good template for your own runbook.

7. An accurate inventory, before you need it

The directive's first action, due within about 30 hours, was "tell us every system you have". Organisations that could not answer that quickly lost the time they needed for forensic capture. Network appliances belong in the same CMDB as servers, with version, exposure and owner.

Lessons for System Design

  1. Authentication is a state machine property. The bug was not weak crypto. It was a transition into "authenticated" that the server did not compute itself. Model protocol states explicitly, allowlist messages per state, and test that every pre-auth message type is rejected in every wrong state. Fuzz the state machine, not just the parser.
  2. Control planes deserve a smaller blast radius than data planes, not a larger one. One Controller distributes routes and keys to the entire WAN. Design for per-region or per-tenant control planes where the product allows, use pairwise keys, and rotate data-plane keys so stolen material ages out. The same logic drives cell-based architecture in services.
  3. Edge devices are the new perimeter breach. The Talos framing, "a continuing trend of the targeting of network edge devices", matches a run of incidents against VPNs, firewalls and SD-WAN gear. These boxes often lack EDR, have limited logging and are patched less often than servers. Treat them as high-value servers: inventory, FIM, off-box logs, restricted admin paths.
  4. Rollback is a security-relevant capability. Every system that supports "install an older version" also supports "reintroduce an old vulnerability". Gate it, log it, alert on it. This applies equally to firmware, container images (pin digests, block tag regression) and database migrations.
  5. Integrity of evidence is part of the design. If the attacker can delete your logs, you do not have logs. Ship them out synchronously, store them immutably, and alert on silence.
  6. Recovery should assume compromise. CISA's "rebuild from patched images and migrate edges" is only quick if you have templates, automation and documented edge migration. Practise rebuilding your control plane the way you practise database failover.
  7. Public PoCs reshape the threat. A sophisticated actor's quiet zero-day became, within weeks, a noisy free-for-all of webshells and miners on unpatched Managers. Your patch deadline is set by the second wave, not the first.

What Would You Do?

Scenario 1: It is 25 February, 18:00 UTC. ED 26-03 just dropped. Your team runs on-prem vManage and vSmart. The upgrade is ready to go. Do you (A) patch immediately, (B) collect logs, a tech dump and disk/memory snapshots first, then patch, or (C) put the ACL in place and wait for the next maintenance window?

(B). The directive requires collection before update for a reason: the activity may date back to 2023, and an upgrade reboots and rewrites files that may hold the only evidence. Apply the ACL from Cisco's interim guidance immediately while you collect, then patch inside the deadline. (C) leaves you on a vulnerable release behind a control Cisco says mitigates but does not fix.

Scenario 2: Your scanner reports every controller on the fixed release. A hunter finds a "Software upgrade not confirmed. Reverting to previous software version." message from eight months ago and a 0-byte bash_history for an account nobody recognises. Is the box clean?

No. Treat it as root-compromised. This matches the reported downgrade-and-restore chain and the log-wiping behaviour. Follow CISA's path: report, rebuild Manager, Controller and Validator from patched images, migrate edges, issue new credentials, and hunt laterally. A current version number says nothing about what ran in the past.

Scenario 3: In May, your detection engineer wrote rules from a public PoC labelled "CVE-2026-20127" and saw lots of hits. Are you covered?

Probably not, and possibly looking at the wrong bug. Talos and VulnCheck both said the widely used PoC was misattributed and targeted different Manager vulnerabilities. Keep the PoC-based rule, but add behaviour-based rules (unknown privileged peer up, new admin key, root login, downgrade, log silence) and make sure the February patches for the other Manager CVEs and the CVE-2026-20182 fixes are in place too.

Key Lessons

  • Patch is necessary, not sufficient. For a multi-year zero-day, collect evidence, patch, hunt, and rebuild if root was touched.
  • Allowlist your control plane. Ports 22 and 830 (and control ports) only from known peer and bastion IPs. Static edge IPs make this possible.
  • Logs off the box, immutable, with silence alerts. The attacker deleted local logs.
  • Downgrades are attacks until proven otherwise.
  • Write detections for behaviour, not for one PoC.
  • KEV on an edge device means hours, not a monthly cycle.
Quiz

Q1: Why did CISA require forensic collection before patching? Because exploitation likely began in 2023 and the upgrade process reboots the appliance and replaces files, which could destroy evidence of a long-running intrusion. Collecting first preserves the ability to answer "were we compromised and for how long?".

Q2: The attacker had an admin-level account. Why bother with a 2022 vulnerability? The bypass gave an internal high-privileged non-root account. Downgrading to a release vulnerable to CVE-2022-20775 allowed escalation to root, and restoring the original version hid the downgrade from version-based checks.

Q3: What design flaw does Rapid7 describe as the root cause? A peering-protocol state-machine flaw: a message that should only be accepted after authentication was allowed before it, and its handler trusted a peer-supplied status to mark the session authenticated without the server's own identity verification.

Q4: What does KeyDrift add to the risk picture beyond configuration tampering? It runs inside the control-plane daemon and extracts what Talos assesses are AES-256 IPsec data-plane keys plus edge identities, which could let an attacker decrypt WAN traffic. Whether keys were exfiltrated is unknown because the exfiltration configuration was not recovered.

Q5: Name three controls that would have shrunk exposure even before a patch existed. Any three of: firewall allowlisting of management and control ports to known IPs, no internet exposure of management interfaces (isolated management VLAN), real-time immutable off-box logging with alerts on unknown peers and root logins, alerting on software downgrades, file-integrity monitoring of SSH keys and service scripts, pairwise data-plane keys.

One-Liner Summary

A broken peering-authentication check let a sophisticated actor sit inside the controllers that run enterprise WANs for about three years, escalating to root by quietly downgrading and restoring the software, and the response showed that for edge devices "patch" is only step four of six.

Sources

Primary:

Research and reporting: