Password authentication makes a simple promise: if you do not know the key, you do not get in. Cyrus SASL, one of the oldest libraries for handling that process on mail and directory servers, stopped keeping it up to version 2.1.28, and the advisory was published with no room for doubt. The flaw was published on November 16, 2026 as CVE-2026-129483 with a score of 9.1 out of 10, and its description reads in two lines: a network client without credentials can authenticate as any user that exists on the server.
The technical detail is rather uncomfortable. The affected mechanism is SRP, a key exchange protocol designed precisely to avoid sending the password over the network. When the client sends a specific public value, the server computes a shared secret that equals zero, because it never checks for that case. With the secret in view, the attacker completes authentication with whatever username they want and also learns the session keys derived afterwards.
The library appears in mail, directories and products that delegate authentication to an external module. If your server accepts outside connections and loads this library, exposure depends on the configuration and on which mechanisms it advertises.
SRP and why it was broken
SRP is a password-based key exchange protocol. The server stores a verifier derived from the password instead of the password itself, and client and server prove they know that verifier without sending it. Two public numbers are used for this: N, a large prime that defines the group, and g, its generator, plus ephemeral values that each side chooses and does not share until the end.
The delicate part is in the public value sent by the client, known as A. The server computes the shared secret from A raised to its secret exponent, multiplied by the verifier. If A turns out to be a multiple of N, the result of the whole operation is zero, because any multiple of the modulus vanishes inside the group. A well-implemented protocol rejects that value before continuing.
The SRP specification and its profile for TLS explicitly require that check, and here is the flaw: `srp_server_mech_step2` does not perform it. A client can send A equal to N, obtain a secret it knows in advance and finish the exchange as if it had the password. The library accepts the session, derives the keys and leaves the attacker inside with whatever username they have chosen.
The missing check is a single line of code, and its absence does not depend on the server configuration: the library is what decides which values it accepts as public and which it rejects before continuing with the calculation.
The official description adds another effect that is often overlooked. The attacker does not just get in: they learn the session keys the server will use on that connection. In a protocol that promises forward secrecy, knowing the derived key turns impersonation into a position from which the traffic of that specific session can also be read.
A lock that does not work
The base scenario is a network connection without prior credentials. The attacker needs to know that the service speaks SRP, choose a valid username and send the value that zeroes the secret. Neither physical access nor a certificate is needed, and neither is a compromised account. The only condition is that the SRP mechanism is enabled and that the user exists.
That reduces the difficulty to a reconnaissance problem. On mail servers, the mechanism is advertised during negotiation, so discovering it is a matter of one greeting. On directory services, the user list is usually inferable from the system's own design. When the username can be guessed, the flaw becomes a door with the lock in place but without the cylinder.
Severity does not depend on how many services use SRP, but on which ones. A mail server with SRP enabled is not as common as one with PLAIN or LOGIN, precisely because SRP promises more. That promise is the one that breaks, and it tends to be enabled on installations that specifically sought not to depend on TLS to protect the password.
The flaw is not limited to a specific application, so it is worth reviewing the server's full inventory before deciding it does not apply to you and moving on to a more urgent task.
Cyrus SASL: who uses it and what is exposed?
Cyrus SASL is the layer that allows a server to accept several authentication methods without rewriting them. Postfix and Cyrus IMAP are the most cited cases, and the library also appears in commercial products that include it as a dependency without the end customer knowing. In those cases, the vendor's advisory arrives late or not at all, and the administrator finds out about the problem through a mailing list.
Actual exposure depends on three things that should be reviewed separately: whether the package is installed, whether any application loads it and whether SRP is among the accepted mechanisms. The three answers can differ, and the third is the one that gets forgotten. A system can have the library installed for years without using it, and another can use it only with PLAIN because nobody configured anything else.
The case resembles what happened with the authorization error that opened an empty cookie up to root in Xen Orchestra, where the missing check was a single line. In both flaws, the distance between a secure system and a compromised one lies in a validation that the code took for granted, and that is why the patch is small and the review is large.
Neither case requires an elaborate chain. The common lesson is that range checks are easily omitted when the code was written at a time when the attacker was imagined to be cooperative.
Identify whether you are affected
The first step is to identify the installed version, because the flaw affects Cyrus SASL up to and including 2.1.28. On Debian and derived systems, querying the package manager returns the figure in one line. On hand-compiled installations, the version appears in the library headers or in the binary that loads it, and it is worth checking before assuming the system is up to date.
The second step is to look at the mechanisms enabled in each service, not in the system. A `saslauthd` with SRP active is different from one that only accepts PLAIN over TLS. The list is usually in the application configuration, and in Postfix it is queried with `postconf` to see which methods are advertised to clients.
The third is to update when the project publishes the fixed version and install the patch on all services that load the library. Restarting only the first one leaves the rest on the vulnerable version, and that is a common mistake on machines hosting several services at once.
Until the patch arrives, containment means disabling SRP where it is not essential and limiting access to authentication ports to the networks that really need them. It is not an elegant solution, but it reduces the number of clients that can send the value that breaks the calculation.
What this flaw makes clear
Authentication is the point where a slip becomes an incident, because there is no later layer to stop it. A validation flaw in a format parser is contained with luck and with memory limits. An authentication flaw hands over the entire system, and in this case it also hands over the session keys.
The other reading has to do with maintenance. Cyrus SASL is a library from 1990 that is still in production because it works, and that merit also explains why its checks have been reviewed so little. When a project accumulates twenty years of trust, the gaps that remain are small, old and hard to see without looking at the code with the specification at hand.
For the reader who administers a server, the practical conclusion is the usual one and admits no shortcuts. Check the version, look at which mechanisms each service advertises and patch everything that loads the library. It is half an hour of work that avoids a much worse conversation with the security lead.
The UnrealIRCd case, which went from the KEV catalog to a compromised server in a matter of days, shows the cost of postponing that half hour. The difference between the two incidents is not in the severity of the flaw, but in how long it took someone to check the installed version.