How other teams built this in.
Integrations told from the architecture down: where the entropy source sits, what consumes it, what the work actually took, and what changed once it was in. A post-quantum migration, a certificate authority issuing machine identities, an OEM carrying one interface across a product generation, and equipment that has to make its own keys in the field.
IllustrativeWritten by Quside to show what a customer story here will cover. No customer is named, quoted or described.
The seed and the algorithm on one card.
- The team
- Security appliance vendor
- The source
- On a PCIe card in the appliance
- Parts
- Garnet™ X5
- Software
- Linux C and Python drivers
Where they started
They were adopting ML-KEM and ML-DSA across an appliance already deployed across enterprise infrastructure, and both halves of the problem arrived together. New post-quantum implementations had to be adopted, tested and maintained; and the key material those implementations produce is only as strong as the randomness seeding it. Both land on the same board, and both have to survive the regression testing that any change to a shipping product sets off. Doing the algorithm work first and the entropy work a generation later would have meant paying that cost twice.
The architecture
The post-quantum operations run on the cryptographic accelerator configuration of the Garnet card, and the quantum entropy source on the same card seeds the deterministic generator underneath them. Randomness is measured and consumed inside one chassis, so there is no link between those two points for a reviewer to ask about. The application above keeps the protocol logic and hands off key generation and signing. The source keeps its own runtime measurement, which means the condition of the source is something the appliance can read at the moment a key is produced rather than something recorded once in a factory test report.
The integration
Two pieces of work, neither of them in the application. The first was mapping the entropy interface onto the seed input of the generator the platform already called — a driver-level change rather than an architectural one. The second took longer and was operational: carrying the source health record up alongside the key material so the two arrive together, and an operator can see the condition of the source behind a given key. That second piece is the one teams underestimate, and it is what makes the argument answerable a year later.
What changed
Key generation and signing run on the card. The host application gets the cycles back, and the seeding path is a property of the hardware rather than a configuration the field can get wrong.
Keys minted inside the issuing host.
- The team
- Certificate authority operator
- The source
- On a PCIe card in every issuing node
- Parts
- Garnet™ Plus A41
- Software
- Linux C and Python drivers
Where they started
They issue machine identities at a rate nobody signs off by hand, and every certificate is a claim about key strength that an auditor may come back to years later. The keys were sound. What was missing was any account of where the randomness behind them came from: the issuing host drew from a pool it could not see into, so the strongest thing the operator could say about the entropy behind a certificate was that nothing had gone visibly wrong.
The architecture
A Quside card sits in each issuing node and seeds the generator the certificate platform calls. The trust boundary for entropy becomes the machine that issues, rather than anything that machine reaches out to. Every node is built the same way, so one argument covers the estate and survives a hardware refresh. The card measures its own physical process against a defined model while it runs and exposes a health state to the operating system, which puts the seeding path and the evidence path on the same route.
The integration
The card came in through the standard driver path and the certificate platform above it was unchanged — it asks the operating system for randomness exactly as it did before. The work that took the schedule was in operations: attaching the entropy source health record to the issuance audit trail, agreeing how long that record is kept, and getting it into the form the compliance team already reviews. Nothing in the issuance logic moved.
What changed
Entropy stays inside the trust boundary, and the audit trail says so. A reviewer reading a certificate can read the state of the source that produced it.
One entropy interface, carried across a product family.
- The team
- Network equipment manufacturer
- The source
- FMC module now, embedded module next
- Parts
- Nellite™ Plus A41, then Onyx™ S1
- Software
- VHDL IP cores
Where they started
A platform shipping today, and a successor already in design. The entropy decision was never really about the current product: a component that has to be characterised from scratch for every unit in a family competes against doing nothing, and loses. What the product leader needed to know before committing was how much of the first qualification would still be worth something on the second board.
The architecture
On the shipping platform, entropy is taken into the FPGA fabric through an FMC module, so the cryptographic path never crosses the host bus to reach it. The successor is designed around the compact embedded module instead, carried on the manufacturer’s own board once the volume made the board work worth doing. The same runtime loop runs in both: the device measures its physical process against a defined model, estimates entropy, derives a health state, and makes that state available as an audit output.
The integration
What carried across was the physical model of the source, the entropy estimation and health-test methodology, the documentation package an evaluator asks for, and the manufacturer’s own test plans and acceptance criteria. Certificate scope did not, and was never offered as though it would: a certificate is issued against a product, so a different form factor is a different scope. The rest of the repeated work was specific to the new design — the enclosure, its operating range, and the environmental campaign that goes with them.
What changed
The second design started from a known-good interface instead of a new evaluation.
A source in the enclosure, and a health state in the built-in test.
- The team
- Defence equipment manufacturer
- The source
- On the equipment’s own board
- Parts
- Onyx™ S1, built on Ruby™ S1
- Software
- Embedded host interface, defined per integration
Where they started
Equipment that generates session keys in the field, over a service life measured in decades, with no route back to anything while it is doing it. Two options were ruled out early. Randomness arriving over a link cannot be verified where it is consumed, and it adds a dependency the platform does not control. And a source characterised once on a bench and assumed for the next twenty years describes the day it was tested rather than the day it is used.
The architecture
The entropy source is a component of the equipment’s own board, next to the function that consumes it, digitising a physical process rather than deriving from the state of the system around it. It measures that process against its model while the equipment runs and derives a health state from the measurement. Size, weight and power were fixed long before entropy was discussed, which is what put a compact embedded module in the design rather than a card.
The integration
Most of the effort was mechanical, thermal and environmental rather than electrical: the module had to fit an enclosure and a power budget that already existed. The software work was in routing the health state into the equipment’s own built-in test, so a source drifting outside its validated operating conditions shows up where an operator already looks instead of in a log nobody opens.
What changed
The strength of key material generated in the field can be argued from the equipment’s own records.
The same three decisions, in four different systems.
Different markets, different form factors, different reasons for starting. The engineering underneath lands in the same place every time.
The source sits inside the machine that consumes it
A chassis, a board or an enclosure — in every one of these the randomness is measured and used inside the same boundary. Nothing arrives over a link, so there is no point in the path where a reviewer has to take the source on trust.
The health record travels with the key material
The driver work is rarely what takes the schedule. Deciding where the source’s runtime health state goes, who reads it and how long it is kept is the part that turns a component choice into evidence somebody can use at a review.
The interface is qualified once
The same runtime loop appears at every integration point, so the physical model, the test methodology and the documentation package carry from one product to the next. Certificate scope is the exception: it is issued against a product, and it moves when the product does.
Evidence closer to your own system.
Customers in space, defence, government and regulated infrastructure do not publish what is inside their systems, so the next step after reading is arranged rather than downloaded. Pick the one that answers the question you are stuck on.
A reference call under NDA
Tell us the market and the architecture you are working in. Where a customer has agreed to act as a reference, we arrange the introduction under NDA.
Request a customer reference→An architecture review
A working session with an engineer on your system: where the source sits, what consumes it, what your assessor will ask, and which product fits.
Request an architecture review→An evaluation kit
Hardware in your own lab. Tell us the interface, throughput, environment and volume you are designing for, and we send the right unit.
Request an evaluation kit→Tell us what you are building.
The market, the architecture and the date you have to decide by. An engineer comes back with which part fits, what the integration takes, and what evidence you can have in front of you.