79% vs 51%: independent neobanks lag on app security. Read the report

Deep Dive

Deep Dive

Cyrus SASL SRP Authentication Bypass (CVE-2026-129483)

A missing check in Cyrus SASL's SRP server lets an unauthenticated client log in as any user when SRP is built; no release carries the fix.

TL;DR

  • A missing check in Cyrus SASL's Secure Remote Password (SRP) server mechanism lets an unauthenticated client log in as any existing user. VulnCheck published CVE-2026-129483 on November 15, 2026.
  • Every release through 2.1.28 is affected when built with the optional SRP plugin. The default build, and the Debian, Ubuntu, Arch and Fedora packages, do not include it.
  • The CVE record rates it CVSS v3.1 9.1 and CVSS v4.0 9.3, both Critical. A public reproducer is attached to the upstream issue. No exploitation is known, and it is not in CISA KEV as of November 16, 2026.
  • No release contains a fix. The upstream commit of November 12, 2026 removes the SRP plugin. Until a release or backport carries it, rebuild without --enable-srp or remove libsrp.so. See "How do I fix it?".

Am I affected?

All of these must hold for a service to be exposed:

  • The service uses Cyrus SASL and offers the SRP mechanism to clients.
  • The library was built with --enable-srp. The upstream configure script defaults to srp=no, and the Debian, Ubuntu, Arch and Fedora packages build without it.
  • The username the attacker targets exists in the SASL password database that the SRP plugin reads.
  • The attacker can reach the service's SASL negotiation. That can be SMTP authentication, IMAP or POP authentication, LDAP SASL bind, or another protocol that embeds SASL.

SRP is an optional mechanism. A service that uses PLAIN, LOGIN, CRAM-MD5, DIGEST-MD5, SCRAM or GSSAPI without SRP is not exposed by this flaw, even on an affected library build.

Build Affected versions Fixed version
Upstream cyrus-sasl with --enable-srp Every release through 2.1.28 No release; commit fb3724f43d removes SRP on 2026-11-12
Upstream default build None, because SRP is disabled Not applicable
Debian and Ubuntu packages None, because the package uses --disable-srp Not applicable
Arch package None, because the package uses --disable-srp Not applicable
Fedora package None, because the source tarball removes plugins/srp* Not applicable
Custom or appliance build with SRP Every release through 2.1.28 Rebuild without SRP, or add the missing check

No release newer than 2.1.28 exists. That release is from February 2022, and the project has published no tag since. The commit that removes the plugin is on the development branch only.

Check whether the SRP plugin is built and loaded:

sudo pluginviewer -s 2>/dev/null | grep -i srp

Check for the plugin file in the system library directories and under /usr/local, where a source build installs by default:

find /usr/lib /usr/lib64 /usr/local/lib /usr/local/lib64 -name 'libsrp.so*' 2>/dev/null

Check which Cyrus SASL package is installed:

dpkg -l | grep -i sasl

On an RPM-based system:

rpm -qa | grep -i cyrus-sasl

If the pluginviewer and find commands return nothing for SRP, the mechanism is not available and this CVE does not apply to that host.

How do I fix it?

No released version contains the fix. Remove the SRP mechanism from the build, or add the missing validation if you need SRP.

  1. If you do not use SRP, rebuild Cyrus SASL without --enable-srp. The upstream default already disables it:
./configure --disable-srp --disable-srp-setpass
make
sudo make install
  1. If you cannot rebuild, remove the plugin file and restart the services that load it:
sudo find /usr/lib /usr/lib64 /usr/local/lib /usr/local/lib64 -name 'libsrp.so*' -exec mv {} {}.disabled \;
sudo systemctl restart postfix

Replace postfix with every service that uses the library. Confirm with pluginviewer -s that SRP no longer appears.

  1. If you need SRP, add the check that the server is missing. Reject a client public value A when A is zero modulo N, before ServerCalculateK() runs. The reporter's gist includes the math and a suggested check. This is a local patch, not a released fix.

  2. Distribution users should follow their vendor's advisory. The Debian, Ubuntu, Arch and Fedora packages do not build SRP, so they are not exposed through this plugin. A vendor may still ship a rebuild for source completeness.

Removing SRP breaks clients that require it. That is the intended trade-off: the mechanism is optional, and no release has been published to repair it. If SRP is part of your authentication design, the local check is the narrower option.

What is the root cause?

The SRP server accepts a client public value A that is a multiple of the group modulus N. That makes the shared secret zero, and the server accepts a client proof that anyone can compute.

This is srp_server_mech_step2() in plugins/srp.c at 2.1.28:

    /* Per [SRP]: reject A <= 0 */
    if (BigIntCmpWord(text->A, 0) <= 0) {
    SETERROR(params->utils, "Illegal value for 'A'\n");
    result = SASL_BADPROT;
    goto cleanup;
    }

The comment says the code rejects A <= 0. The SRP specification also requires the server to reject A when A is zero modulo N. The check is missing. A client that sends A = N passes the A > 0 test and reaches ServerCalculateK().

The server then computes base = A * v^u mod N. With A = N, the base is zero. The shared secret S = 0^b mod N is zero. The session key K = H(S) is therefore H of an empty value, which is SHA1("") for the default digest. The value is the constant da39a3ee5e6b4b0d3255bfef95601890afd80709, and the attacker knows it.

The client proof M1 is a hash of H(N) xor H(g), H(user), the salt, A, B, K, the authorization identity and the digest label. Every value is public or attacker-chosen when A = N and K is the constant. The attacker can compute a valid M1 without the password. The server compares its own M1 with the client's and accepts it.

The client side of the same file checks that B is between zero and N. The server side lacks the matching check on A.

How is it exploited?

An attacker who can reach a service that offers SRP authenticates as any user in the SASL database without knowing that user's password.

  1. The attacker starts the SRP mechanism and sends a valid username.
  2. The server replies with the SRP parameters: the modulus N, the generator g, the user's salt, the server public value B and the digest list.
  3. The attacker sends A = N, a client proof M1 computed from the public values and the constant K, and the client options.
  4. The server computes the same zero shared secret, derives the same K, and compares the proofs. The check succeeds.
  5. The server authenticates the session as the victim and returns the server proof M2. The attacker now holds the session keys.

The reporter's gist contains a full reproducer against a real --enable-srp build. Its captured transcript shows a control run rejected with SASL_BADAUTH and the attack run authenticated as the test user. The upstream issue carries the same material.

No exploitation in the wild is known as of November 16, 2026.

How does the attack flow?

The attacker sends A = N, the server derives a zero shared secret that the attacker can predict, and the forged client proof is accepted as the victim.

flowchart LR A["Attacker starts SRP
as a known user"] --> B["Server sends
N, g, salt and B"] B --> C["Attacker sends
A = N"] C --> D["Server computes
S = 0 and K = SHA1 of empty"] D --> E["Attacker computes M1
from public values"] E --> F["Server accepts M1
and returns M2"] F --> G["Session as
the victim"]

Timeline of CVE-2026-129483: the issue on July 31, 2026, the oss-security list on October 9, the fix commit on November 12 and the CVE on November 15
Figure 1: From the public issue on July 31, 2026 to the CVE on November 15, 2026. Source: Cyrus SASL issue 896, oss-security and the fix commit, checked November 16, 2026

What can an attacker do?

An attacker can authenticate as any existing user the SRP plugin knows, and inherit that user's access to the service.

The conditions are part of the impact:

  • The service must build and offer SRP. The default build and the major distribution packages do not.
  • The targeted username must exist in the SASL password database. An unknown username produces a normal failed authentication.
  • The attacker must reach the service's SASL negotiation. No password and no user interaction are required.
  • The service must grant meaningful access to the authenticated user. That can be mailbox access, directory access or another resource behind the SASL layer.

The attacker also learns the session keys. If the service negotiates a confidentiality or integrity layer after authentication, the attacker holds the keys for that layer. The flaw does not execute code and does not read the password database directly. Its impact is account takeover in the service that uses the library.

No victim is named in the public record, and no exploitation is known.

Why does the fix work?

The upstream fix removes the SRP plugin entirely, so the vulnerable server code is no longer built or loaded.

The commit deletes plugins/srp.c and removes the build hooks. This is the configure change:

-dnl SRP
-AC_ARG_ENABLE(srp, [  --enable-srp            enable SRP authentication [[no]] ],
-  srp=$enableval,
-  srp=no)
-
-AC_MSG_CHECKING(SRP)
-if [ "$srp" != no ]; then
-  AC_MSG_RESULT(enabled)
-  SRP_LIBS="-lcrypto $LIB_RSAREF"
-
-  SASL_MECHS="$SASL_MECHS libsrp.la"

The commit message says the SRP SASL mechanism was never standardized. It exists only as an expired Internet-Draft, and the project chose to delete it rather than repair it. The same commit removes libsrp.la from the plugin list, the SRP entries from the static plugin table, and the --enable-srp-setpass option.

The fix is complete for a build that takes the commit and does not re-add SRP. It is not a code-level correction: a deployment that keeps the plugin still has the missing check. The reporter's suggested correction is to reject A when A is zero modulo N, before ServerCalculateK() runs. A deployment that needs SRP should add that check itself.

No release carries the commit (release status in "Am I affected?"), so distribution vendors must backport the removal or the check.

How do I check if I was compromised?

No indicators of compromise are published. The useful checks are whether SRP was available and whether the authentication logs show SRP logins that should not have happened.

  • Confirm that the host offers SRP with pluginviewer -s | grep -i srp. If it does not, this CVE cannot be reached on that host.
  • Search the service's authentication logs for successful SRP authentications. Mail servers and LDAP servers usually log the username and the SASL mechanism; a login with SRP for an account that should not have logged in is a lead.
  • Compare successful authentications with the account owner's known activity. A login from a new address, a new client or an unusual time is worth investigating.
  • If SRP was enabled and reachable, rotate the passwords of the accounts in the SASL database and review what those accounts can reach. The attacker learns the session keys, so treat sessions established over SRP as exposed.

A failed attempt with an unknown username looks like an ordinary failed login. A host that does not build SRP has no SRP log entries and no exposure through this plugin. With no published indicators, absence of a log entry is not proof that the flaw was not used.

Timeline

  • 2026-07-31: The reporter opens Cyrus SASL issue 896 with the reproducer and the attack math.
  • 2026-10-09: Alan Coopersmith posts "Unfixed vulnerabilities in Cyrus SASL" to oss-security, listing the SRP issue among the open reports.
  • 2026-11-12: Upstream commit fb3724f43d removes the SRP plugin.
  • 2026-11-15: VulnCheck publishes CVE-2026-129483.

FAQ

Is SRP enabled by default?

No. The upstream configure script sets srp=no unless the builder passes --enable-srp. The Debian, Ubuntu, Arch and Fedora packages build without it, so a stock installation of those distributions does not load the plugin.

Which services can be affected?

Any service that builds Cyrus SASL with SRP and offers the mechanism to clients. That includes mail servers that use Cyrus SASL for SMTP, IMAP or POP authentication, and LDAP servers that use it as a SASL provider. Custom applications that call the library directly can be affected too. A service that never offers SRP is not exposed.

Is there a fixed release?

No. The newest release is 2.1.28 from February 2022. The fix is commit fb3724f43d on the development branch, and it removes the plugin rather than repairing it. Until a vendor backports the commit or the check, a build with SRP remains vulnerable.

Can I just disable SRP?

Yes, if no client needs it. Rebuild without --enable-srp, or remove libsrp.so from the plugin directory and restart the service. Both remove the mechanism the attacker needs. The second option is a local change that a package update can undo, so rebuild when you can.

Is it exploited in the wild?

No exploitation in the wild is known. The CVE is not in CISA KEV as of November 16, 2026, and the CVE record has no CISA ADP exploitation assessment. The public reproducer shows the bypass works, so the absence of a report does not make an SRP-enabled service safe.

Does the CVE affect a library build without SRP?

The vulnerable source file is present in the 2.1.28 tarball, but it is not compiled or loaded unless the build enables SRP. The CVE record names the product without stating the build option, so check the build rather than the package version alone. A distribution package that passes --disable-srp is not exposed through this plugin.

Inventory Cyrus SASL builds with Ostorlab

Ostorlab's software composition analysis inventories the Cyrus SASL version and package in your applications and container images, so you can see which builds carry the optional SRP plugin. Scan your dependencies with Ostorlab.

References

  • CVE record for CVE-2026-129483, https://www.cve.org/CVERecord?id=CVE-2026-129483 (checked November 16, 2026)
  • Cyrus SASL issue 896 with the report and reproducer, https://github.com/cyrusimap/cyrus-sasl/issues/896 (checked November 16, 2026)
  • Public reproducer gist, https://gist.github.com/afldl/18d15d3f5a1df99411e35000c7de80db (checked November 16, 2026)
  • Fix commit fb3724f43d, https://github.com/cyrusimap/cyrus-sasl/commit/fb3724f43dc50247ff2bf02135457d6d77031654 (checked November 16, 2026)
  • Vulnerable code in plugins/srp.c at 2.1.28, https://github.com/cyrusimap/cyrus-sasl/blob/cyrus-sasl-2.1.28/plugins/srp.c#L2046-L2051 (checked November 16, 2026)
  • oss-security post "Unfixed vulnerabilities in Cyrus SASL", https://seclists.org/oss-sec/2026/q4/122 (checked November 16, 2026)
  • Debian packaging rules, https://sources.debian.org/src/cyrus-sasl2/2.1.28+dfsg1-9/debian/rules/ (checked November 16, 2026)
  • Arch Linux PKGBUILD, https://gitlab.archlinux.org/archlinux/packaging/packages/cyrus-sasl/-/blob/main/PKGBUILD (checked November 16, 2026)
  • Fedora source-tarball script, https://src.fedoraproject.org/rpms/cyrus-sasl/blob/rawhide/f/make-no-dlcompatorsrp-tarball.sh (checked November 16, 2026)
  • Repology package entries for cyrus-sasl, https://repology.org/project/cyrus-sasl/versions (checked November 16, 2026)
  • CISA Known Exploited Vulnerabilities catalog, https://www.cisa.gov/sites/default/files/feeds/known_exploited_vulnerabilities.json (checked November 16, 2026)