Post-quantum cryptography in financial infrastructure: when to start and why now
Encryption that protects data today will be broken later: an attacker collecting traffic now can decrypt it once a large quantum computer exists. In financial infrastructure that turns the question from "when" into "what do we do in the next 12 months".
- The risk is "harvest now, decrypt later": the data is already being collected, only the decryption is postponed.
- The migration starts with an accurate cryptographic inventory — where RSA/ECC is used, who issues it, and what depends on it.
- The first practical step is hybrid key exchange (X25519MLKEM768) in TLS 1.3.
- HSMs and PKI are the bottleneck: without supporting firmware, the migration stalls even when the code is ready.
The risk: collect today, decrypt tomorrow
Almost every encryption discussion I sit in produces the same question: "there is no quantum computer, so why now?". That is not a mistake in physics, it is a mistake in the threat model. The attacker I care about is not trying to break my traffic this evening. He records it, compresses it, stores it and waits. The moment a sufficiently large quantum computer exists, all those recordings become raw material for decryption — including a key exchange that finished long ago.
This point confuses technical people too, so let me spell it out. In TLS 1.3 the session’s symmetric key is derived from an asymmetric exchange, usually ECDHE. The exchange is ephemeral: the private key the server generated for that session is thrown away the moment it ends. But the attacker who recorded the ClientHello and the ServerHello holds the server’s ephemeral public key. Once there is a quantum computer that can solve the discrete logarithm problem on an elliptic curve, it will derive that session’s shared secret from that public key — a session from ten years earlier. Nothing in the recording has expired.
So what does survive the migration? Symmetric encryption itself. Against Grover, AES-256 loses half its computational security, dropping to roughly 128 effective bits, which is still not practical to break. That is why an attack on traffic archives is an attack on key exchange, not on the cipher. It also explains why the right order of priority in the migration is key exchange first and signatures later.
Which data stays sensitive after a decade
When I build a priority list I look at two parameters only: how long the data must stay confidential, and how long the key protecting it stays in use. In financial infrastructure four categories always come to the top:
- Payment and settlement records — payment instructions, account numbers, clearing data and reconciliation files. They are kept for years because of accounting, audit and investigation obligations, so they can be decrypted long after the customer has forgotten the transaction.
- KYC and AML files — identity documents, passport scans, ownership structures and source of funds. This is the only data on the list whose loss cannot be remedied: you cannot reissue a customer’s identity number or fingerprint.
- Contracts and binding documents — loan agreements, letters of guarantee, disclosure agreements and secured assets. Their legal value depends on being able to prove, fifteen years from now, who signed and when.
- Signing keys — code-signing keys, certificate-signing keys and keys belonging to payment systems. They are not exposed retroactively, but once there is a quantum computer new signatures can be forged with them, and that is an immediate threat to everyone who relies on them.
Why "another ten years" is the wrong frame
I hear that sentence about once a week, and it always assumes the work starts when the machine arrives. The opposite is true: the clock starts running on the day the data is captured, not the day the machine is built. If data must stay confidential for fifteen years and the migration in your infrastructure will take six or seven, you are already late today. This is usually called Mosca’s inequality: if migration time plus the shelf life of the data is greater than the arrival time of the machine, you have a problem — even when none of the three is known.
The second reason is the nature of the work. Code can be changed in months. HSM firmware, the root of the certificate authority, supplier contracts and the queue at the validation labs cannot be hurried. Those items are measured in years, and most of them are not under your control. A plan that starts in 2029 is not a plan; it is a bet that every supplier will move exactly on the schedule you imagine. And the third reason: a computer that appears in ten years will decrypt what is captured today as well.
What NIST has approved
In August 2024 NIST published three federal standards that turned a theoretical conversation into an engineering one: FIPS 203, FIPS 204 and FIPS 205. All three are the product of a long, public standardisation process, and all three are meant to replace what we have relied on until now — RSA and ECC — in two separate areas: key transport and digital signatures.
| Standard | Primitive | Main use in financial infrastructure | What is worth knowing |
|---|---|---|---|
| FIPS 203 | ML-KEM — key exchange | Key exchange in TLS 1.3 and in VPNs, and transport of symmetric keys | The most mature component; a public key of about 1.2 KB; the first to deploy |
| FIPS 204 | ML-DSA — digital signature | Code signing, certificates, tokens and documents | A signature of about 2.4 KB; requires support across the whole verification chain |
| FIPS 205 | SLH-DSA — hash-based signature | Trust roots, long-lived signatures and backup | Slow and large; rests on very conservative mathematical assumptions |
The distinction between a KEM and a signature matters more than it seems. A KEM is not a faster version of Diffie-Hellman; it is a different primitive. Instead of both sides deriving a shared secret from public keys, one side generates a key pair, the other wraps a secret with the public key and gets a ciphertext, and the first side extracts the secret from it. In TLS 1.3 this translates into the KEM public key going into key_share and the ciphertext coming back in the server’s response. This is not a one-line change in code, it is a rethink of what happens in the handshake.
What the standards do not solve
The standards define algorithms, not migration. They contain no integration profile for protocols — that is the IETF’s job; no HSM support; no PKI policy; and no answer to the question of what you do with a fifteen-year-old system that nobody maintains. Anyone who reads FIPS 203 and concludes that they have a solution has read only the first half of the sentence. The second half lives with the vendors, the certificate authority and the firmware.
Above the standards sits migration guidance. The 2024 draft of NIST IR 8547 proposes to stop using RSA and ECC by 2030 and to disallow them after 2035. These are not one project’s deadline; they are a frame that says when an algorithm stops being acceptable. I use those dates as an anchor for planning and not as a target, because anyone who waits for 2030 will no longer have time to replace an HSM.
In the government and defence sector it is common to bring NIST timelines forward, and sometimes to prohibit classical algorithms earlier than the commercial market plans. If your customer is a regulatory body, a central bank, or a supplier to one of them, your timeline is their timeline and not the one published in the standard. I recommend establishing this before planning starts, because it changes the order of the phases and who needs to be in the room.
Start with the inventory: CBOM
I have never met an organisation that managed to replace something it did not know existed. The CBOM, the Cryptographic Bill of Materials, is the closest thing to a map available today: a machine-readable document listing which algorithms, certificates, keys and protocols exist in each component, who owns them and when they are due to expire. The idea is identical to an SBOM, with one difference: an SBOM answers the question of which libraries are here, and a CBOM answers the question of what protects what, and with which algorithm.
The practical format is CycloneDX, which defines an entity called cryptographic-asset. The fields are defined in a language that can be verified automatically, so the inventory can be generated on every build instead of being written once a year in a spreadsheet. That is the difference between a document that ages from the day it is born and an operational asset you can hang decisions on.
What goes into the inventory
The list I work from on clearing and settlement infrastructure projects:
- TLS endpoints — every listener, internal and external, including the protocol version, the group actually negotiated and the certificate chain.
- Code and artefact signing — signing keys, signing authorities and how verification is done in the build pipeline and on the installation agent.
- Token signing — the algorithm that signs JWT and OAuth tokens, including tokens issued by third parties and the ones you consume from them.
- Database and storage encryption — disk-level and column-level encryption, wrapping keys in the KMS and how they are rotated.
- HSM firmware and its capabilities — which mechanisms are exposed through PKCS#11 or KMIP, and which firmware version is authorised today.
- Keys at rest — keystore files, API keys and secrets kept in Vault or in Kubernetes, and who owns each one of them.
The sixth item is where most inventories fall down. A listener is easy to map; finding the key that someone pasted into a configuration file in 2019 and never documented is hard. So I also add components with no known owner to the inventory. "Unknown" is a finding, not a failure of the scan, and without it the report lies politely.
{
"bomFormat": "CycloneDX",
"specVersion": "1.6",
"serialNumber": "urn:uuid:1f0c2f8a-5c6d-4d1a-9d6c-0f2b9a4e7c11",
"version": 17,
"metadata": {
"timestamp": "2026-11-10T06:15:00Z",
"component": { "type": "application", "name": "payments-gateway", "version": "4.12.0" }
},
"components": [
{
"type": "cryptographic-asset",
"bom-ref": "crypto:payments-gateway/listener-443",
"name": "payments-gateway TLS listener",
"cryptoProperties": {
"assetType": "protocol",
"protocolProperties": {
"type": "tls",
"version": "1.3",
"cipherSuites": [{ "name": "TLS_AES_256_GCM_SHA384" }]
}
},
"properties": [
{ "name": "owner", "value": "payments-platform" },
{ "name": "pqc-migration-date", "value": "2027-03-31" }
]
},
{
"type": "cryptographic-asset",
"bom-ref": "crypto:payments-gateway/server-cert",
"name": "payments-gateway server certificate",
"cryptoProperties": {
"assetType": "certificate",
"certificateProperties": {
"subjectName": "CN=payments-gateway.internal, O=Sanpu17, C=SG",
"issuerName": "CN=Sanpu17 Internal Issuing CA 2025, O=Sanpu17, C=SG",
"notValidBefore": "2026-09-01T00:00:00Z",
"notValidAfter": "2027-09-01T00:00:00Z",
"signatureAlgorithmRef": "crypto:algorithms/ecdsa-p256-sha256",
"subjectPublicKeyRef": "crypto:algorithms/ecdsa-p256"
}
},
"properties": [{ "name": "owner", "value": "pki-team" }]
}
]
}
Note the properties field. In some tools it is treated as decoration; for me it is the core. Without an owner and without a target date for migration, an asset is only a record. With those two, the inventory becomes a task list you can prioritise and report to the risk committee.
How to keep the inventory current
A static inventory is a dead inventory. The only way I know is to generate it on every build, verify it against the live environment and turn it into a gate in the pipeline. The scan draws on three sources: static analysis of the code and configuration that finds cryptographic calls and key files, parsing certificates from the keystore and from the certificate authority, and probing endpoints after deployment — that is, what the server actually presents and not what the repo says.
The gate itself is simple. Every new cryptographic asset has to carry a target date for migration, and if a classical asset is added without a date, the build fails. That sounds harsh, and that is exactly the point: otherwise every sprint adds another piece of RSA, and next year the inventory is bigger than the one you started from.
#!/usr/bin/env bash
set -euo pipefail
cbom="artifacts/cbom.json"
# classical crypto assets without a migration target date — the build fails
jq -r '.components[]
| select(.type == "cryptographic-asset")
| select(.cryptoProperties.assetType == "algorithm")
| select(.name | test("RSA|ECDSA|ECDH|Ed25519|P-256|P-384"; "i"))
| select(((.properties // []) | map(select(.name == "pqc-migration-date")) | length) == 0)
| .bom-ref' "$cbom" > unplanned.txt
if [ -s unplanned.txt ]; then
echo "legacy crypto without a migration date:"
cat unplanned.txt
exit 1
fi
Alongside the gate I add two things. One is signing the CBOM as an attestation, so that you can prove to an auditor what was known and when. The other is a daily drift check that compares the inventory with the real state and alerts on an asset that appears in production and is not in the inventory. That drift is usually the third party or the old equipment — exactly the places that get forgotten.
Hybrid key exchange in TLS 1.3
The first phase I recommend carrying out is key exchange on the wire. The reason is simple: this is the only point where data is captured today and exposed retroactively, and it is also the change that is easiest to roll back. In TLS 1.3 you can add a hybrid group without breaking certificates, without touching PKI and without replacing an HSM.
The group in common use today is X25519MLKEM768. The name describes exactly what happens: two secrets are produced in parallel, one from X25519, that is classical ECDH, and one from ML-KEM-768, and the final secret is derived from a combination of both. Whoever holds both secrets computes the key; whoever holds one of them does not.
Why hybrid and not pure PQC
I run into two extreme positions: "if we are migrating, we migrate clean" and "PQC is not ready, we wait". Both miss the idea of hybrid. Hybrid gives you two defences at the same time. If ML-KEM falls tomorrow because of progress in lattice cryptanalysis, X25519 still protects the traffic. If a quantum computer appears, ML-KEM still protects, because X25519 is the fragile half. Anyone who wants to break the session has to break both of them, and that is exactly what I want.
There is also a boring and important aspect to it: compatibility. An unfamiliar group in the ClientHello is a place where old network equipment tends to fail quietly, and not always with a clean failure you can diagnose. Hybrid lets you leave X25519 on the list, and that is what keeps the old equipment alive during the migration.
Configuration: what it looks like in practice
# nginx with OpenSSL that supports ML-KEM; hybrid group first, gradual fallback
ssl_protocols TLSv1.3;
ssl_ecdh_curve X25519MLKEM768:X25519:P-256;
ssl_prefer_server_ciphers off;
ssl_session_cache shared:SSL:32m;
ssl_session_timeout 1h;
server {
listen 443 ssl;
server_name payments-gateway.internal;
ssl_certificate /etc/nginx/tls/payments-gateway.pem;
ssl_certificate_key /etc/nginx/tls/payments-gateway.key;
# the log must show the group actually negotiated, not the one we asked for
log_format pqc '$remote_addr $ssl_protocol $ssl_curve $ssl_session_reused';
access_log /var/log/nginx/payments-pqc.log pqc;
}
A quick check that the group is really being offered is openssl s_client -connect payments-gateway:443 -groups X25519MLKEM768 -tls1_3. If the connection succeeds and you see the group in the $ssl_curve variable in the log, you have hybrid at the front door. In Go the picture is similar: crypto/tls offers the group by default in recent versions, and you can force an order of preference through CurvePreferences. That is a change of one line, not of architecture.
What to measure before widening the rollout
Three things, in this order. The first is handshake size: the ML-KEM-768 public key is about 1,184 bytes and the ciphertext about 1,088 bytes, so the ClientHello grows by about 1.2 KB and the response by roughly the same order of magnitude. That sounds negligible until it meets the MTU: a packet that crosses the 1,500-byte boundary needs fragmentation, and there are network boxes that behave badly with that fragmentation. In QUIC it is felt even more, because the Initial packet is limited to a smaller MTU from the outset.
The second is compute cost. ML-KEM is fast, but the hybrid group computes two secrets on every handshake. That said, most of the load disappears once session resumption comes into play, so the right metric is not overall CPU but CPU per new handshake. The third, and the most important of all, is the failure rate per peer: I want to see a distribution of handshake failures by destination, because that is where the middlebox returning an RST for an unfamiliar group hides. Without that metric you will discover the problem through a customer, and that is always more expensive.
The rollout comes in three waves: internal traffic between services, where both ends are under my control; endpoints facing partners, ordered by data sensitivity; and finally end customers and browsers, where the pace is set by others. In each wave I keep a classical fallback group and remove it only once the metrics show no regression.
Signatures, certificates and PKI
Once traffic is protected, the hard question remains: what to do about identity. Here I separate two completely different threats. Key exchange puts confidentiality at risk retroactively; a signature puts authenticity at risk in real time. A quantum computer will not make it possible to retroactively forge a signature made in 2024, but once it exists it will make it possible to forge a signature on a new certificate, on a firmware update or on a new document. That difference determines the order of operations, which is why I do not treat the two as a single task.
Where signatures break
In four places, and each has a different pace. Code signing: an artefact signed today will be verified in five or ten years, so anyone who can forge a signature can install malicious code without breaking a key. Certificate signing: forging a server certificate allows impersonation, and that is a direct threat to mTLS and to every Zero Trust design that rests on service identity. Document and contract signing: here the problem is double, both future forgery and the ability to deny an existing signature. And firmware signing: a firmware update for an HSM or a switch is the attack vector people talk about least.
The practical conclusion is that a signature needs supporting evidence. A valid signature today has to come with a timestamp and a public record, otherwise in ten years you will not be able to prove that it was created before the quantum computer existed. That sounds like a legal detail, but it is what holds a loan agreement up in court.
Hybrid certificates and sizes
A hybrid certificate carries two public keys and two signatures, classical and post-quantum. The idea is identical to TLS: a verifier that only knows ECDSA still works, and a verifier that knows ML-DSA also gets the new protection. The problem is that there is not yet one agreed way to package this, and every verifier in the chain has to understand the structure. Until standardisation settles this is a choice that needs testing in every component of the environment, and not only at the edge.
Sizes are the less discussed and the more disturbing side. An ML-DSA-44 signature is about 2.4 KB and a public key about 1.3 KB, against a few tens of bytes in ECDSA. A single certificate grows to about 4 KB, and a chain of three certificates adds about 10 KB to the handshake. That affects too many places at once: header buffers in a load balancer, revocation lists that swell, OCSP responders and keystore files. SLH-DSA is worse still, because its signatures are roughly three times larger, so it suits trust roots and not leaf certificates.
Short-lived certificates are the remedy. If the certificate lives for an hour, chain size stays a performance problem rather than a management problem, and rotating an algorithm becomes a change in the issuer’s configuration. That is also what makes the migration practical: I am not replacing a trust root, I am shortening certificate lifetimes and re-running the automation. Tools such as cert-manager and SPIFFE are not decoration in this story; they are what makes it possible to swap an algorithm without a project.
Certificate authorities and root lifetimes
With public certificates you are not alone. Certificate authorities, the CA/Browser Forum and the browser programmes decide which algorithms and structures are allowed, and their timelines do not depend on you. A hybrid certificate that a browser verifier does not recognise is not a certificate, it is a file. So on external infrastructure I plan a migration on two tracks: hybrid where the verifiers are ready, and classical with a planned expiry date everywhere else.
On internal infrastructure the situation is the reverse, which is why I start there. An internal root is created on a particular date and lives for fifteen or twenty years. If I create it in 2027 with ECDSA, I have put a fragile algorithm into the trust chain until 2047. So I recommend a parallel root hierarchy with PQC capability from today, even if the signatures themselves are still classical, and clear documentation of how a new root reaches every trust store. This is the phase nobody likes to plan and everybody gets stuck in later, because it touches every client, every device and every supplier that cannot be updated.
HSMs, firmware and regulation
If there is one phase where migration plans break, it is this one. Code can be rewritten in a quarter; HSM firmware cannot. The device that holds the keys has to implement the new algorithm, generate keys inside itself and hold keys of new orders of magnitude — all of it under a valid FIPS 140-3 validation. Those three conditions do not move at the same pace, and between them lies the gap that only shows up during testing.
The real bottleneck
The lag comes from three layers. The first is hardware: not every model can run ML-KEM and ML-DSA at the performance a clearing environment requires. The second is firmware: even when the hardware can, the manufacturer has to release a version, and it has to go through validation again — lab, queue and certification. The third is documentation: the validation certificate lists which algorithms and mechanisms are permitted, and new firmware under an old certificate is not a solution that survives an audit.
Hence the rule I keep repeating: a PQC project that does not budget for firmware and hardware upgrades is a documentation project. There is no shame in that, but it is something you should find out from the vendor rather than assume. I wrote about key work inside an HSM in a financial environment separately in the guide to key management with HSMs, and that is the background worth reading before the conversation with the manufacturer.
What to ask the HSM vendor
- Which mechanisms are exposed through PKCS#11 or KMIP for ML-KEM and ML-DSA, and are the keys generated and kept inside the device without export?
- What is the performance per operation — key generation, wrapping, signing — and not just the statement that the algorithm is supported?
- Is there built-in hybrid support, or do I have to combine the two secrets in the application myself?
- Which firmware version implements this, when is a FIPS 140-3 certificate expected for it, and where does that appear on your roadmap?
- Can an old and a new algorithm run in parallel on the same partition, and what is the rollback path?
- Can a backup taken before the upgrade be restored after it? That is the quiet failure that brings HSM migrations down.
I bring these questions into the room before signing, not after. They also end up as clauses in the contract, and that is the difference between "the vendor said" and "the vendor committed". A dated commitment to support FIPS 203, 204 and 205; the right to receive firmware updates without buying new hardware; a reasonable notice period before end of support; a commitment to support hybrid mode and not only pure PQC; performance figures per operation; and an obligation to export keys and secrets in a documented format on leaving the vendor. I also add an evidence requirement — validation certificate number, firmware version and date — because without those there is no way to report a state.
The Singapore context
In Singapore the frame is risk management, not a list of algorithms. The MAS Technology Risk Management Guidelines, read alongside MAS Notices 644 and 655 on cyber security management and cyber hygiene, expect financial institutions to govern technology risk and manage cyber resilience, and MAS expects cryptographic risk to be managed as part of that technology risk rather than left to individual engineering teams. The Cyber Security Agency of Singapore publishes advisories and guidance, and its posture on quantum-safe migration is that organisations should plan the transition before the algorithms they rely on stop being acceptable. The Personal Data Protection Act 2012 and the PDPC add responsibilities around how personal data is kept and used. None of them mandates a move to PQC today, and I do not attribute such a requirement to them. But all three create the same question: if you are required to manage risk over time and to keep data for years, you cannot ignore the fact that the protection around it breaks on a date that is not known.
That is why I put the subject on the risk committee’s work plan and not in a separate technical discussion: once it is framed as a risk with a timeline, an owner and an accepted residual risk, it gets a budget.
A practical migration plan
I do not believe in five-year PQC plans with a single Gantt chart. I believe in four phases, each of which ends in something you can show to others.
- Phase 1 — mapping and ownership. An automated CBOM for every service, an owner for every asset and a target date for every classical algorithm. What counts as done: you can produce a report showing which classical assets exist, who owns them and when they are scheduled to migrate — and a daily drift check finds no gaps between the inventory and the production state.
- Phase 2 — protecting traffic. Hybrid exchange in TLS 1.3 on every internal endpoint, and then towards partners. What counts as done: all internal traffic reports a hybrid group in the log, a metric for handshake failures by destination exists, and a controlled rollback has been exercised at least once.
- Phase 3 — identity and signing. Hybrid certificates on internal infrastructure, code signing with ML-DSA alongside the classical signature, and renewal of the root chain. What counts as done: the internal certificate authority issues hybrid certificates, every verifier in the environment can validate them, and there is a documented process for double-signing artefacts.
- Phase 4 — closure and reduction. Stopping new issuance of classical algorithms, handling exceptions and calibrating against the NIST IR 8547 timelines. What counts as done: no new issuance of RSA or ECC, every exception recorded with a date, and the inventory showing a measured decline rather than a declaration.
Between the phases there are two dependencies that I write down explicitly. Phase 2 cannot end before Phase 1 is accurate enough, because you cannot roll out a change in an environment you do not know. And Phase 3 depends on firmware, so the conversation with HSM vendors starts in Phase 1 and not in Phase 3. Anyone who leaves the vendors until the last phase discovers too late that their queue is longer than the entire plan.
If the timeline in your plan puts the migration in 2030, you are assuming that every vendor, every validation lab and every certificate authority will move exactly according to what suits you. In practice, firmware, FIPS certificates and trust roots are the slowest items in any migration. I recommend setting an earlier internal target and treating 2030 as the external timeline on which the algorithms stop being acceptable, not as the goal.
On every migration I have led, a third of the inventory was outside my control: a clearing provider, a settlement house, a portfolio management system, a network box we were handed ten years ago. Ask them for their timeline in writing, enter it into the inventory as an asset, and record whoever has no answer. Better to discover in 2026 that thirty vendors have no PQC plan than to discover it in 2029.
Key takeaways
- The main threat is "collect today, decrypt tomorrow": traffic captured now will be opened once a quantum computer is available, so the clock starts at the date of capture and not at the date of development.
- The most sensitive data is the data you cannot reissue — KYC files, payment records, contracts and signing keys. That is where you start, and not with whatever is easy to map.
- FIPS 203, 204 and 205 are the tools and not the plan. The migration starts with a CBOM that is updated in the build pipeline, not with a document written once.
- The first practical step is a hybrid X25519MLKEM768 exchange in TLS 1.3, with measurement of handshake size, compute cost and failure rate per peer.
- HSMs, firmware and FIPS certificates are the bottleneck. Start with them, put them into the contract and do not leave them for the last phase.
Sources and links
- NIST FIPS 203 (ML-KEM) — the key-exchange standard, the basis for hybrid exchange in TLS 1.3.
- NIST FIPS 204 (ML-DSA) — the digital signature standard, intended for code, certificate and document signing.
- NIST FIPS 205 (SLH-DSA) — the hash-based signature standard, conservative and slow, suited to trust roots.
- NIST Post-Quantum Cryptography project — an overview of the programme, the standards and the migration guidance.
- CycloneDX CBOM — the specification for the cryptography inventory (Cryptography Bill of Materials).
- RFC 8446 (TLS 1.3) — the specification of the protocol in which the hybrid exchange happens.
- NIST FIPS 140-3 — security requirements for cryptographic modules, the basis for HSM validation.