Post-quantum cryptography work is easier to manage when algorithms, libraries, APIs, protocol guidance, and migration tasks are evaluated together. This checklist helps developers and security teams find suitable PQC resources, compare implementation maturity, test hybrid deployments, and create a practical plan for replacing vulnerable public-key cryptography without treating a library upgrade as the whole migration.
Overview
Post-quantum cryptography, or PQC, refers to cryptographic methods designed to resist attacks from sufficiently capable quantum computers. The immediate engineering challenge is not simply choosing a new algorithm. Teams must identify where public-key cryptography is used, understand which protocols and certificates depend on it, select supported implementations, and verify that applications continue to interoperate.
A useful resource directory should therefore separate several related categories:
- Key encapsulation mechanisms: Tools and libraries for establishing shared secrets over an untrusted connection.
- Digital signatures: Implementations for authentication, code signing, certificates, documents, and software updates.
- Hybrid cryptography: Protocol patterns that combine an established classical method with a post-quantum method during a transition period.
- Developer libraries and APIs: Language bindings, provider interfaces, command-line utilities, and test harnesses.
- Migration tooling: Cryptographic inventory scanners, dependency checks, certificate analysis, traffic inspection, and configuration validation.
- Research and test resources: Specifications, security guidance, test vectors, interoperability projects, benchmarks, and implementation notes.
When reviewing any entry, record its supported algorithms, language, interface style, license, maintenance activity, platform support, side-channel considerations, test coverage, and intended use. A prototype for research should not be treated as a production dependency merely because it exposes a convenient API.
For broader quantum context, compare this checklist with the Quantum Research Resources Directory and the Quantum Computing Tools Directory. Those resources cover the surrounding research and developer ecosystem; this guide focuses specifically on quantum-safe cryptography work.
Checklist by scenario
You are starting a cryptographic inventory
- List applications, services, devices, and data stores that use public-key cryptography.
- Record algorithms, key sizes, certificate types, protocol versions, libraries, providers, and configuration locations.
- Identify cryptography embedded in dependencies, appliances, firmware, scripts, build systems, and third-party integrations.
- Mark long-lived data and systems that may require confidentiality or authentication over an extended period.
- Separate confirmed usage from assumptions and assign an owner to each inventory item.
Start with discovery rather than replacement. An incomplete inventory can make a migration appear finished while vulnerable uses remain hidden in a certificate service, legacy integration, or device update process.
You are selecting a PQC library
- Confirm whether the implementation is intended for experimentation, evaluation, or production use.
- Check which key encapsulation and signature schemes are supported and whether their names, parameters, and interfaces match current guidance.
- Review language bindings, operating-system support, build requirements, memory use, key and signature sizes, and failure behavior.
- Look for reproducible tests, published test vectors, interoperability results, vulnerability disclosure information, and a visible maintenance process.
- Verify the license and whether it fits commercial distribution, internal deployment, or embedded use.
Prefer an abstraction that lets the application change algorithms without rewriting business logic. The cryptographic boundary should make keys, authentication failures, negotiation choices, and audit events explicit.
You are integrating a PQC API into an application
- Define whether the API handles key generation, encapsulation, decapsulation, signing, verification, certificates, or protocol negotiation.
- Test malformed inputs, invalid signatures, repeated operations, key rotation, interrupted connections, and unavailable algorithms.
- Measure message expansion, handshake size, latency, memory use, and operational effects on proxies, gateways, queues, and storage.
- Keep classical and post-quantum components distinguishable in logs and metrics without exposing private material.
- Document rollback behavior and make sure a temporary fallback cannot silently downgrade security.
You are testing hybrid deployment
- Choose a documented hybrid pattern rather than concatenating cryptographic outputs without protocol analysis.
- Test both endpoints, certificate chains, libraries, load balancers, service meshes, and middleboxes.
- Use test environments that reflect production message limits and timeout settings.
- Validate negotiation, failure handling, observability, and upgrade sequencing across mixed client versions.
- Record which component provides confidentiality or authentication and how the combined result is interpreted.
You are preparing a procurement or platform review
- Ask the provider for supported algorithms, API maturity, deployment boundaries, upgrade practices, and interoperability evidence.
- Request documentation for certificate handling, key management, hardware acceleration, audit logging, and incident response.
- Distinguish a provider roadmap from a currently available feature.
- Require a migration path that preserves application portability and avoids unnecessary dependence on one vendor.
For related platform evaluation, the Quantum Cloud Providers Directory and Quantum SDKs and Frameworks Directory offer useful comparison habits: inspect interfaces, limits, support boundaries, and workflow fit rather than relying on a single feature label.
What to double-check
Before approving a resource, verify its status at the time of use. Algorithm recommendations, standardization documents, library versions, provider support, and implementation warnings can change. Record the review date and link to the exact documentation or release used for the decision.
Check terminology carefully. A key encapsulation mechanism is not a digital signature scheme, and replacing one does not automatically address the other. Likewise, upgrading a TLS library may not update certificate issuance, code-signing workflows, archival formats, or device firmware.
Review security boundaries. A mathematically suitable algorithm can still be exposed by weak randomness, unsafe memory handling, poor key storage, timing leakage, insecure serialization, or incorrect error handling. Look for implementation-specific security notes rather than assuming that algorithm selection guarantees a secure deployment.
Double-check interoperability with the systems that matter most: identity providers, certificate authorities, hardware security modules, mobile clients, embedded devices, partner APIs, and long-lived archives. Record unsupported combinations and create a test owner for each one.
Common mistakes
- Replacing algorithms before mapping usage: Inventory first so hidden dependencies and certificate workflows are included.
- Treating a research implementation as production-ready: Check maintenance, testing, review history, operational guidance, and release discipline.
- Ignoring signatures: Authentication, software updates, certificates, and signed documents may require a separate migration path from encrypted transport.
- Testing only a local handshake: Larger keys, signatures, or certificates can affect gateways, packet limits, storage, and monitoring.
- Assuming hybrid means automatically secure: The combination, negotiation rules, downgrade behavior, and failure modes still require protocol-level review.
- Hard-coding one provider’s API: Keep an internal interface where practical so future algorithm or library changes are manageable.
- Failing to document uncertainty: Mark assumptions, unknown dependencies, and provisional choices instead of presenting them as completed controls.
When to revisit
Review this resource set at least before major planning cycles and whenever a cryptography library, protocol, certificate service, hardware platform, or compliance requirement changes. A three- to six-month review interval can be a practical starting point for active migration programs, but the right cadence depends on system lifetime, exposure, release frequency, and the pace of relevant standards and vendor updates.
Revisit immediately after a major algorithm or implementation update, a security advisory, a new interoperability result, a platform migration, or the discovery of previously unknown cryptographic use. Refresh directory entries with the review date, supported interfaces, implementation maturity, license, known limitations, and links to current documentation.
For the next working session, create a small migration register with five fields: system owner, cryptographic use, current dependency, proposed replacement or test path, and next review date. Prioritize long-lived sensitive data, externally exposed services, signing infrastructure, and systems that are difficult to update. Then test one representative workflow end to end before expanding the change. This turns post-quantum cryptography from a broad research topic into a repeatable engineering process.