Qu4z4r
28 min read
06 Nov
06Nov

Post-quantum embedded crypto, the practical takeaway, you do not need to rip out every elliptic curve today, but you do need a concrete plan that starts now. If you ship embedded devices that will remain deployed for years, you should assume that attackers can record traffic today and attempt to decrypt it later when quantum capable cryptanalysis becomes practical. The most time sensitive control is key establishment for long lived confidentiality. The second is the ability to update and rotate cryptographic algorithms in the field without bricking devices. Everything else follows from those two facts.

What to do first, treat post-quantum cryptography (PQC) as an engineering migration, not a marketing event. Build a short readiness backlog: inventory where public key crypto is used, choose where hybrid modes make sense, measure CPU, RAM, flash, and bandwidth impact on your actual microcontrollers, and ensure you can patch cryptography in the field. If you can do only one thing this quarter, add algorithm agility to your firmware and backend so you can swap key exchange and signature schemes without redesigning the product.

Where the standards are, NIST has published finalized standards for key encapsulation and signatures, including ML-KEM (based on CRYSTALS-Kyber), ML-DSA (based on CRYSTALS-Dilithium), and SLH-DSA (based on SPHINCS+). These are the practical starting points for embedded adoption because they are converging on stable interfaces, test vectors, and compliance expectations. In parallel, IETF and industry groups are standardizing how to use PQC in protocols like TLS, COSE, and VPN stacks, often via hybrid approaches that combine classical and post-quantum algorithms.

What is not urgent, not every embedded signature in your system must become post-quantum immediately. If a signature is used only to authenticate an ephemeral session, the risk horizon differs from firmware signing keys that must remain trustworthy for the device lifetime. Similarly, internal manufacturing flows might tolerate a different timeline than devices in hostile physical environments. The goal is to prioritize based on data lifetime, device lifetime, and update feasibility.

Practical readiness without the hype means being honest about constraints. PQC brings larger keys, larger signatures, and heavier computations, especially on small microcontrollers. Some devices will need careful tuning, hardware assists, protocol framing changes, or even a bill of materials change. The payoff is not a single magic checkbox. The payoff is a system that can survive a multi year transition while still meeting power, cost, latency, and reliability targets.

How QVLx Labs frames the problem, for embedded products, the hard part is rarely the math alone. The hard part is fitting new algorithms into secure boot chains, factory provisioning, certificate profiles, constrained network links, and long term maintenance. A practical program ties together cryptography, firmware architecture, manufacturing operations, and backend services so that post-quantum becomes a controlled change, not a surprise.

When you actually need PQC in embedded systems, you should accelerate adoption if any of these apply: you protect sensitive data whose confidentiality must last longer than the likely quantum timeline, you deploy devices that cannot be updated reliably, you use asymmetric cryptography for secure boot or signed updates, you rely on long lived device identity certificates, or you operate in a threat environment where traffic capture is plausible. If none apply, you still need algorithm agility and a migration plan, but you can stage deployment later.

Threat model in one paragraph, a large scale quantum computer would most directly impact RSA and discrete log systems such as ECDH and ECDSA by enabling Shor style attacks. Symmetric primitives like AES and SHA are less affected, typically modeled as requiring larger key sizes to maintain margins. In embedded practice, the highest leverage risk is harvest now, decrypt later, where an attacker stores encrypted traffic today and decrypts it in the future if key exchange is later broken. That is why key establishment deserves attention early.

A minimal, high value migration sequence for many embedded fleets looks like this:

  • Make cryptography algorithm agile in firmware and backend, separate protocol logic from algorithm selection.
  • Introduce hybrid key establishment in your transport security, for example combining an elliptic curve with ML-KEM, so compromise requires breaking both.
  • Plan a transition for firmware signing and device identity, typically adding ML-DSA signatures alongside existing ECDSA during a migration window.
  • Update provisioning, certificate profiles, and update servers to accept PQ and hybrid artifacts.
  • Only then consider removing classical algorithms, after ecosystem support, testing, and operational maturity are proven.

What embedded teams underestimate, bandwidth and message sizing. In many microcontroller deployments, the CPU cost of ML-KEM is manageable with optimized code, but the handshake bytes can break assumptions in MTU sizing, fragmentation, radio duty cycles, and connection setup time. Protocols and transports that were tuned around 32 byte public keys and 64 byte signatures may need redesign when signatures become multiple kilobytes.

Concrete size expectations, exact sizes vary by parameter set and encoding, but it is useful to plan with realistic orders of magnitude. For ML-KEM, public keys and ciphertexts are typically around 0.8 KB to 1.6 KB. For ML-DSA, public keys are roughly 1 KB to 2.6 KB, and signatures are roughly 2.4 KB to 4.6 KB. SLH-DSA signatures are significantly larger, often tens of kilobytes depending on parameter choices, which can be difficult for constrained links but can be attractive when you want conservative security assumptions and can tolerate the size.

Protocol impact checklist, before you pick any algorithm, answer these sizing questions with measurements, not guesses:

  • What is the maximum packet payload in your real transport path, after headers, link layer security, and any tunneling?
  • What are your current handshake and certificate sizes, and do you already rely on fragmentation or multiple round trips?
  • How does fragmentation affect reliability on lossy links, and what does it do to battery life and connection setup time?
  • Are there intermediaries, gateways, or cellular modules that enforce record size limits or timeouts?
  • Do you have a safe way to handle larger buffers without introducing heap fragmentation or stack overflow?

Choosing algorithms for embedded reality, most embedded deployments will start with ML-KEM for key establishment and ML-DSA for signatures. ML-KEM is designed for encapsulation workflows similar to existing ECDH based approaches. ML-DSA provides comparatively efficient signing and verification relative to other PQ signature families, with manageable signature sizes for many device classes. SLH-DSA is important to keep in your toolbox when you need a more conservative, hash based signature option, but its signature sizes can be a non starter for tight links and small flash budgets.

Hybrid modes are your friend, especially early. Hybrid key exchange, such as combining X25519 with ML-KEM, reduces the risk of betting everything on a new primitive while standards and implementations mature. Hybrid signatures can similarly pair ECDSA with ML-DSA during migration. The operational cost is bigger messages and additional computation, but in many systems this cost is acceptable for a limited transition period, particularly if you apply it only to session establishment and firmware update channels rather than every message.

Embedded systems and the difference between handshake and steady state, in many products the secure channel handshake is rare compared to the total device runtime. If you connect once per day, you can afford a heavier handshake. If you connect hundreds of times per hour due to sleep cycles, roaming, or intermittent links, the handshake cost is multiplied and becomes a power and latency driver. Your readiness plan should classify each connection type by frequency and then decide where to use hybrid or PQ first.

Memory planning, the hidden blocker, PQC implementations often need temporary buffers for polynomials, NTT transforms, and hash function state. On a Cortex-M class MCU, the difference between fitting in SRAM and spilling into slower memory can make or break real time constraints. You should prototype on your lowest end target, with your real compiler flags, and measure peak stack and heap usage under worst case paths, including error handling paths that might allocate additional buffers.

Implementation strategy for constrained firmware, treat PQC code like any other cryptographic primitive: isolate it behind a stable interface, keep it out of application logic, and ensure you can swap implementations. In practice that means a thin wrapper around your chosen library, clear key and buffer ownership rules, and a test harness that can run on target hardware. Avoid hard coding algorithm identifiers in too many places. The time you spend on clean interfaces now directly reduces migration cost later.

Library selection criteria for embedded PQC should include more than performance. Consider:

  • Constant time and side channel posture, including known countermeasures and clear documentation.
  • Memory footprint across your target set, not just on a desktop benchmark.
  • Quality of test vectors, known answer tests, and interoperability fixtures.
  • Licensing compatibility with your product.
  • Release cadence, security response process, and long term maintenance.
  • Ease of building with your toolchain, including bare metal builds.

Do not ignore side channel realities, embedded devices are often physically accessible. That makes timing analysis, power analysis, electromagnetic analysis, and fault injection more plausible than in many server settings. PQC does not remove side channel risk. In some cases it increases it, because new code paths, larger computations, and more complex decoding steps create more opportunities for leakage. If your device is in a hostile environment, your readiness plan should include side channel evaluation, not just functional correctness.

Key management changes with PQC, not because keys must be stored differently in principle, but because the artifacts are larger and workflows are less mature. Device identity certificates that embed PQ public keys become bigger. Manufacturing systems that assumed a fixed record size might break. Secure elements that store keys might not support PQ key sizes or operations yet. If you rely on a hardware security module, secure element, or trusted execution environment, validate early whether it can store and use PQ keys, or whether you will do PQ operations in the main MCU with protected key storage and careful anti extraction controls.

Secure boot and signed firmware updates are a prime target for staged post-quantum adoption. Firmware signing keys are long lived. If you ship a product that must accept updates for ten or more years, you should plan for a transition of the signing algorithm and certificate chain. A practical approach is dual signature for a period: sign the same firmware with a classical algorithm and a PQ algorithm, then verify both during migration. Over time you can change policy to require PQ and later remove classical verification if your ecosystem supports it.

Update pipeline readiness is often more critical than the embedded math. Ask these operational questions:

  • Can you update the bootloader, or only the application?
  • Can you rotate the root of trust, or is it fused in a way that prevents future changes?
  • Can your update servers, CDNs, and gateways handle larger metadata, signatures, and certificates?
  • Do you have rollback protection that still works if you change signing algorithms?
  • Can support teams recover devices safely if an update fails mid flight?

Algorithm agility, what it should mean in firmware, algorithm agility is not a configuration file that picks between RSA and ECDSA. In embedded products it should mean that algorithms are negotiated or selected via identifiers, that parsing code is robust to unknown identifiers, that keys are stored with metadata describing their algorithm and parameters, and that the system can enforce policy updates. The most important property is that you can add a new algorithm without rewriting your entire protocol stack or reflashing manufacturing data formats.

Transport protocols, what changes first, TLS is the most common boundary between embedded devices and the internet. PQ support in TLS is evolving through hybrid key exchange and new code points. For constrained IoT stacks, CBOR based ecosystems often use COSE and OSCORE, and those communities are also working on PQ compatible structures. Your plan should map each protocol you use to an adoption path and a realistic testing strategy, including interop with third party servers, proxies, and diagnostic tools.

Certificate ecosystem issues, X.509 can carry PQ public keys, but existing tooling might not like them yet. Some certificate authorities and device management platforms have strict limits on certificate size or supported algorithms. If you operate your own private PKI, you have more control, but you also inherit more responsibility for compatibility and auditing. Many embedded deployments will use hybrid certificates or dual certificate chains during transition to avoid breaking legacy verification code in older devices or gateways.

Performance reality, what costs CPU, ML-KEM and ML-DSA both rely on structured lattice operations and hash based sampling. They benefit from fast integer multiplication and efficient hashing, especially SHAKE (Keccak) variants. On small MCUs without hardware accelerators, hashing can dominate runtime. If your chip has SHA3 or Keccak acceleration, you may see a big improvement. If you have only AES and SHA-256 accelerators, you still can implement PQC efficiently, but you must benchmark and choose optimized code paths carefully.

Bandwidth reality, what costs energy, radios are often the primary energy consumer. Larger handshakes increase airtime and retransmissions. A migration plan should explicitly measure energy per handshake with classical, hybrid, and PQ only options on representative links. It is common to discover that an extra kilobyte in the handshake matters more than a few extra milliseconds of CPU time, especially on LPWAN, satellite, or congested mesh networks.

Engineering tradeoffs, a practical decision matrix, embedded adoption decisions are easier when framed as constraints. Here is a useful way to reason:

  • If your device is bandwidth constrained, minimize signature size first, consider ML-DSA parameter choices carefully, and limit SLH-DSA to specialized cases.
  • If your device is CPU constrained but has decent bandwidth, prefer schemes and parameter sets with faster operations and accept larger messages when possible.
  • If your device is memory constrained, prioritize implementations with low peak RAM and avoid dynamic allocation.
  • If your device is physically exposed, prioritize side channel hardened implementations and key protection over raw benchmark speed.
  • If your device cannot be updated, prioritize conservative choices and longer term interoperability, because you might live with the choice for the full lifetime.

Testing, what counts as done, do not declare PQC readiness because a demo handshake worked once. A real embedded readiness definition should include:

  • Known answer tests and negative tests integrated into CI for every target toolchain.
  • On device tests that measure time, stack, heap, and power under worst case settings.
  • Interoperability tests with at least two independent implementations where possible.
  • Fuzzing of parsers and decoders, especially for certificate and message formats.
  • Fault injection and robustness testing for decoding failures, because some PQ schemes have complex failure behavior that must be handled safely.

Failure handling matters more than you think, for both ML-KEM and signature schemes, decoding and validation failures must be constant time where required, must not leak sensitive state, and must result in safe behavior. In embedded systems, failure paths are often under tested and sometimes allocate extra buffers or produce verbose logs. Treat error handling as part of the cryptographic surface. Ensure logs do not leak secrets and ensure the device does not enter unrecoverable loops after repeated handshake failures.

Entropy and randomness, the non negotiable dependency, PQC relies heavily on high quality randomness. Inadequate entropy will break security regardless of algorithm choice. Many embedded products still struggle with early boot entropy, especially when devices power up in identical conditions. Your readiness plan should include a review of entropy sources, conditioning, health tests, and how the device seeds deterministic random bit generators. If you cannot guarantee randomness at first boot, you may need factory injected seeds, hardware noise sources, or delayed key generation until sufficient entropy is available.

Hardware support and accelerators, there is no universal PQ accelerator yet across all embedded chips, but trends are emerging. Some vendors are adding SHA3 acceleration because it helps both PQC and other modern security workloads. Others add polynomial arithmetic accelerators or configurable math engines. You should not wait for perfect hardware to start. Instead, build software implementations that fit today, and design interfaces that can later offload to hardware when it becomes available. Make sure your design does not assume fixed key sizes or fixed signature sizes, because future parameter sets and algorithms may differ.

Secure elements and PQC, many secure elements today are optimized for RSA and ECC. If you rely on them for private key operations, you may be forced to keep classical signatures longer or to move signing into the main MCU. Both options have consequences. A practical staged approach is to keep secure element based identity for classical auth while introducing PQC in the session layer using hybrid key establishment, then revisit secure element capabilities for PQ signing in a later hardware revision.

Supply chain and manufacturing impacts, PQ readiness is not just firmware. Manufacturing lines provision keys, burn fuses, print labels, and generate certificates. Larger keys and certificates can affect barcode payloads, QR codes, and provisioning record formats. If you use a manufacturing test fixture that stores credentials in a small EEPROM region, PQ keys may not fit. Plan a provisioning format version bump and test it with real factory tools.

Compliance and procurement realities, many industries will eventually require NIST standardized algorithms for government or regulated markets. Even before mandates, procurement checklists may start asking for post-quantum roadmaps. A pragmatic approach is to document your migration stages, align on NIST standardized primitives, and avoid proprietary schemes. If you need FIPS validated modules, factor in lead time. Validation cycles are slow, and embedded devices often ship on timelines that do not match certification schedules.

Common pitfalls to avoid, teams fall into predictable traps during PQC evaluation:

  • Benchmarking on a desktop and assuming the same ratios hold on a microcontroller.
  • Optimizing CPU time while ignoring handshake size and radio cost.
  • Ignoring side channels because the algorithm is post-quantum.
  • Assuming certificate tooling will accept new key types without changes.
  • Hard coding parameter sets and making future updates difficult.
  • Rolling a custom protocol when standard protocols can be extended.

A practical embedded readiness roadmap can be executed in parallel tracks:

  • Track 1, architecture, define crypto interfaces, algorithm identifiers, versioned credential formats, and update mechanisms that can carry new algorithms.
  • Track 2, prototypes, integrate ML-KEM and ML-DSA in a lab firmware build, measure resources, and validate interoperability with a reference stack.
  • Track 3, operations, update PKI, certificate issuance, device management services, logging, monitoring, and incident response playbooks.
  • Track 4, security assurance, run code review, side channel review where relevant, and formalize threat models and acceptance criteria.

Deployment patterns that work, for fleets already in the field, you often cannot switch everything at once. Consider these patterns:

  • Enable PQ hybrid key exchange for a subset of devices and gradually expand, monitoring handshake failure rates and power impact.
  • Adopt PQ for the most sensitive channel first, such as device to cloud control plane, while leaving low sensitivity telemetry on classical temporarily.
  • Use dual signature firmware updates for a transition period, so older bootloaders can still accept updates while newer ones start enforcing PQ.
  • Introduce PQ capable gateways that terminate PQ sessions from devices and bridge to existing infrastructure where needed, as a temporary measure.

How to talk about timelines without making promises you cannot keep, quantum timelines are uncertain, and hype cycles distort planning. A practical way to communicate is to focus on device lifetime and data lifetime. If your device will be deployed for ten years, and the data must remain confidential for ten years, you have a direct reason to adopt PQ key establishment sooner. If your device is replaced every two years and data is short lived, you can stage later. This is engineering risk management, not prophecy.

Cost control, avoid a surprise bill of materials increase, the most expensive PQ migrations are the ones that discover late that a microcontroller lacks flash, RAM, or performance headroom, forcing a silicon upgrade. You can reduce that risk by testing on your lowest tier hardware early, and by designing the firmware so PQ features can be enabled selectively. In some cases, you can keep the same MCU by moving to a slightly larger flash variant or by optimizing other code, but you need measurements to decide.

Observability and field diagnostics, when you deploy new cryptography, failures can look like random connectivity problems. Add metrics and logs that capture algorithm identifiers, handshake stages, and error categories without leaking secrets. Ensure you can correlate failures across firmware versions and backend configurations. If you cannot observe it, you cannot safely migrate it, especially when you need to support mixed fleets over long periods.

Security posture improvements you can make immediately that complement PQC, and are often higher ROI:

  • Move to TLS 1.3 where possible, reduce legacy cipher suite exposure.
  • Increase symmetric key sizes where appropriate, for example prefer AES-256 for long term confidentiality designs.
  • Harden firmware update mechanisms, add rollback protection, improve key custody for signing keys.
  • Reduce long term secrets in logs and telemetry, and encrypt stored data at rest on the device.
  • Improve entropy sources and boot time seeding for all cryptography.

Putting it all together, a pragmatic definition of ready, you are practically ready for post-quantum embedded crypto when your product can negotiate or select modern algorithms without a redesign, when your firmware and backend can handle larger artifacts safely, when you have measured the impact on your real hardware and links, when your update mechanism can rotate trust anchors and algorithms, and when your operational team can monitor and respond to issues. At that point, adopting ML-KEM and ML-DSA becomes an incremental rollout, not a disruptive rewrite.

Conclusion, post-quantum embedded crypto is not science fiction, and it is not a single deadline either. It is a multi year migration in constrained environments where protocol sizing, updateability, and side channel resilience matter as much as the cryptographic primitive. The practical path is to start with algorithm agility, deploy hybrid key establishment where confidentiality lifetime demands it, plan for firmware signing transitions, and continuously test on real devices. That is how teams, including QVLx Labs and its partners, can move toward post-quantum readiness without buying into hype, and without shipping fragile systems.