AWS Builder Center
X25519MLKEM768 in the Wild

X25519MLKEM768 in the Wild

AWS KMS already negotiates hybrid post-quantum TLS on production calls, confirmed via CloudTrail and a 20-trial raw handshake benchmark.

Cloud Engineer
I was chasing a completely different rabbit hole. Someone asked me for a quirky Amazon Braket project idea, and while listing quantum novelty apps I ended up asking a more grounded question: does quantum computing actually touch daily life anywhere yet. The honest answer landed on post-quantum cryptography, the migration away from RSA and ECC before a large enough quantum computer can run Shor's algorithm against them.
That migration doesn't need a quantum computer at all. Post-quantum algorithms are classical code, designed to run on ordinary CPUs and resist a quantum attacker. So the Braket idea died, and I ended up checking something more useful instead: is AWS KMS, the service I call from a CLI every day, actually speaking post-quantum TLS on production traffic right now.
AWS KMS supports hybrid post-quantum key exchange, combining ECDH X25519 with ML-KEM768, the key encapsulation mechanism NIST finalized as FIPS 203 in August 2024. Hybrid means the classical exchange still runs in full, so nothing gets weaker; the ML-KEM step is added on top for resistance against a future quantum adversary. AWS documents this, but I wanted to see it happen on a call I made myself, not take the documentation's word for it.

CloudTrail makes this checkable without any special tooling. Every logged API call carries a  tlsDetails  field, and that field names the key exchange algorithm actually negotiated for that specific connection.
aws kms list-keys --region ap-northeast-1
I ran that, noted the timestamp, and looked up the matching event a little later.
aws cloudtrail lookup-events --region ap-northeast-1 \
--lookup-attributes AttributeKey=EventName,AttributeValue=ListKeys \
--start-time "2026-08-27T14:05:20Z" \
--max-results 10
CloudTrail Event history isn't instant. This particular call took about 75 seconds before it was queryable, so the lookup needs to poll rather than fire once. When the event finally showed up, this is what its  tlsDetails  looked like:
"tlsDetails": {
"tlsVersion": "TLSv1.3",
"cipherSuite": "TLS_AES_256_GCM_SHA384",
"clientProvidedHostHeader": "kms.ap-northeast-1.amazonaws.com",
"keyExchange": "X25519MLKEM768"
}
 keyExchange  reads  X25519MLKEM768 . A completely ordinary, signed AWS CLI call had already negotiated the hybrid group, with no special configuration on my end.
CloudTrail alone is convincing, but I wanted to see the actual bytes move, so I connected to the same endpoint directly with  openssl s_client , forcing the offered key exchange group each time.
# classical only
echo | openssl s_client -connect kms.ap-northeast-1.amazonaws.com:443 -groups X25519 -tls1_3

# hybrid PQC
echo | openssl s_client -connect kms.ap-northeast-1.amazonaws.com:443 -groups X25519MLKEM768:X25519 -tls1_3
The hybrid connection reports  Negotiated TLS1.3 group: X25519MLKEM768  and a handshake that read 6,331 bytes and wrote 1,522 bytes, against 5,243 read and 336 written for the classical-only connection. Carrying an ML-KEM768 public key inside ClientHello nearly quintuples what the client sends.

A single trial is indistinguishable from noise, so I scripted 20 handshakes per method against the same endpoint and timed each one. One classical run came in at 82.97ms against a normal range in the high 50s to low 60s, which is exactly the kind of outlier a single measurement would have hidden. Averaged across the full set, classical key exchange took 61.41ms and hybrid took 59.82ms, statistically the same. AWS's own guidance describes the performance cost of hybrid key exchange as hardly perceptible, and this run doesn't contradict that.
Along the way, the benchmark script's JSON output kept failing to parse, and it took a minute to notice why:  bc  prints a value like 0.082975 as  .082975 , dropping the leading zero, which isn't valid JSON. A one-line  sed  to reinsert the zero fixed it. Small, but the kind of thing that eats ten minutes if you're not watching for it.
I put both the CloudTrail evidence and the benchmark results into a report page, in Japanese and English.

The scripts and the aggregate benchmark data are on GitHub. The raw CloudTrail and  list-keys  API responses are excluded on purpose, since they carry my AWS account ID and IAM identity — only the account-agnostic  handshake_results.json  is committed.
I went looking for a fun quantum computing project and came back with something duller and more useful: the migration away from RSA isn't a future thing to plan for. On AWS KMS, it's already the default path a signed API call takes, whether or not you noticed.
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article