Skip to content
Browsa
  1. Blog
  2. Detection

The post-quantum handshake that gives bots away

Chrome's first TLS message now carries a 1,216-byte post-quantum key share. A client that borrows Chrome's User-Agent but not its handshake is visible before any JavaScript runs.

Browsa team4 min readDetection

A bot check does not need JavaScript to spot most scripted clients. The first message of every HTTPS connection, the TLS ClientHello, is sent before the request line and says a lot about the software that built it. Since 2024, Chrome's version of that message carries something many HTTP libraries did not have for a long time: a post-quantum key share.

What Chrome sends now

TLS 1.3 lets a client guess the key exchange the server will pick and send its half of the key in the first message, so the handshake needs one round trip instead of two. Chrome now guesses a hybrid of classic X25519 and a post-quantum scheme, and it got there in three steps:

WhenWhat changedSource
Aug 2023Chrome announces hybrid Kyber key agreement, X25519Kyber768, starting as an option.Chromium blog
Apr 2024Version 124 turns it on by default on desktop (codepoint 0x6399).Intent to ship
Nov 2024Version 131 drops Kyber and offers the standard ML-KEM hybrid, X25519MLKEM768, codepoint 0x11EC.Google Security blog

The IETF draft that defines the hybrid puts the client share at 1,216 bytes: 1,184 for ML-KEM-768 and 32 for X25519. A classic X25519 share is 32 bytes. That one field pushes the ClientHello past what fits in a single packet, which is why some servers broke when Chrome turned it on: they expected the whole hello in one read(). The tldr.fail page documents that bug.

Same User-Agent, different handshake

A scraper that sends a Chrome User-Agent from Python, Go or curl changes one HTTP header. The TLS library underneath still writes its own ClientHello: its own cipher list, its own extensions, its own key share. The server sees the handshake first and the header second.

We pointed six clients at tls.peet.ws, which echoes back the ClientHello it received, on 17 November 2026:

ClientKey shareJA4
Google Chrome, current stable, macOSX25519MLKEM768, X25519t13d1517h2_8daaf6152771_cb7bf5808d99
Phantom, Browsa productionX25519MLKEM768, X25519t13d1517h2_8daaf6152771_cb7bf5808d99
curl 8.7.1, macOS system build (LibreSSL)X25519 onlyt13d497h2_0d8feac7bc37_7395dae3b2f3
Python requests 2.32, OpenSSL 3.6X25519MLKEM768, X25519t13d1712h1_ab0a1bf427ad_882d495ac381
Go 1.26 net/httpX25519MLKEM768, X25519t13d1312h2_f57a46bbacb6_ab7e3b40a677
Node 26 fetchX25519MLKEM768, X25519t13d5212h1_b262b3658495_8e6e362c5eac

Two things stand out. First, the missing key share is now a sign of an old stack, not of every library. OpenSSL added X25519MLKEM768 to its default key shares in 3.5.0 (April 2025). Go offered the Kyber draft by default in 1.23 and switched to ML-KEM in 1.24. Python linked against OpenSSL 3.4 or older, Go before 1.23, and curl builds like the macOS one above still send a classic share only. Go 1.23 sends the 0x6399 draft that Chrome stopped offering in 2024, which is a mismatch of its own.

Second, a matching key share is not a matching handshake. Python, Go and Node all offer ML-KEM now, and none of them looks like Chrome: different cipher counts, different extensions. Python requests offers only HTTP/1.1, and Node lists HTTP/1.1 before HTTP/2. Chrome and Phantom produce the same JA4.

JA4 in one minute

JA4, from FoxIO, turns a ClientHello into a short string with three parts. Take Chrome's:

  • t13d1517h2: TLS over TCP, version 1.3, a domain name in SNI, 15 cipher suites, 17 extensions, and h2 as the first ALPN value.
  • 8daaf6152771: a truncated SHA-256 of the cipher suites, sorted.
  • cb7bf5808d99: a truncated SHA-256 of the extensions, sorted, plus the signature algorithms in their sent order.

JA4 ignores GREASE values and sorts the lists, so a client that shuffles its extension order still gets one stable value. It does not hash the key share bytes, but the extension list and counts move whenever a library's defaults move, and a Chrome User-Agent next to a JA4 that no Chrome release sends is a contradiction a server can check before it serves a byte.

The handshake also changes between Chrome releases. A TLS profile copied from mid-2024 Chrome offers the 0x6399 Kyber share, which Chrome stopped sending in version 131. A frozen copy of Chrome becomes a fingerprint of its own.

Check your own client

Run these from the same machine, library and proxy your agent uses. Replace curl with your client.

Terminal
# JA4 of the ClientHello your client sent
curl -s https://tls.peet.ws/api/all | python3 -c "import sys, json; print(json.load(sys.stdin)['tls']['ja4'])"

# The key exchange Cloudflare negotiated with you
curl -s https://www.cloudflare.com/cdn-cgi/trace | grep kex

Chrome and Phantom print kex=X25519MLKEM768 on the second line. The macOS system curl prints kex=X25519.

To check a whole browser rather than one HTTP client, open browsa.io/detect in your agent's browser. It checks TLS, HTTP/2 and the IP address along with what page scripts can see.

What to do about it

  1. Use a real browser engine. A browser sends its own handshake, so there is nothing to keep in sync. Phantom, Browsa's own browser, uses the same TLS code as Chrome: in the capture above its JA4 matched Chrome's exactly, and so did its HTTP/2 settings fingerprint.
  2. Or use a library that copies the current Chrome. Projects such as curl-impersonate, curl_cffi and uTLS rebuild Chrome's ClientHello outside the browser. Pick a profile for the Chrome version your User-Agent claims, update both together, and run the check above after each update.
  3. Keep the story consistent. The handshake, the HTTP/2 settings, the headers and the User-Agent all describe one client. Changing only the header is the mismatch these checks look for.

None of this gets a client past every bot check. The IP address, the browser's JavaScript surface and its behavior all count too. But the handshake is the first thing a server sees, and it is the cheapest one to get right.

Sources

  1. Protecting Chrome Traffic with Hybrid Kyber KEM, Chromium blog, August 2023
  2. Intent to Ship: X25519Kyber768 key encapsulation for TLS on Desktop, blink-dev, March 2024
  3. A new path for Kyber on the web, Google Online Security blog, September 2024
  4. draft-ietf-tls-ecdhe-mlkem, IETF: codepoint 4588 (0x11EC), client share 1,216 bytes
  5. tldr.fail: servers that read a large ClientHello in one call
  6. Go 1.23 and Go 1.24 release notes, crypto/tls
  7. OpenSSL 3.5 release notes, 8 April 2025
  8. JA4 technical details, FoxIO
  9. Our captures: tls.peet.ws/api/all and Cloudflare's /cdn-cgi/trace, 17 November 2026

Try it

Start free with 100 credits. No card.