You can't migrate what you can't see: finding your quantum risk with a CBOM
Every organisation has to move off quantum-vulnerable cryptography, and most can't yet say where it's in use. Here's why the answer lives in your traffic rather than your spreadsheets, how VeilNet's observer reads it without touching it, and how that becomes a cryptography bill of materials and a migration plan.
Ask an IT team which of their systems still rely on RSA, and the honest answer is usually “we're not sure”. That isn't a failing. Cryptography is everywhere and almost never visible: inside web servers and databases, VPNs and mail relays, backup agents and build tools, each one choosing its algorithms quietly, connection by connection.
For a long time that didn't matter much. It matters now, because the algorithms most of those connections depend on are the ones a large quantum computer is expected to break, and the deadlines for replacing them have started to arrive.
The clock has already started
This is urgent even though no such quantum computer exists yet. An attacker can record encrypted traffic today, keep it until one does, and decrypt it then. It's called harvest now, decrypt later, and it means anything that has to stay secret for years is already at risk if it crosses the network protected by classical key exchange. Our walkthrough of how Shor's algorithm breaks RSA shows why.
Governments have started setting dates:
- NIST's transition plan, IR 8547, published in final form in October 2026, deprecates quantum-vulnerable public-key cryptography such as RSA and elliptic curves after 2030, and disallows it after 2035.
- In Australia, the Australian Signals Directorate's guidance is to stop using traditional asymmetric cryptography by the end of 2030.
- In the US, a June 2026 executive order, and OMB memo M-26-15 that followed two days later, told federal agencies to cut as much quantum risk as they can by the end of 2030.
Every one of these plans starts in the same place: find out what you have. OMB's memo puts it plainly: “The foundation of the migration plan is a dynamic, continuously updated inventory of all cryptographic assets.” The data behind it, the memo goes on, “should populate a central Cryptographic Bill of Materials (CBOM) to provide a real-time view” of where an agency stands. Building one turns out to be harder than it sounds.
The question most teams can't answer
You might expect to answer it from a spreadsheet: list your applications, then look up what each one supports. The trouble is that “supports” and “uses” are different things.
The algorithms on a connection aren't fixed in advance. They're agreed in its first few packets, the handshake, between two sides that each bring their own list. A server might be perfectly capable of post-quantum key exchange while every client that talks to it still asks for the classical kind. An appliance might have been set up once, years ago, and never looked at since. A library update might quietly change a default.
Surveys and code scans tell you what could happen. The handshakes on your network tell you what actually does. They also tell you something no spreadsheet can: when a connection falls short, which side is holding it back.
What's a CBOM?
You may have come across a software bill of materials, or SBOM: an ingredients list for a piece of software, saying which components went into it. A cryptography bill of materials, or CBOM, does the same job for cryptography. It lists the cryptographic assets in a system, such as the protocols and algorithms in use, in a form that tools and auditors can read.
VeilNet writes CBOMs in CycloneDX 1.6, an open standard from OWASP and Ecma International. A single machine can save its own, and the guardian, VeilNet's self-hosted control suite, writes one for your whole network. In the guardian's, each service pair, meaning one application and the service it connects to, becomes a cryptographic asset, listed with its protocol, algorithm, quantum risk and fix, and the machines that saw it. The file also records the time window, the network and the policy it was rated under, and every one is checked against the CycloneDX 1.6 schema.
Watch the handshakes, not the traffic
VeilNet gathers all this with an observer, built into conflux, the same agent that runs VeilNet's anchors. You can run it on any Linux, macOS or Windows machine, whether or not that machine is on a VeilNet network:
$ sudo conflux observe
From then on, the machine hands the observer a copy of the start of each connection. The observer reads the handshake and writes down what was agreed. For each service the machine connects to, serves or forwards, it records the protocol, whether the key exchange was post-quantum, hybrid, classical or absent, which side held it back if it wasn't post-quantum, and which program on the machine owns the connection.
The host hands the observer a copy of the start of each connection. The observer reads the handshake and writes down what was agreed, while the traffic itself carries on untouched. What's inside the connection is never recorded.
Three things about this matter:
- It reads a copy, never the traffic. Nothing passes through the observer, so it can't slow, break or reroute a connection.
- It asks for very little. The observer joins no network and needs no credential. On Linux, it runs as its own account with the right to capture packets and nothing more. On macOS it reads packet copies through BPF, and on Windows it uses the system's own packet capture. The
sudois only there to register it as a service. - It never records content. It writes down what was agreed, not what was said. If even server names are sensitive,
--hide-namesrecords each server's address instead.
Use the machine as usual for a minute, then ask what it has seen:
$ sudo conflux inventory SERVICE PORT PROTOCOL KEY EXCHANGE GROUP LAGGING ROLE PROCESS FLOWS a.example 443/tcp tls hybrid X25519MLKEM768 - client curl 3
That one's good news: curl reached a.example with X25519MLKEM768, a hybrid that includes ML-KEM, NIST's post-quantum key exchange standard. To save the whole inventory as a CBOM:
$ sudo conflux inventory -cbom > host.cdx.json
On a machine that's already on your VeilNet network, add --observe to conflux up or conflux proxy instead. The observer then runs in the same process as the anchor, which also gets the right to capture packets, and the machine stays on the network. It sees the traffic the anchor carries as well as the machine's own.
The observer sees connections as they happen. For the servers you care about most, the guardian can also probe TLS endpoints directly. It runs one handshake every six hours, with no application data sent, and checks the key exchange the server agrees to, which algorithm signed its certificate and how long that certificate has left.
From handshakes to risk
A list of handshakes is only half the story. Observers that send their records to the guardian, with --export, build one inventory for your whole network, and the guardian rates every service pair in it:
| Rating | What it means |
|---|---|
| Critical | Exposed now, with no quantum computer needed: TLS 1.1 or earlier, TLS 1.2 with RSA key transport or without forward secrecy, a NULL cipher, or an SSH key exchange that uses SHA-1. |
| High | Classical key exchange, such as ECDHE or X25519. Secure against today's computers, but traffic recorded now could be decrypted once a quantum computer exists. |
| Medium | Post-quantum, but not the NIST standard: sntrup761, or the early drafts of Kyber. |
| Quantum-safe | ML-KEM, the NIST standard, on its own or in a hybrid. |
| Not assessed | No key exchange was seen, for example on a resumed session. These never count as quantum-safe. |
| No cryptography | The protocol has none of its own, such as plain HTTP or DNS. These are left out of the quantum-safe share. |
What counts as quantum-safe depends on the policy you choose. Under NIST's, any ML-KEM group does. Under CNSA 2.0, the suite the US National Security Agency sets for national security systems, only ML-KEM-1024 does, and the smaller groups drop to medium. Ratings are worked out each time you open a page, so switching policy re-rates everything you've collected.
Each pair at critical or high risk also says who has to fix it, which is the part spreadsheets miss:
- Server: the client offered post-quantum key exchange, and the server chose a classical one.
- Client: the client never offered a post-quantum group. If the same server already uses quantum-safe key exchange with other clients, the pair is marked server ready, and updating the client is enough.
- Undetermined: the handshake doesn't show which side is responsible.
The observer sees what the client offered and what the server chose. If the client offered no post-quantum group, the client has to change, and if that server already uses ML-KEM with other clients, updating the client is enough. If the client offered one and the server picked a classical group anyway, the server has to change.
A plan, not just a list
Knowing you have two hundred risky connections is daunting. Knowing that a dozen changes will fix them is a project. So the guardian turns the inventory into a migration plan.
It takes every pair at critical or high risk and groups them into the changes that fix them: one change for each server that has to change, and one for each application. Then it puts those changes in two phases. Exposed now comes first, because those connections can be broken without a quantum computer. Harvest now, decrypt later comes second. Within each phase, the changes that fix the most at-risk traffic come first.
Each step is a plain change: upgrade a server to TLS 1.3 with hybrid key exchange, turn hybrid key exchange on, or update an application on the machines that run it. Where a handshake doesn't show who's responsible, the step is to find out which side is blocking. As you work through the plan, a fix shows up under Became quantum-safe as soon as the guardian sees a quantum-safe handshake. The pair keeps its old rating until its older handshakes age out of the time window you're viewing, so a short window, such as 24 hours, shows a step clear sooner.
Seven connections at risk come down to three changes. The plan fixes what's exposed now first, then what's open to harvest now, decrypt later, and within each phase it starts with the change that fixes the most at-risk traffic.


Always up to date
An inventory you build once is out of date the next day. Observers that export to the guardian keep it current on their own, and the TLS endpoint probes run every six hours. The guardian keeps each service's records for 90 days after it was last seen, and you choose how far back each view looks, from 24 hours to 90 days.
When you need to show your work, the guardian exports:
- a CycloneDX 1.6 CBOM, for all your realms in one file or one realm at a time
- each realm's inventory as CSV, in the columns OMB memo M-23-02 asks for
- a one-page readiness summary for briefings
- every certificate the guardian's authorities have issued, as CSV
The CBOM is also one of the guardian's evidence items, so it goes into the signed evidence packs for frameworks that ask for a cryptographic inventory.
Your inventory stays yours
A map of every encrypted connection in your organisation is sensitive in its own right, so it stays where you put it:
- On its own,
conflux observekeeps its inventory in memory on the machine. Records leave only when you point--exportat a collector, and then they go to the one you name: your own guardian, or an OpenTelemetry collector you run. - The guardian runs on your own infrastructure, and can run with no connection to the outside world at all.
- Only auditors and above can read the inventory in the guardian.
What it can't see
Like any tool, the observer has limits worth knowing:
- It sees what happens while it watches. A job that runs once a month shows up the first time it runs. A connection appears once it has lasted a minute, or when it ends.
- It needs a handshake. A resumed session skips the key exchange, so it's rated not assessed rather than guessed at.
- Certificates come from probes. The observer reports the key exchange. To check which algorithm signed a server's certificate, use the guardian's TLS endpoint probes.
- It doesn't read code or stored keys. It shows the cryptography on the wire, not the keys in a vault or the libraries in a build, so it complements your existing cryptography inventory and PKI work rather than replacing it. M-26-15 itself lists network scanners alongside tools that analyse code and SBOMs.
- It takes over a machine's anchor. Plain
conflux observestops an anchor that's already running, after asking first. Use--observeonuporproxyto keep it.
Try it
You can inventory a machine in a couple of minutes, with nothing to enrol. Install conflux from the get-started page, run sudo conflux observe, use the machine as usual for a minute, then run sudo conflux inventory.
The docs cover observing traffic, the inventory, the migration plan and reports and the CBOM in full, and the Discover page shows the console. To roll observers out across your network with your own guardian, book a demo, or write to sovereign@veilnet.net.