My swarm is a handful of nodes running what I use and whatever I am testing that month, so I can spend an hour asking whether anything here reaches the vulnerable code.
The mechanism, in plain terms
On 29 September OpenSSL published fixes for CVE-2026-84782, a bug in how its DTLS handshake code retransmits a message 1. DTLS carries TLS over datagrams, so it handles loss and reordering on its own. Handshake messages go out in fragments, and OpenSSL tracks how far into a message it has written so it can resume after a partial send. When the socket cannot take more data, the write suspends and returns WANT_WRITE, and that position counter stays where it is.
The retransmission timer runs on its own schedule, independent of the suspended write, and can ask for an earlier message to be resent. In the vulnerable code, the retransmission reused the buffer and position tracking of the message still in flight instead of resetting to the start of the message it meant to resend 1. The resend began partway into a different, larger message, shipped bytes that never belonged in a handshake as its body, and could read past the end of the allocation.
The peer can receive heap memory as plaintext handshake data before any authentication completes, or the read runs into an unmapped page and the process aborts.
The advisory describes a second path to a crash: a retransmission that completes while another write is suspended overwrites the bookkeeping the suspended write needs to resume. When the application later resumes that write, it finds the bookkeeping in a state inconsistent with the message and aborts the process in a debugging build 1.
How bad, and for whom
OpenSSL rates it High 1. The CNA score is 8.2, Red Hat scored it 7.4 and rated it Important, and the published tables differ on two fields: Red Hat puts Attack Complexity at High and Confidentiality at High, while cve.org has Attack Complexity Low and Confidentiality Low 2. OpenSSL has not reported any exploitation at release, and nobody has established whether an attacker can force that timing 3.
Affected branches are 4.0, 3.6, 3.5, 3.4, 3.0, 1.1.1 and 1.0.2. Fixed releases are 4.0.3, 3.6.5, 3.5.9 and 3.4.8, and the fixes for 3.0, 1.1.1 and 1.0.2 went to premium support customers 1. Laurent Gaffie reported the bug on 17 August and Ryan Hooper wrote the fix 1.
One detail matters more for container images than the version list: 3.1, 3.2 and 3.3 went out of support before this analysis, so OpenSSL never looked at them 1. An image pinned to one of those branches has no advisory covering it, so my own version sweep is the only thing that will name it.
The conditions that shrink the problem
The vulnerable code runs only for DTLS over UDP, under non-blocking I/O, with a handshake write that suspends mid-message 2. A TLS server on TCP, which is most of what I run, never enters that path.
That narrows the search to a list I can build: UDP sockets, and the libraries behind them.
Step one, the UDP inventory
I start with the sockets, one container at a time.
for c in $(docker ps --format '{{.Names}}'); do
printf '== %s\n' "$c"
docker exec "$c" sh -c 'ss -lunp 2>/dev/null || netstat -lunp 2>/dev/null' || echo 'no socket tools in this image'
done
Plenty of images ship neither ss nor netstat, so I fall back to the node. ss -lunp on the host shows the published UDP binds, and docker inspect maps a port back to a container. On a swarm node the ingress network hides some of that; docker service inspect --format '{{json .Endpoint.Ports}}' <service> gives the published ports.
Then I look at what the UDP sockets are. QUIC on UDP 443 is TLS 1.3 inside a QUIC transport, a different code path in the same library. WireGuard does its own crypto, and OpenVPN on 1194 runs a handshake it implements itself.
A UDP socket by itself does not settle it. I want a socket whose daemon links libssl and drives a DTLS handshake, and that half of the answer comes from the binary.
Step two, the library sweep
The same loop answers the second question.
for c in $(docker ps --format '{{.Names}}'); do
printf '== %s\n' "$c"
docker exec "$c" sh -c 'openssl version 2>/dev/null; ls -l /usr/lib/*/libssl.so* /lib/*/libssl.so* 2>/dev/null'
done
Images with no shell get a throwaway container from the same tag, or docker save and a look at the layers. I check the filesystem because ldd on the entrypoint binary misses a static libssl, which shows up as a file and never as a shared object dependency. Go binaries and Rust services built against rustls carry no OpenSSL at all, so they drop off the list. A Python service reaches OpenSSL through the ssl module, which puts it back on and makes it the one worth a second look when it also holds a UDP socket.
The result on my swarm
The sweep found libssl in most of my images and no DTLS listener at all. Everything I run that terminates TLS does it over TCP, and the few UDP sockets on the swarm belong to processes that do not link OpenSSL.
I have no backport to chase here, so the work is keeping base images moving on their normal cadence and re-running both steps when I add a service. If something did speak DTLS, I would swap the image tag for a fixed branch rather than compile anything, because 4.0, 3.6, 3.5 and 3.4 each have a public fixed release.
The trap worth remembering
On Debian and RHEL based images the fix arrives as a distro package bump, not an OpenSSL release. Red Hat shipped RHSA-2026:82939 on 14 October for Red Hat Update Infrastructure 5 2. On a 3.0 based image the distro backport is the only fix that exists, since upstream 3.0.23 sits behind premium support 1. The upstream advisory tells me which branch needs the fix; the distro errata tells me when my image gets it, and those are two different subscriptions.
FIPS is the other trap. The advisory lists FIPS impact as no, with the affected code outside the module boundary 1. The line looks like an exemption. It means the validated module never covered this code, so a FIPS build carries the same exposure as anything else on the same branch.
Where this leaves me
This one did not need a dramatic fix. The swarm has no DTLS service to leak from, and I know that from a socket list and a library sweep rather than from the advisory sounding unlikely to apply.
The next OpenSSL advisory of this shape starts from the same two steps.
-
OpenSSL Software Foundation. (2026, September 29). OpenSSL Security Advisory [29th September 2026]: DTLS retransmits handshake messages from a stale buffer offset (CVE-2026-84782). OpenSSL Library. https://openssl-library.org/news/secadv/20260929.txt ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎
-
Red Hat. (2026, September 29). CVE-2026-84782. Red Hat Customer Portal. https://access.redhat.com/security/cve/cve-2026-84782 ↩︎ ↩︎ ↩︎
-
SOC Prime Team. (2026, October 1). CVE-2026-84782: High-severity OpenSSL DTLS flaw exposes heap memory and enables DoS. SOC Prime. https://socprime.com/blog/cve-2026-84782-analysis/ ↩︎