The revocation list GoAhead never checked

· Essay

On 26 October Sébastien Féry at FoxIO wrote up three TLS bugs in GoAhead, a small web server that device makers build into their products. FoxIO says it runs in "hundreds of millions of IoT, Firewall, OT, and Military devices". Embedthis, which maintains GoAhead, published advisories on 12 October, and the fixes are in GoAhead 6.1.1.

None of the three breaks any cryptography. Each one is a small mistake in how GoAhead calls a TLS library. The first is the one I keep coming back to: a revocation list that loaded without complaint and was never checked.

Some background

Plenty of devices you'd never call a computer have a web server inside. It's what answers when you type a router's address into a browser to change its settings. Firewalls and industrial controllers work the same way, and GoAhead is one of the web servers they use.

TLS is the encryption behind the padlock in your browser. Normally only the server proves who it is. With mutual TLS (mTLS) the client has to prove who it is as well, by presenting a certificate. A company might require its admins' laptops to present a client certificate before they can reach a device's management page.

Certificates can be cancelled. If a laptop is stolen or someone leaves, the company revokes that certificate and adds it to a certificate revocation list (CRL). The server is supposed to check the list and turn away anything on it.

Mutual TLS is opt-in. The advisories say default GoAhead builds don't check client certificates at all, so two of these bugs only matter to people who set mTLS up on purpose.

The revocation list

GoAhead lets you name a CRL file in its configuration. With the OpenSSL backend, GoAhead loaded the file at startup using X509_STORE_load_locations(). But OpenSSL doesn't check revocation just because a CRL is loaded. The program also has to set a flag, X509_V_FLAG_CRL_CHECK, and GoAhead never set it.

So the list sat in memory and nothing read it. FoxIO tested GoAhead 6.1.0 with OpenSSL 3.6.2. A revoked client certificate, signed by a trusted CA, completed the handshake with issuer checking turned on. The advisory says the load succeeds and nothing warns the operator.

The fix is one line:

X509_STORE_set_flags(store, X509_V_FLAG_CRL_CHECK);

It checks the client's own certificate only. The advisory says it deliberately leaves out X509_V_FLAG_CRL_CHECK_ALL, which would also check the intermediate certificates above it.

Put in everyday terms: the company revokes the stolen laptop's certificate, the device's configuration shows the revocation list in place, the logs are clean, and the stolen laptop still gets in. Embedthis rated it critical, 9.1 on the CVSS scale, as CVE-2026-115881. GoAhead 3.4.5 to 6.1.0 are affected.

I think this is the most useful of the three to understand. The admin who revoked that laptop would reasonably think the job was done, and every check they'd normally do passes. You'd only catch it by revoking a certificate and then trying to connect with it.

The 256-byte number that became one byte

The second bug is in GoAhead's other TLS backend, Mbed TLS. For one kind of TLS 1.2 key exchange, DHE_RSA, GoAhead sets a 2048-bit Diffie-Hellman modulus, which is 256 bytes. The two ends use it to agree on a shared secret that someone listening in can't work out.

This is the call before the fix:

mbedtls_ssl_conf_dh_param_bin(conf, dhm_p, sizeof(dhm_g), dhm_g, sizeof(dhm_g))

The second argument is the modulus, dhm_p, but its length is given as sizeof(dhm_g). That's the size of the generator, which is one byte. It should have been sizeof(dhm_p). So Mbed TLS took the first byte of the modulus, 0xFF, and dropped the other 255.

A one-byte modulus leaves only eight possible shared secrets, where the full 2048-bit one leaves far too many for anyone to try. FoxIO showed that someone who recorded the handshake and the traffic could find the secret and decrypt the session. In their reproduction it took five tries.

It needs a few things to line up: the Mbed TLS backend, a TLS 1.2 DHE_RSA connection, and a client that accepts the broken parameters. The OpenSSL client FoxIO tested refused them with "modulus too small". ECDHE and TLS 1.3 connections aren't affected. Embedthis rated it moderate, 5.9, in an advisory with no CVE. GoAhead 4.0.2 to 6.1.0 are affected.

According to Féry, the typo came in during a 2018 move to the binary-parameter API and survived a TLS refactor in April 2024. That's easy to believe. The line compiles, and connections with lenient clients still work, so nothing looks wrong unless you inspect what was negotiated.

The chain-depth check

A client certificate usually comes with a short chain of others above it, each vouching for the one below, up to one the server trusts. GoAhead limits that chain to a depth of 10. LibreSSL 3.2.x and 3.3.2 to 3.3.6 use an older verifier, and on those a chain that's too deep comes back as error 20 ("unable to get local issuer certificate") instead of the expected error 22 (chain too long). GoAhead only applied its own depth check when no error had been set yet, and with issuer checking turned off its callback accepts error 20. So the depth limit never fired. FoxIO showed it with a 17-certificate chain on LibreSSL 3.3.6.

This one needs mTLS on and issuer checking off. Setups that check the issuer weren't exposed, and neither were builds on OpenSSL, BoringSSL, AWS-LC or LibreSSL 4.x. Embedthis rated it high, 7.4, as CVE-2026-115884 (advisory). The fix in 6.1.1 enforces the depth limit whatever error the library reports.

If you own one of these devices

For most people, probably not much. A home user opening their router's settings page isn't using client certificates, so the first and third bugs don't apply. The second needs a particular TLS setup and a lenient client on the other end. The "hundreds of millions" figure is how many devices run GoAhead. It isn't a count of vulnerable ones, which depends on the TLS library, the version and the configuration.

The bugs matter more to organisations that use client certificates to control who can manage their equipment, because those are exactly the setups they hit.

The fix also doesn't reach a device by itself. GoAhead is compiled into each maker's firmware. The maker has to pick up 6.1.1, test it and ship an update, and then the owner has to install it. The 6.1.1 release notes say it went to device builders on 2 August, and the public release and advisories followed on 12 October. If you run equipment like this with client certificates turned on, ask the vendor whether their firmware includes GoAhead 6.1.1. Until it does, I'd keep the management pages reachable only from trusted networks, and on OpenSSL builds I wouldn't count on revocation to lock out a lost or stolen laptop.

Testing the refusal

All three bugs left the normal case working. Good certificates got in, connections completed and the server started without errors, and that's mostly what tests check.

A security control also needs a test that it says no. For revocation, that means revoking a certificate and trying to connect with it. For key exchange, look at what was actually negotiated, not what the config asks for. And if there's a chain limit, send a chain one longer than it. None of this is hard, and each of those tests would have caught one of these bugs.