VeilNet
Blog

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.

HOSTweb-01OBSERVERHOSTdb-02OBSERVERHOSTlaptop-7OBSERVERINVENTORY · EVERY SERVICE PAIR10.20.0.40:443TLS 1.0 · RSA KEY TRANSPORTCRITICAL10.20.0.12:5432TLS 1.3 · x25519HIGH10.20.0.50:22SSH · sntrup761x25519MEDIUM1.1.1.1:853TLS 1.3 · X25519MLKEM768QUANTUM-SAFE+ 35 MORE PAIRSRATED UNDER NIST OR CNSA 2.0CBOMCycloneDX 1.6ONE ASSET PER PAIRMIGRATION PLAN1UPGRADE TO TLS 1.32ENABLE HYBRID KEX3UPDATE THE CLIENT01 OBSERVE02 INVENTORY03 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.

Fig. 01 — A copy, never the traffic
YOUR HOSTAPPcurlSERVERa.examplePORT 443TRAFFIC CARRIES ONA COPYOBSERVERREADS THE HANDSHAKETHE RECORD · EVERY MINUTE, PER FLOWCONTENT NEVER RECORDEDSERVICEPORTPROTOCOLKEY EXCHANGEGROUPROLEPROCESSa.example443/tcptlshybridX25519MLKEM768clientcurl

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 sudo is 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-names records 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:

RatingWhat it means
CriticalExposed 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.
HighClassical key exchange, such as ECDHE or X25519. Secure against today's computers, but traffic recorded now could be decrypted once a quantum computer exists.
MediumPost-quantum, but not the NIST standard: sntrup761, or the early drafts of Kyber.
Quantum-safeML-KEM, the NIST standard, on its own or in a hybrid.
Not assessedNo key exchange was seen, for example on a resumed session. These never count as quantum-safe.
No cryptographyThe 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.
Fig. 02 — Which side has to change
CLIENTOFFERSSERVERSUPPORTSOFFERCHOOSES x25519HIGH RISKCLASSICAL KEY EXCHANGEx25519X25519MLKEM768x25519The client must changeIT OFFERED NO POST-QUANTUM GROUPSERVER READYTHIS SERVER DOES ML-KEM WITH OTHER CLIENTS

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.

Fig. 03 — Many findings, few changes
7 PAIRS AT RISK3 CHANGES, IN ORDERapp-01 → vpn:443app-02 → vpn:443ci-01 → vpn:443app-01 → db:5432app-02 → db:5432backup-01 → s3:443backup-02 → s3:4431 · EXPOSED NOW2 · HARVEST NOW, DECRYPT LATERSERVER3 PAIRSUpgrade vpn to TLS 1.3SERVER2 PAIRSEnable hybrid on dbCLIENT2 PAIRSUpdate backup-agentCRITICALHIGHIN EACH PHASE, BIGGEST FIX FIRST

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.

Discover › Migration planGuardian console
The migration plan: 17 changes for 17 pairs at risk, ten on servers and seven application updates, in order, with the share of at-risk traffic each fixes and the quantum-safe share by day.

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 observe keeps its inventory in memory on the machine. Records leave only when you point --export at 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 observe stops an anchor that's already running, after asking first. Use --observe on up or proxy to 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.