Automated Threat Modeling

Cyrus SASL CVE-2026-129483: SRP Pre-Auth Authentication Bypass with PoC Analysis

CVE-2026-129483 is a pre-authentication SRP authentication bypass in Cyrus SASL through 2.1.28. This covers the root cause, a public proof of concept, patch details, and detection guidance.

CVE Analysis

11 min read

Gaurav Sarraf
Gaurav Sarraf

2026-11-15

Cyrus SASL CVE-2026-129483: SRP Pre-Auth Authentication Bypass with PoC Analysis

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 = 0
  • S = 0^b mod N = 0
  • K = 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:

  1. The attacker opens an SRP exchange and sends step1 client to server: { utf8(U) utf8(I) utf8("") os(cn) }, where U is the target username.
  2. The server responds step1 with { 0x00 mpi(N) mpi(g) os(salt) mpi(B) utf8(L) }, disclosing N, g, salt, B, and L.
  3. The attacker computes K = SHA1("") and forges M1 from the disclosed public values.
  4. The attacker sends step2 client to server: { mpi(A) os(M1) utf8("mda=SHA-1") os(cIV) } with A = N.
  5. Because SRP is a server-send-last mechanism, a SASL_CONTINUE response 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 via ctypes bindings to sasl_server_start and sasl_server_step, hand-crafting the SRP wire messages. It runs a negative control (random A, wrong M1) that is rejected, then the attack run with A = N.
  • poc_math.py: a self-contained, stdlib-only proof of the attack math.
  • output.txt: a captured transcript from an --enable-srp build (Ubuntu 22.04, OpenSSL 3.0.2).
  • MANIFEST.sha256 and README.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-srp and --enable-srp-setpass options are gone, along with SRP_LIBS, STATIC_SRP, and DO_SRP_SETPASS.
  • Automake rules in plugins/Makefile.am: libsrp.la and its sources are removed, and srp_init.c is 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 into libsasl2 statically:
-#ifdef STATIC_SRP - SPECIFIC_SERVER_PLUG_INIT( srp, "SRP" ), - SPECIFIC_CLIENT_PLUG_INIT( srp, "SRP" ), -#endif
  • Windows builds: plugins/NTMakefile drops the SRP=1 and DO_SRP_SETPASS=1 options and saslSRP.dll; win32/include/config.h and win32/makeinit.ps1 drop their SRP entries.
  • Init generation and docs: plugins/makeinit.sh no longer lists srp, and the srp_mda option and SRP rows are removed from current documentation. The commit deliberately keeps historical references in the ChangeLog, release notes, and doc/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 (from srp.c / srp_init.c) on Unix and saslSRP.dll on Windows builds made with SRP=1. Statically linked builds define STATIC_SRP.
  • Check SASL configuration for SRP-specific settings such as the srp_mda option, and check whether SRP appears in mech_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 through mech_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

Detect & fix
what others miss

Works with
  • GitHub
  • GitLab
  • Bitbucket
  • Azure DevOps Services
  • Gerrit
  • CVS
  • Jira
  • Linear
  • Slack
  • Security Compass
Explore integrations
Security magnifying glass visualization