Cisco SD-WAN KeyDrift: What a Compromised Controller Does With Your Overlay Keys
On 28 October Cisco Talos published an analysis of malware it calls KeyDrift, installed on Cisco Catalyst SD-WAN controllers after attackers used CVE-2026-20127. I have written about that CVE before, but only the way in. KeyDrift is about what comes after: an attacker who is already on the controller and wants the keys that protect your site-to-site traffic.
This post is based on Talos’s write-up and the coverage of it. I have not run any of this, and the controllers I work with are not compromised, so everything below is what Talos reports, plus clearly marked opinion.
How the attacker got in
CVE-2026-20127 is the peering authentication bypass in Catalyst SD-WAN Controller, Manager and Validator, patched in February with a CVSS score of 10.0. I covered the bug and its sibling CVE-2026-20182 in Declare Yourself Trusted. Talos attributes the KeyDrift intrusions to a cluster it tracks as UAT-11473, a different tracking name from the UAT-8616 in that post. The coverage I read does not explain how the two relate, so I am not treating them as one actor.
Talos reports targeting in space and satellite services, defence and aerospace technology, and policy research. It also assesses with high confidence that the infrastructure UAT-11473 used overlaps considerably with Volt Typhoon’s “Silent Train” covert access network. That is an infrastructure overlap, not a statement about who the operators are.
Why the controller is the target
In the Catalyst SD-WAN design, each edge router generates data-plane keying material and sends it to the controller, which passes it to the other edges that need it. The controller is the one place where those keys are visible together. That is the design working as intended, and it is also why a controller in an attacker’s hands is more valuable than any single branch router.
KeyDrift does not try to break the encryption. It collects the keys.
What KeyDrift does
Talos describes a framework with two main parts, plus the pieces that put them in place.
PolyFlame is the main module. It lives in memory inside legitimate vdaemon processes, the daemon that handles the control-plane sessions. From there it hooks socket and DTLS calls such as recvfrom and sendto, so it sees control traffic from inside the controller’s own process rather than beaconing out from a separate implant. It provides a backdoor in the style of TinyShell, with file read, file write and command execution but no interactive shell, and it can relay commands on to other peers, which makes the compromised controller an intermediate C2 host. Talos did not recover any hardcoded callback addresses, ports or domains from the samples, and describes the tasking as in-band over control-plane traffic.
One detail I liked as a defender’s problem: PolyFlame checks a date handshake. The C2 sends the MD5 of a date string, the implant computes the MD5 of the local date, and if they do not match it stops. A sample detonated on the wrong day does nothing.
LittleFilch is the key thief. It hooks SSL_read inside vdaemon, so it reads control messages after they have been decrypted. It only acts on buffers above a size threshold that start with a particular byte and contain specific marker patterns, and it pulls out the edge’s public IP and system IP along with a 32-byte field. Talos assesses that field to be AES-256 key material for the data plane, and that it is collected for a predefined list of edge nodes. The result is encrypted with RSA and written to /var/tmp/vdaemon.bin, and it can be sent out over UDP in a record shaped like DTLS 1.2 application data. LittleFilch reads its destination from /var/tmp/vdaemon.conf and deletes that file after reading it, which is why Talos could not recover one.
How it stays installed
The persistence is the part that matters for incident response. KeyDrift anchors on the controller’s runit service scripts, not on a cron job or a startup binary you would think to look for.
In the sshd variant, the attacker edits the service run script to remount /rootfs.rw as executable and start a script called conf_sshd in the background, then start the real sshd as normal. That script lists the running vdaemon process IDs, writes them to /tmp/system-vdaemon, and calls an injector named rsshd, which uses ptrace to load libdssl.so (PolyFlame) into each one. On a vBond appliance Talos found a parallel pattern: a malicious runit service under /etc/sv/aaamgr/ running a packed loader called aaamgrd. The legitimate aaamgr component is a Python package, so a compiled ELF with that name is wrong. Talos also saw timestomping, and notes the modules show signs of ongoing development, including anti-debugging and process impersonation.
What patching does and does not do
Patching CVE-2026-20127 closes the door. It does not remove an implant that is already in place. Talos calls this “historical” activity, and the central question for anyone running these controllers is whether an attacker got in before you patched, not whether you are patched now.
The artefacts Talos names are worth knowing:
/var/tmp/vdaemon.bin, the RSA-encrypted staging file/var/tmp/vdaemon.conf, normally deleted after reading, so its absence proves nothing/tmp/system-vdaemon, the PID list written by the loaderlibdssl.soandlibcommon.so, the PolyFlame and LittleFilch modules- changes to the sshd or aaamgr runit run scripts, and an unexpected compiled
aaamgrd /rootfs.rwremounted as executable
I am deliberately not giving shell commands for checking these. Access to the controller’s underlying shell is controlled, I have not verified a procedure on a live controller, and a mistake on a controller is expensive. Take the artefact list to Cisco TAC and ask for their forensic procedure, and follow Cisco’s SD-WAN hardening guide. The Talos post has the full indicator list.
What I would ask
These are my questions, not Talos guidance.
- If a controller was reachable and unpatched at any point since CVE-2026-20127 became known, can you show it was not compromised? The honest answer for many deployments may be that you cannot.
- If you cannot, what does Cisco advise about the data-plane keys the controller held? A key that was copied is still valid until it is replaced.
- A stolen key only helps if the attacker can also capture the encrypted traffic. Who can see your transport paths? That decides how worried you should be.
- Is the controller’s management and control-plane exposure what it should be? This is the same lesson as the CSV upload privilege escalation and the October fixes: the controller keeps getting attacked because it is the most useful box in the fabric.
Why this matters for the design
In my overview of the three planes, the argument is that the control plane is where SD-WAN systems differ most, and where the trust sits. KeyDrift is a concrete case of that. A centralised controller gives you simple operations and one place to see everything, and it gives an attacker the same. The data plane can be strongly encrypted and still depend on a control plane that holds the keys.
That is not a reason to avoid SD-WAN. It is a reason to treat the controllers as the most sensitive systems in the estate, patch them first, keep them off untrusted networks, and plan for what you will do if you discover one was compromised before you patched it.
Sources:
- Cisco Talos: Inside KeyDrift, Analyzing historical UAT-11473 activity on Cisco SD-WAN
- BleepingComputer: Hackers exploit Cisco SD-WAN flaw to deploy custom KeyDrift malware
- SecNews: Hackers exploited a Cisco SD-WAN flaw to plant malware built to steal encryption keys