One Long Key Name. Your Mail Client Hands Over the Data.

One Long Key Name. Your Mail Client Hands Over the Data.

Your mail client does not have a bug. The encryption library underneath it does — and that is worse. On November 20, 2026, the GnuPG project warned that a single malicious OpenPGP key can trigger a critical memory flaw in GPGME, the standard library programs use to work with GnuPG. The trigger is almost absurdly simple: a key whose user ID — the name attached to the key — is unusually long.

The flaw is tracked as CVE-2026-129975, and it affects all software using GPGME before version 2.3.0 — shared library, Windows DLL, or statically linked. The project says the bug could be used to steal data from affected applications, and that remote code execution cannot be ruled out. No attacks exploiting the flaw have been reported.

One library, a very long blast radius

GPGME is plumbing. It lets everyday programs encrypt, decrypt, sign, and verify without talking to GnuPG directly, and it sits underneath far more software than most people realize.

The project names most mail clients, many XMPP chat clients, Samba, and its own Gpg4win, GnuPG Desktop, and GnuPG VS-Desktop packages as affected examples. One flaw in one shared library reaches every application built on top of it.

Many apps, one shared flaw: mail clients, XMPP clients, Samba and Gpg4win all converge on a single double-free bug in GPGME, tracked as CVE-2026-129975, affecting versions before 2.3.0, with remote code execution not ruled out.
Many apps, one shared flaw.

How a long name breaks memory

The flaw is a double free — the same piece of memory released twice — sitting in two routines, read_status() and read_colon_line(), that read status lines and key listings coming back from GnuPG.

Here is the mechanism, stripped of jargon. When the input runs long, those routines move the data to a larger buffer — a bigger box. They record the new address only if they finish without errors. If an error happens in between, the code is left holding a pointer to memory that was already freed, and cleanup then frees it a second time. That double free corrupts the program’s memory bookkeeping, and in the worst case that corruption is what an attacker steers toward data theft or code execution. It is the kind of bug that hides in plain sight — the blog has covered the same pattern before, when a Linux kernel bug hid for eleven years until a single packet exposed it.

Why this one matters

Three things make CVE-2026-129975 worth dropping everything for. First, the blast radius is the library, not one product: patching your mail client alone does nothing if the library underneath it is still old. Second, there is no workaround — the advisory offers no interim mitigation, so the only defense is the fixed version. Third, disclosure itself was rushed: the flaw was found by Johan Carlsson and reported to the project by GitLab last week, with disclosure set for November 25, but it was moved up because the Ruby2Shell bug forced earlier updates. When a disclosure moves early, stragglers stand out. The one piece of good news is timing: no attacks have been reported, so the gap between now and the first exploit attempt is measured in how fast defenders move.

What to check today

1. Update GPGME to 2.3.1. That is the fixed library version, released this week. Note the version jump: 2.3.0 was never publicly available, so 2.3.1 is the version to look for. If your package manager offers it, take it now; if not, get it from the project’s official downloads.

2. On Windows, update Gpg4win to 5.1.2. The new release bundles the fixed library, and its release notes call the issue severe and say to update as soon as possible. Do not assume an earlier Gpg4win update covers it — check the version number.

3. Rebuild anything that bundles GPGME. This is the step most people will miss. Bundled and statically linked copies are affected too, and updates to the system’s shared library do not reach them — the applications that contain them need their own rebuilt releases. Audit which of your applications link GPGME, including the ones you forgot about: mail clients, chat clients, file-sharing tools, and anything that verifies signatures.

4. Watch how signed data reaches your apps. The known path in is signed data sent to an application. Until your stack is fully patched, treat unexpected signed material — especially anything carrying an unfamiliar key — with suspicion, and confirm the applications your team relies on are on the fixed versions before they handle it.

The fix cycle: update GPGME to 2.3.1, Gpg4win to 5.1.2, legacy branch to 1.24.4, rebuild statically linked apps, and note that no workaround is offered.
The fix is a cycle, not a single update.

One caveat for older deployments: versions that cannot move to 2.3.1 have a patch carried in the advisory, and the legacy branch has its own fixed release, 1.24.4 — but the project cannot guarantee that branch will see every future security patch, so treat it as a bridge, not a home. Two components need nothing at all: GPGMEPP and GPGMEQT require no update.

A long key name should never be able to reach into your mail client and take data out. The defense is unglamorous and complete: update the library, update the bundle, and rebuild everything that carries its own copy. No workaround exists, no attack has been seen yet, and the fix is already out — that combination does not stay favorable for long.

Comments

This site uses Akismet to reduce spam. Learn how your comment data is processed.