Introduction
An unauthenticated client can log into a Cyrus SASL server as any existing user, without the password, by sending a single malformed value in the SRP handshake. The flaw collapses the SRP shared secret to zero and the derived session key to a known constant, which turns a password proof protocol into a free pass for anyone who can reach the service and knows a username.
Cyrus SASL implements the Simple Authentication and Security Layer specification, providing a generic interface so applications can plug in authentication mechanisms. It is widely used shared authentication infrastructure. Cyrus documentation names Sendmail, Cyrus imapd, and OpenLDAP as applications that use the library, and Postfix documents using external SASL implementations as building blocks. The flaw matters to the broader ecosystem because of this reuse across multiple server applications, not because of a single product.
Technical Information
The affected component is plugins/srp.c, specifically the server function srp_server_mech_step2. Secure Remote Password (SRP) is an authentication and key exchange protocol that Cyrus documentation describes as providing authentication, optional mutual authentication, and negotiation of a shared context key. RFC 2945 and RFC 5054 section 2.5.3 require the host to abort authentication when A % N is zero, where A is the client's public value and N is the group modulus.
The root cause is a missing modular check. The reporter's upstream issue shows that the only validation applied to A in the vulnerable code is a positivity test:
/* Per [SRP]: reject A <= 0 */ if (BigIntCmpWord(text->A, 0) <= 0) { /* srp.c:2040 -- ONLY check on A */ SETERROR(params->utils, "Illegal value for 'A'\n"); result = SASL_BADPROT; goto cleanup; }
Because A is never reduced modulo N, a positive value that is a multiple of N (such as A = N) passes this check even though its residue modulo N is zero. That single gap collapses the entire password proof. The reporter describes the resulting calculation:
base = A * v^u mod N = N * v^u mod N = 0S = 0^b mod N = 0K = H(S) = SHA1("") = da39a3ee5e6b4b0d3255bfef95601890afd80709, a known constant
With K reduced to a fixed, publicly computable value, the client proof M1 = H(H(N) xor H(g) | H(U) | salt | A | B | K | H(I) | H(L)) can be computed entirely from public or attacker known values. The attacker forges a valid M1 without the password, and the server accepts it, authenticating the attacker as any existing user and handing over the session keys.
Attack flow
Using the wire protocol documented by the reproducer, the attack proceeds as follows:
- The attacker opens an SRP exchange and sends step1 client to server:
{ utf8(U) utf8(I) utf8("") os(cn) }, whereUis the target username. - The server responds step1 with
{ 0x00 mpi(N) mpi(g) os(salt) mpi(B) utf8(L) }, disclosingN,g,salt,B, andL. - The attacker computes
K = SHA1("")and forgesM1from the disclosed public values. - The attacker sends step2 client to server:
{ mpi(A) os(M1) utf8("mda=SHA-1") os(cIV) }withA = N. - Because SRP is a server-send-last mechanism, a
SASL_CONTINUEresponse at step2 indicates completed, successful authentication.
The published CVE classifies the weakness as CWE-287 (Improper Authentication). The reporter's original issue used CWE-347 and also scored high availability impact (CVSS 3.1 9.8). The formal CVE vectors assign CVSS 3.1 9.1 and CVSS 4.0 9.3 and do not score availability impact.
Proof of Concept
Researcher afldl published a working proof of concept as a GitHub Gist, companion to upstream issue #896 (filed 2026-07-31). The oss-sec disclosure and the VulnCheck advisory corroborate it. The gist contains several artifacts:
srp_bypass_e2e.py: a full end-to-end reproducer that drives the real libsasl2 SRP server mechanism viactypesbindings tosasl_server_startandsasl_server_step, hand-crafting the SRP wire messages. It runs a negative control (randomA, wrongM1) that is rejected, then the attack run withA = N.poc_math.py: a self-contained, stdlib-only proof of the attack math.output.txt: a captured transcript from an--enable-srpbuild (Ubuntu 22.04, OpenSSL 3.0.2).MANIFEST.sha256andREADME.md.
The README documents three prerequisites: SRP must be compiled in (--enable-srp, which is opt-in and non-default), SRP must be offered in mech_list, and the target username must exist.
Reproduction steps from the PoC README and issue #896:
git clone https://github.com/cyrusimap/cyrus-sasl.git cd cyrus-sasl autoreconf -fi && ./configure --enable-srp --enable-srp-setpass --with-gdbm && make && sudo make install echo secret | saslpasswd2 -p -c -u localhost testuser python3 srp_bypass_e2e.py testuser
The captured output demonstrating the bypass:
=== CONTROL RUN (A random, wrong M1) ===
[*] control step2 result=-13 (expect SASL_BADAUTH=-13)
[OK] control run correctly rejected
=== ATTACK RUN (A == N) — user testuser ===
[*] step1 (start) result=1 (SASL_CONTINUE=1)
[+] parsed N (2048 bits), g, salt (16 B), B, L=b'mda=SHA-1'
[*] step2 result=1 (SASL_CONTINUE=1, SASL_BADAUTH=-13)
[!!!] AUTHENTICATED AS: testuser
[!!!] PRE-AUTH SRP AUTHENTICATION BYPASS CONFIRMED
The PoC was verified by reviewing the gist contents (README, poc_math.py, and the full srp_bypass_e2e.py source), the issue #896 report body, and the fix commit. It was not independently executed during this review.
Patch Information
The upstream fix for CVE-2026-129483 does not add the missing check. It deletes the whole SRP plugin. Commit fb3724f43dc50247ff2bf02135457d6d77031654, titled "Remove the SRP plugin", was written by maintainer Ken Murchison on 2026-11-12 and is the fix referenced in VulnCheck's advisory. The commit removes 3,297 lines and adds 24; most of the removed lines are plugins/srp.c itself (3,180 lines). The commit message explains the reason: the SRP SASL mechanism was never standardized and exists only as the expired draft draft-burdis-cat-srp-sasl. The maintainers chose to drop an unmaintained, non-RFC mechanism rather than patch it.
The removal covers every place SRP could be built or loaded:
- Build options in
configure.ac: the--enable-srpand--enable-srp-setpassoptions are gone, along withSRP_LIBS,STATIC_SRP, andDO_SRP_SETPASS. - Automake rules in
plugins/Makefile.am:libsrp.laand its sources are removed, andsrp_init.cis no longer generated:
-libsrp_la_SOURCES = srp.c srp_init.c -libsrp_la_DEPENDENCIES = $(COMPAT_OBJS) $(PLUGIN_COMMON_OBJS) $(CRYPTO_COMPAT_OBJS) -libsrp_la_LIBADD = $(SRP_LIBS) $(LIB_SOCKET) $(COMPAT_OBJS) $(PLUGIN_COMMON_OBJS) $(CRYPTO_COMPAT_OBJS)
- Static plugin table in
lib/staticopen.h: SRP can no longer be linked intolibsasl2statically:
-#ifdef STATIC_SRP - SPECIFIC_SERVER_PLUG_INIT( srp, "SRP" ), - SPECIFIC_CLIENT_PLUG_INIT( srp, "SRP" ), -#endif
- Windows builds:
plugins/NTMakefiledrops theSRP=1andDO_SRP_SETPASS=1options andsaslSRP.dll;win32/include/config.handwin32/makeinit.ps1drop their SRP entries. - Init generation and docs:
plugins/makeinit.shno longer listssrp, and thesrp_mdaoption and SRP rows are removed from current documentation. The commit deliberately keeps historical references in the ChangeLog, release notes, anddoc/legacy.
From this commit onward, a build cannot produce a server that advertises or negotiates SRP. The vulnerable srp_server_mech_step2 no longer exists in the tree.
The targeted check (unofficial)
The bug is easier to understand from a smaller, targeted patch. Issue #896 explains that the server's only check on A was BigIntCmpWord(text->A, 0) <= 0, so A was never reduced modulo N, while the SRP client already checked 0 < B < N. Contributor Nathan Gill wrote the missing check as commit e01ce45cad12d5a614dae8b414487e020d72086a ("plugins/srp.c: add rfc5054 check on A #896"). It adds 10 lines to srp_server_mech_step2 after A is parsed:
+ BIGNUM *rem = NULL; BN_CTX *ctx = NULL; ... + rem = BN_new(); ctx = BN_CTX_new(); + BN_mod(rem, text->A, text->N, ctx); + if (BN_is_zero(rem) || BN_cmp(text->A, text->N) >= 0) { + BN_free(rem); BN_CTX_free(ctx); + SETERROR(params->utils, "Illegal value for 'A'\n"); + result = SASL_BADPROT; goto cleanup; + } + BN_free(rem); BN_CTX_free(ctx);
The two conditions work together: BN_is_zero(rem) rejects every multiple of N (0, N, 2N, and so on), while BN_cmp(A, N) >= 0 limits A to the range [1, N-1], rejecting non-reduced values that would otherwise be silently reduced. A rejected A ends the exchange with SASL_BADPROT before any key is derived. Two caveats apply. GitHub reportedly shows this commit is not on any upstream branch (a claim from one of the input reports that was not independently checked), and the commit does not check whether BN_new() or BN_CTX_new() return NULL, nor does it address a second dead check the reporter flagged in ServerCalculateK, where after BN_add_word(base, 1) the comparison of S against N never fires because S is always less than N. This is an unofficial fix for operators who must keep SRP in an older build. It is not the upstream fix.
Release status
The removal is in the upstream source tree. None of the sources reviewed here identified a tagged Cyrus SASL release that includes it, and the release pages still identify 2.1.28 as the latest.
Detection Methods
The flaw is purely cryptographic and leaves no file, process, or payload behind, so detection focuses on three places: whether the vulnerable mechanism is exposed, what is inside the SRP exchange, and how authentication behaves afterward.
One caution for log monitoring: the Illegal value for 'A' / SASL_BADPROT path in the vulnerable code fires only for A <= 0. An A = N attack passes it without any error. Only builds carrying the suggested modulo patch would log anything for this attack, and upstream did not ship that check (it removed the plugin instead), so on stock builds you should not expect that error string during exploitation.
Step 1: Find your exposure
Exploitation has three prerequisites, all documented in the reproducer README: SRP must be compiled in (--enable-srp, opt-in), it must be offered through mech_list, and the target username must exist. That makes asset discovery the first and most reliable step:
- Look for the SRP plugin on hosts running Cyrus SASL 2.1.28 or earlier. Upstream build files name it
libsrp.la(fromsrp.c/srp_init.c) on Unix andsaslSRP.dllon Windows builds made withSRP=1. Statically linked builds defineSTATIC_SRP. - Check SASL configuration for SRP-specific settings such as the
srp_mdaoption, and check whether SRP appears inmech_list. - From the network side, enumerate which SASL mechanisms each SASL-enabled service (mail, LDAP, and others) advertises to unauthenticated clients. SRP was never standardized as a SASL mechanism, so legitimate use is rare; in most environments, seeing it offered at all is worth investigating.
Step 2: Protocol-level detection (the high-fidelity signal)
The reproducer documents the SRP wire format, which supports a stateful check:
- step1 client to server:
{ utf8(U) utf8(I) utf8("") os(cn) } - step1 server to client:
{ 0x00 mpi(N) mpi(g) os(salt) mpi(B) utf8(L) } - step2 client to server:
{ mpi(A) os(M1) utf8(o) os(cIV) } - Encoding: MPI = 2-byte big-endian length + data; os = 1-byte length + data; utf8 = 2-byte big-endian length + data; each whole buffer has a 4-byte big-endian length prefix.
The detection logic: record N from the server's step1 challenge, parse A from the client's step2 message, and alert if A mod N == 0. The public PoC uses the simplest case where A is byte-for-byte identical to N, so a direct equality test catches it; an arithmetic modulo test also catches variants such as 2N. A legitimate client never sends such a value, because a correct A = g^a mod N is always between 1 and N-1, so false positives should be close to zero. Two limits apply. The check needs both directions of the same session because N comes from the server, and SASL exchanges usually run inside TLS and are often base64-wrapped by the application protocol, which means TLS-terminating inspection, an application-layer proxy, or instrumenting the SASL server itself. No public Snort, Suricata, YARA, or Sigma rule implements this check, so it has to be built from the published wire format.
Step 3: Server-side instrumentation clue
In an attack, the server computes S = 0 and K = SHA1("") = da39a3ee5e6b4b0d3255bfef95601890afd80709. This value never crosses the wire, but on a debug or instrumented build, a derived session key equal to that constant (or S == 0) proves the bypass was triggered.
Step 4: Behavioural and log hunting
Because the attacker ends up properly authenticated, follow-on activity looks like a normal login by the victim. Hunt for successful SASL authentications that used the SRP mechanism, especially from unfamiliar source addresses, against privileged or dormant accounts, or across many usernames from one client. Prioritize any successful SRP login in an environment where nobody is known to use SRP, and correlate with the protocol-level alerts from Step 2 where available.
Validating a specific build
The reporter published srp_bypass_e2e.py, which loads the installed libsasl2 with ctypes and drives the real SRP server code locally. It first runs a negative control (random A with a wrong M1, which a sound build rejects with SASL_BADAUTH = -13) and then the A = N case; a vulnerable build returns SASL_CONTINUE = 1 on step2 and the script prints the confirmation line. This is a local test harness, not a remote scanner, and belongs in a lab or staging copy of your build.
Current state of public detection content
As of publication, the Ethiack Zero tracker lists this CVE as "no check available" with its own check still being built, and NVD returns "CVE ID Not Found" for the record. No vendor IDS signatures or campaign IoCs have been published. Until they are, the most dependable approach is exposure inventory (Step 1) combined with a custom A mod N protocol check (Step 2).
Affected Systems and Versions
- Product: Cyrus SASL (cyrusimap/cyrus-sasl).
- Affected versions: Cyrus SASL through 2.1.28, and the development master code identified in the report.
- Vulnerable configuration: the SRP server mechanism must be compiled in (
--enable-srp, which is opt-in and non-default) and offered throughmech_list, and the targeted username must already exist. Deployments that do not build or offer SRP are not exploitable through this path.
Note that 2.1.28 is at once the upstream fix for the older CVE-2022-24407 SQL escaping issue and an affected release for this SRP bypass, so a prior upgrade to 2.1.28 does not protect against CVE-2026-129483.
Vendor Security History
A concrete historical remediation case is CVE-2022-24407, in which versions 2.1.17 through 2.1.27 failed to escape passwords used in SQL INSERT or UPDATE statements. Debian identifies upstream 2.1.28 as the fix, and the project's release notes list the password escaping correction. That history matters because the same release that fixes the SQL issue remains affected by this distinct SRP flaw. For the SRP case, issue #896 opened on July 31, 2026, and on October 9, 2026 Alan Coopersmith publicly warned on oss-sec of multiple reported security issues, limited maintainer responses, and no new release since 2022. A concrete SRP removal commit nonetheless exists upstream, which shows the distinction between the ability to change source code and the delivery of a deployable security release.
References
- NVD: CVE-2026-129483
- CVE Record: CVE-2026-129483
- Public PoC gist (afldl)
- Upstream issue #896
- Fix commit: Remove the SRP plugin (fb3724f4)
- Vulnerable srp.c (cyrus-sasl-2.1.28)
- oss-sec: Unfixed vulnerabilities in Cyrus SASL
- VulnCheck advisory
- GitHub API: fix commit fb3724f4
- GitHub API: targeted check commit e01ce45c
- GitHub API: issue #896
- Ethiack Zero tracker entry
- Debian security tracker: CVE-2022-24407
- Cyrus SASL Options documentation (mech_list)
- Cyrus SASL System Administrators guide
- RFC 2945
- Cyrus SASL releases



