Skip to main content
A vintage portable television and an old tablet with blank screens on a terracotta sideboard, a metaphor for old devices that can no longer complete a TLS handshake with Supabase after the CBC cipher removal
8 min readBy Carlos Aragon

Supabase TLS Handshake Failure After CBC Cipher Removal

If a client started failing to reach Supabase with a TLS handshake error this week, it's almost certainly the CBC cipher removal: four TLS 1.2 cipher suites are gone from <ref>.supabase.co, and any client that can't do TLS 1.3 or GCM now gets cut off before it sends a single HTTP request. Supabase announced it for "November 10, 2026 at the earliest." This morning I checked one of my own projects. It's live. Here's what I measured, which devices actually lost access, and the proxy workaround I tested for the ones you can't update.

Is the Supabase CBC Cipher Removal Live Yet?

Yes, at least on my project. I forced OpenSSL 4.0.3 onto each of the four suites from the Supabase TLS docs and every one failed with alert 40. The six remaining GCM and ChaCha20 suites connected, and so did TLS 1.3. The nice part: api.supabase.com is explicitly out of scope, so it still offers the old suites and works as a before/after control from the same company.

$ H=<ref>.supabase.co
$ openssl s_client -connect $H:443 -servername $H -tls1_2 -cipher ECDHE-RSA-AES128-SHA256
...:error:0A000410:SSL routines:ssl3_read_bytes:tls alert handshake failure:...:SSL alert number 40

$ openssl s_client -connect $H:443 -servername $H -tls1_2 -cipher ECDHE-RSA-AES128-GCM-SHA256
New, TLSv1.2, Cipher is ECDHE-RSA-AES128-GCM-SHA256

$ openssl s_client -connect api.supabase.com:443 -servername api.supabase.com \
    -tls1_2 -cipher ECDHE-RSA-AES128-SHA256
New, TLSv1.2, Cipher is ECDHE-RSA-AES128-SHA256      # Management API: still offered

Run that first command against your own project ref. A handshake failure on the CBC suite plus a clean connect on GCM means the change has reached you. TLS 1.0 and 1.1 were already off before this, so nothing changed there.

What Does the Error Look Like in My Client?

It depends on the TLS stack, but it's always a handshake failure, never an HTTP status. I pinned three clients on my Mac mini to a single CBC suite to capture the real strings:

# curl 8.7.1 (LibreSSL 3.3.6), client forced to a CBC suite
curl: (35) LibreSSL/3.3.6: error:1404B410:SSL routines:ST_CONNECT:sslv3 alert handshake failure

# Python 3 (OpenSSL 3.6), urllib
urlopen error [SSL: SSLV3_ALERT_HANDSHAKE_FAILURE] ssl/tls alert handshake failure (_ssl.c:1082)

# Node 26, tls.connect({ ciphers: "ECDHE-RSA-AES128-SHA256", maxVersion: "TLSv1.2" })
ERR_SSL_TLS_ALERT_HANDSHAKE_FAILURE ... SSL alert number 40

# Same three clients with ECDHE-RSA-AES128-GCM-SHA256
HTTP 401   # reached PostgREST, which wanted an apikey. TLS is fine.

Browsers show ERR_SSL_VERSION_OR_CIPHER_MISMATCH, .NET Framework says "Could not create SSL/TLS secure channel," and Java throws SSLHandshakeException: Received fatal alert: handshake_failure, per Supabase's troubleshooting note.

The part that wastes people's time: the failed request never shows up in your API logs. The connection dies before Auth, PostgREST, Storage or Realtime ever see it. If a user reports "the app can't connect" and your logs are clean for their account, check their device before you check your RLS policies.

One thing worth knowing: a modern curl, Python or Node client won't hit this on its own. They all offer GCM and TLS 1.3 by default. I had to pin the cipher list to break them. So if a server-side job broke this week, look for a hard-coded cipher string in its config. That's the one place modern code can still trip on this.

Which Devices Can't Connect to Supabase Anymore?

Supabase's docs say "end-of-life software" without naming any. I wanted names, so I ran testssl.sh (3.3dev) with ALL_CLIENTS=true, which replays 177 recorded ClientHellos from real browsers, phones, runtimes and bots, against my project and against api.supabase.com. Then I diffed the two.

Nine clients connect to the Management API but fail on the project API. Every one of them used ECDHE-ECDSA-AES128-SHA256 before.

ClientCipher on api.supabase.com<ref>.supabase.co
Safari 5 on iOS 5.1.1ECDHE-ECDSA-AES128-SHA256No connection
Safari 6 on iOS 6.0.1ECDHE-ECDSA-AES128-SHA256No connection
Safari 7 on iOS 7.1ECDHE-ECDSA-AES128-SHA256No connection
Safari 8 on iOS 8.0 beta and 8.4ECDHE-ECDSA-AES128-SHA256No connection
Safari 7 on OS X 10.9ECDHE-ECDSA-AES128-SHA256No connection
Safari 8 on OS X 10.10ECDHE-ECDSA-AES128-SHA256No connection
Chrome 30 on Windows 7ECDHE-ECDSA-AES128-SHA256No connection
Opera 17 on Windows 7ECDHE-ECDSA-AES128-SHA256No connection

The line sits right at Apple's 2015 releases:

  • iOS 9 and OS X 10.11 still connect, on ECDHE-ECDSA-AES128-GCM-SHA256. So does Apple's ATS profile for iOS 9.
  • iOS 8.4 and OS X 10.10 don't.That's the iPhone 4 (stuck on iOS 7.1.2), the first iPad (iOS 5.1.1), and any device someone never updated.
  • Chrome 31 and later, Firefox 27 and later, IE 11 on Windows 7, Android 4.4, and Java 8u31 all still connect.

Another 42 clients fail on both hosts, so this change didn't touch them: Android 4.3 and older, IE 6 through 10, Java 6 and 7u25, and old crawler profiles. They only speak TLS 1.0, which Supabase dropped years ago. If one of those is your broken client, the CBC removal isn't the cause.

Two honest caveats. A replayed ClientHello tests the cipher negotiation, not certificate trust or what a real app's networking layer adds on top. And the docs mention smart TVs, set-top boxes and embedded HTTP clients, which no simulator covers. For those, test the actual device against /auth/v1/health.

Does This Affect the Pooler or Direct Postgres Connections?

No. Supabase scopes the change to the HTTP APIs (Auth, Data API, Storage, Realtime and Edge Functions), on <ref>.supabase.co and on custom domains. I checked the session pooler anyway with openssl s_client -starttls postgres on ports 5432 and 6543.

The pooler already refused ECDHE-RSA-AES128-SHA256, with a different alert: 71, "insufficient security." GCM negotiated fine. So a CBC-only Postgres driver wasn't connecting before this week either. Direct db.<ref>.supabase.codidn't resolve over IPv4 from my network, so I couldn't test it.

Same story for the keys themselves: this has nothing to do with the legacy API keys migration or permission denied for table errors. Those come back as HTTP responses. This one never gets that far.

How Do I Keep Old Devices Working With Supabase?

Update them if you can. For an iOS app on the system networking stack, a deployment target of 9.0 or later means every user who can install it negotiates a supported suite (that matches the iOS 9 and ATS 9 results above). For a server, update the OS or TLS library, or delete the pinned cipher list.

When you can't (a kiosk, a warehouse scanner, a client's old iPad running a one-off app), Supabase suggests a proxy you control. I built one with stock nginx:alpine in Docker to see if it really works, Realtime included:

events {}
http {
  map $http_upgrade $connection_upgrade { default upgrade; '' close; }

  server {
    listen 443 ssl;
    server_name legacy-api.example.com;
    ssl_certificate     /etc/nginx/cert.pem;   # must chain to a root the OLD device trusts
    ssl_certificate_key /etc/nginx/key.pem;

    # Client side: keep one CBC suite for the devices you can't update
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-SHA256:ECDHE-RSA-AES256-SHA384;

    location / {
      proxy_pass https://<ref>.supabase.co;
      proxy_ssl_server_name on;
      proxy_ssl_name <ref>.supabase.co;
      proxy_ssl_verify on;
      proxy_ssl_trusted_certificate /etc/ssl/certs/ca-certificates.crt;
      proxy_set_header Host <ref>.supabase.co;

      # Realtime needs the WebSocket upgrade passed through
      proxy_http_version 1.1;
      proxy_set_header Upgrade $http_upgrade;
      proxy_set_header Connection $connection_upgrade;
    }
  }
}

Then I pointed a CBC-only client at it:

$ curl -v --tls-max 1.2 --ciphers ECDHE-RSA-AES128-SHA256 \
    https://<proxy>/auth/v1/health -H "apikey: <publishable key>"
* SSL connection using TLSv1.2 / ECDHE-RSA-AES128-SHA256
HTTP 200   {"name":"GoTrue","version":"v2.197.0", ...}

$ curl ... same flags, straight to https://<ref>.supabase.co/auth/v1/health
HTTP 000   (handshake failure)

$ curl ... Upgrade: websocket  https://<proxy>/realtime/v1/websocket?apikey=...&vsn=1.0.0
HTTP/1.1 101 Switching Protocols

Auth answered 200 and Realtime upgraded to a WebSocket, for a client that gets a handshake failure going direct. Three things will bite you if you skip them:

  • The proxy's certificate has to be trusted by the old device. My test used a self-signed cert with -k. In production, Let's Encrypt won't work for the devices you're rescuing: its compatibility list starts at iOS 10 and macOS 10.12.1, newer than every Apple client in the table above. Use a certificate that chains to an older root, or install a profile on the devices if you manage them. (Supabase's own chain goes up to GlobalSign Root CA from 1998, so trust likely wasn't what blocked these devices before.)
  • Set Host and SNI to the project domain. Without proxy_ssl_server_name on the upstream handshake has no SNI, and without the Hostheader Supabase doesn't know which project you mean.
  • Watch your access logs.Realtime passes the API key in the query string, and nginx's default log format wrote mine to disk. A publishable key is fine there. Anything stronger isn't. Strip the query string from the log format.

Keep the proxy's client-side cipher list as short as you can, and put a GCM suite first so every device that can use it does. You're deliberately running a weaker endpoint, so only the legacy devices should ever see that hostname. I wrote about the same kind of front door for a ComfyUI reverse proxy, where the Host and Origin headers were the whole fight too.

Should I Worry About This at All?

For most apps, no. Supabase measured under 0.0001% of connections using these suites in September, and emailed the owners of projects that saw any. If you didn't get that email around October 14, your traffic probably didn't include them.

Where I'd actually look: anything a client of yours deployed years ago and forgot about. Lobby tablets, a check-in iPad on iOS 8, a Windows 7 box with a pinned Chrome, an embedded device on old firmware. Those don't show up in your analytics because they're not "users," and now they can't show up in your API logs either. Those are the ones that break quietly. This month has been full of Supabase changes, by the way. If you missed it, the Supabase CLI v3 changes will break more CI pipelines than this cipher change breaks devices.

FAQ

Why do I get a TLS handshake failure connecting to Supabase?

If it started on or after November 10, 2026, it's most likely the CBC removal. The client can't use TLS 1.3, and the only TLS 1.2 suites it shares with Supabase are the four that were removed.

Which devices can't connect to Supabase after the CBC cipher removal?

In my test: Safari on iOS 5.1 through 8.4, Safari on OS X 10.9 and 10.10, Chrome 30 and Opera 17 on Windows 7. iOS 9, OS X 10.11, Chrome 31, Android 4.4 and Java 8 still connect.

Does the CBC removal affect the pooler or direct Postgres connections?

No. Direct Postgres, the pooler and the Management API are out of scope. The pooler already refused the CBC suite I tried, and api.supabase.com still accepts it.

How do I keep old devices working with Supabase?

Update them, or route them through a TLS-terminating proxy you control that offers a CBC suite to the device and connects to Supabase with GCM. Use a certificate the old device trusts.

Got a Device That Stopped Talking to Supabase?

I build and run Next.js and Supabase apps for real businesses, including the old hardware nobody wants to touch. Tell me what broke and I'll tell you whether it's the cipher change, and what the cheapest fix is.

Related Posts