Article · Cybersecurity

Post-Quantum Cryptography Automation in CI/CD Pipelines: A DevSecOps Framework for Crypto-Agility

Caleb Ngeno

By · November 16, 2026

A dark circuit-board photograph with a PQC migration seal and the title Post-Quantum Cryptography Automation in CI/CD Pipelines

Abstract. Cryptographic migration is no longer a distant research topic. NIST finalized ML-KEM, ML-DSA, and SLH-DSA in 2024; migration guidance now points toward deprecating quantum-vulnerable algorithms by 2030 and disallowing them by 2035. Yet most organizations still cannot answer a basic question: where does our cryptography live, and what breaks if we change it? This research proposal argues that post-quantum cryptography (PQC) should be treated as a continuous software-supply-chain problem, not as a one-time cryptographic upgrade. It proposes PQC-Auto, a DevSecOps framework that discovers cryptographic dependencies across source code, containers, infrastructure as code, certificates, and key-management systems; converts them into a cryptographic bill of materials (CBOM); scores quantum risk; generates migration work; verifies algorithm interoperability; and releases changes through zero-downtime crypto-agility controls. The study will use design science research, a benchmark of containerized microservices, fault injection, and practitioner evaluation. Expected contributions include a reference architecture, an open discovery and policy toolkit, a quantum-risk scoring model, and empirically grounded guidance for migrating legacy systems without downtime.

Keywords: post-quantum cryptography, PQC, CI/CD, DevSecOps, crypto-agility, cryptographic bill of materials, CBOM, ML-KEM, ML-DSA, SLH-DSA, software supply chain, zero trust.

1. The problem: cryptography is infrastructure that nobody owns

Most enterprises can list their servers, containers, domains, and dependencies. Very few can list their cryptography. RSA keys are embedded in service images. ECDSA certificates are issued by pipeline templates. A payment service negotiates TLS through a library three layers below application code. An HSM policy decides which algorithms can sign tokens. A vendor API still requires a legacy cipher suite. Each choice is reasonable in isolation. Together they form an undocumented cryptographic estate.

That estate is now exposed to a deadline. Large-scale quantum computers would break widely deployed public-key algorithms such as RSA, ECDSA, ECDH, and EdDSA. The threat is not only future decryption. It is also harvest now, decrypt later: an adversary can capture encrypted traffic today and decrypt it when capability catches up. Data with a long shelf life, such as health records, financial ledgers, state secrets, and identity material, is already inside the risk window.

The migration problem is made harder by the way modern systems are built. Cryptography is spread across layers:

  • Application code and libraries select algorithms and key sizes.
  • CI/CD pipelines bake certificates and trust bundles into images.
  • Infrastructure as code configures gateways, meshes, and TLS policies.
  • Cloud KMS and HSM policies control key custody and rotation.
  • Third-party APIs and identity providers impose their own negotiation rules.
  • Runtime environments may silently downgrade or fallback when peers do not support newer algorithms.

The result is a classic socio-technical failure. Cryptographers know which algorithms are safe. Platform teams own the pipelines. Application teams own the services. Security teams own policy. Nobody owns the end-to-end path from algorithm decision to deployed evidence. Manual spreadsheets and annual inventories cannot keep up with deployments that happen hundreds of times per day.

The research problem can therefore be stated as follows:

How can organizations continuously discover, assess, automate, and verify the migration of cryptographic dependencies in CI/CD pipelines without disrupting running systems?

2. Why this research is timely

NIST's post-quantum standardization programme has moved from theory to implementation. FIPS 203 specifies ML-KEM for key establishment; FIPS 204 specifies ML-DSA for digital signatures; FIPS 205 specifies SLH-DSA as a stateless hash-based signature standard. HQC was selected as an additional key-establishment algorithm, broadening the portfolio.

Migration guidance is also hardening. NIST IR 8547 frames a transition in which quantum-vulnerable algorithms are deprecated after 2030 and disallowed after 2035 for covered systems, with accelerated milestones for high-value assets. NIST's crypto-agility guidance treats automated discovery, inventory, remediation, and governance as maturity capabilities rather than optional hygiene. CISA's 2026 product-category work shows that some vendors have introduced PQC key establishment, but signature support and full-stack coverage remain uneven.

This creates a practical gap. Standards tell us what to migrate to. They do not tell a platform team how to find every instance of old cryptography, change it safely, prove the change, and keep the service available while peers and vendors migrate at different speeds. That gap is the research opportunity.

3. The research idea: PQC as a DevSecOps control plane

This proposal introduces PQC-Auto, a DevSecOps framework that makes crypto-agility a pipeline property. The framework treats the CBOM as the central artifact, just as SBOMs and provenance attestations became central artifacts for software supply-chain security.

Figure 1: Six-stage PQC automation pipeline from discovery to release

Figure 1. PQC-Auto turns cryptographic migration into a repeatable engineering loop. Each stage writes evidence back to the CBOM and policy ledger.

PQC-Auto has six stages:

  1. Discover. Scan source code, build manifests, lockfiles, container layers, IaC, TLS configurations, certificates, KMS/HSM policies, and runtime handshakes. Normalize findings into a CBOM.
  2. Assess. Score each cryptographic asset by algorithm weakness, data sensitivity, retention horizon, exposure, key criticality, and migration readiness.
  3. Plan. Select a target profile, choose hybrid or pure-PQC paths, assign owners, and generate remediation tickets before a policy deadline becomes an outage.
  4. Transform. Apply codemods, upgrade libraries, rewrite certificate templates, and open migration pull requests with tests attached.
  5. Verify. Run known-answer tests, interoperability checks, performance baselines, downgrade checks, and policy validation in CI.
  6. Release. Deploy through canaries, dual-stack negotiation, feature flags, SLO gates, and automated rollback. Emit signed evidence for audit.

The novelty is not a single scanner. It is the closed loop: discovery produces a machine-readable inventory; the inventory drives risk and migration decisions; migration is implemented as ordinary software change; and runtime observation refreshes the inventory. Crypto-agility becomes a property of the delivery system.

4. Framework design

4.1 Discovery: build the cryptographic dependency graph

Discovery must observe more than import statements. A cryptographic dependency graph should connect application code, libraries, container images, IaC, certificates, KMS/HSM policies, runtime workloads, and external APIs. Static analysis finds explicit calls and package versions. Binary analysis finds linked crypto in legacy services. Configuration analysis finds TLS policies and certificate authorities. Runtime attestation finds what was actually negotiated.

Figure 2: A CBOM-centered cryptographic dependency graph

Figure 2. The CBOM is a graph, not a flat list. It links algorithms to workloads, keys, protocols, owners, and evidence so a policy change has a computable blast radius.

Each CBOM node should carry at least: algorithm family, parameters, protocol context, key lifetime, data classification, owner, source location, deployment location, and evidence freshness. The graph then supports questions that spreadsheets cannot: which services share a vulnerable signing key, which APIs block a profile change, and which workloads would be affected if RSA-2048 were disallowed next quarter?

4.2 Quantum-risk scoring

Risk scoring should be explainable and adjustable. A simple additive model is enough to start:

QR = w1·algorithm exposure + w2·data shelf life + w3·internet exposure + w4·key criticality + w5·dependency depth - w6·migration readiness

The point is not to produce a mystical number. The point is to make trade-offs explicit. A long-lived root signing key in an internet-facing identity service should outrank an internal test certificate. A service that already has algorithm abstraction and automated rotation should score lower than one with hard-coded keys in images. The weights become a governance artifact that can be reviewed, audited, and changed.

4.3 Policy-as-code: the migration contract

PQC-Auto needs a declarative target state. A policy profile should define acceptable algorithms, hybrid combinations, fallback windows, evidence requirements, and rollout behavior:

yaml
cryptoPolicy:
  profile: pqc-hybrid-2026
  keyExchange:
    hybrid: [X25519, ML-KEM-768]
  signatures: [ML-DSA-65]
  symmetric: [AES-256-GCM, SHA-384]
  fallback:
    allowed: [ECDHE-P256, RSA-2048]
    expires: 2027-06-30
  evidence:
    cbom: required
    testVectors: required
    rollout: canary

This policy becomes the contract between security, platform, and application teams. CI fails when code or configuration violates it. Production observes whether the estate drifts from it. Auditors receive evidence that the policy was enforced, not merely documented.

4.4 Zero-downtime crypto-agility

The hardest part is not generating a PQC pull request. It is changing a live cryptographic protocol without breaking peers. The framework therefore proposes staged rollout with dual-stack support: services temporarily accept both legacy and PQC algorithms, prefer PQC where possible, and retire fallback only after an evidence soak period.

Figure 3: Zero-downtime PQC rollout with canary and rollback gates

Figure 3. Crypto-agility uses software-delivery controls: dual-stack builds, canaries, SLO gates, evidence sealing, and fast rollback.

Zero-downtime is measured, not assumed. Candidate metrics include zero failed handshakes, no increase in authentication errors, p95 latency within budget, valid certificate chains, no unauthorized downgrade path, and a rollback time below a defined threshold. A migration that improves quantum posture but breaks checkout is not a successful migration.

5. Research questions and hypotheses

This study is organized around four research questions.

RQ1. How completely can automated discovery reconstruct the cryptographic dependency graph of a containerized microservice estate?

RQ2. Which risk-scoring features best predict migration priority and remediation effort?

RQ3. Can policy-driven PQC changes be released through CI/CD with zero downtime and acceptable performance overhead?

RQ4. How do developer and security workflows change when cryptographic evidence becomes a pipeline artifact?

Corresponding hypotheses:

  • H1. A hybrid discovery approach combining static, configuration, binary, and runtime analysis will materially outperform source-code scanning alone.
  • H2. Risk scores that include data shelf life and exposure will correlate better with practitioner priority rankings than algorithm-only scoring.
  • H3. Dual-stack deployment with canary gates will reduce failed handshakes and rollback time compared with direct algorithm replacement.
  • H4. Teams using CBOM-linked migration pull requests will require fewer manual clarification cycles than teams receiving spreadsheet-based findings.

6. Methodology

The study will follow design science research: build an artifact, demonstrate it on relevant problems, evaluate it, and reflect on its generalizability. The work packages are:

  1. Problem framing. Interview platform, security, and application engineers. Map current cryptographic change processes and failure modes.
  2. Artifact construction. Implement a discovery prototype, CBOM schema extension, risk model, policy validator, migration generators, and rollout controller.
  3. Benchmark corpus. Build or curate a corpus of containerized services in Go, Java, Node.js, and Python with known cryptographic usage, including legacy RSA/ECDSA paths and modern TLS configurations.
  4. Controlled experiments. Compare discovery techniques, score rankings, direct versus dual-stack migration, and rollback behavior under failure injection.
  5. Practitioner evaluation. Run task-based sessions with engineers to measure time to identify, fix, and verify a cryptographic dependency.
  6. Case refinement. Apply the framework to a realistic Kubernetes testbed with ingress, service mesh, certificate issuance, KMS integration, and CI/CD.

All artifacts will be versioned. Discovery output, policy decisions, test results, and rollout telemetry will be retained as an evaluation dataset, with sensitive data redacted.

7. Evaluation plan

Evaluation should cover accuracy, engineering efficiency, reliability, and security assurance.

DimensionExample metrics
Discovery qualityprecision, recall, F1, coverage by source layer, false-positive rate
Inventory qualityCBOM completeness, evidence freshness, owner attribution, drift detection time
Risk scoringrank correlation with expert prioritization, calibration against remediation effort
Migration automationpercentage of generated changes that pass CI, manual edits required, time to pull request
Security verificationknown-answer test pass rate, downgrade prevention, policy violation escape rate
Reliabilityfailed handshakes, authentication errors, p95/p99 latency delta, rollback time
Developer experiencetime to understand finding, time to remediate, perceived trust in evidence

A candidate success threshold would be recall above 0.90 for declared library algorithms, recall above 0.75 for configuration and runtime layers, no unauthorized fallback during policy enforcement, rollback under five minutes, and p95 latency overhead within an agreed budget such as 5%. These thresholds should be validated with practitioners rather than treated as universal truths.

8. Timeline and deliverables

A 12-month programme is realistic:

  • Months 1-2: literature review, interviews, threat model, CBOM schema requirements.
  • Months 3-5: discovery prototype and benchmark corpus.
  • Months 6-7: risk model, policy validator, and migration planner.
  • Months 8-9: transformation generators, verification suite, and rollout controller.
  • Months 10-11: controlled experiments, practitioner evaluation, case study.
  • Month 12: open artifacts, paper, practitioner guide, and policy recommendations.

Deliverables include an open-source discovery toolkit, a CBOM extension for cryptographic evidence, a reusable policy profile set, a reference Kubernetes architecture, an evaluation dataset, and a practitioner guide for PQC migration in CI/CD.

9. Risks, ethics, and limitations

Several risks could affect validity. Vendor support for PQC signatures is uneven. HSM and FIPS boundaries may constrain algorithm choices. Legacy binaries may resist analysis. Hybrid deployments can introduce negotiation complexity and latency. A false negative in discovery may create dangerous confidence; a false positive may waste engineering time.

The research should avoid exploit development and focus on defensive migration. Interviews and telemetry should be data-minimized and redacted. Vendor claims should be verified with interoperability tests rather than accepted from documentation. Finally, the framework does not claim to replace cryptographic review. It makes review scalable, evidence-based, and continuous.

10. Expected contributions

The expected contributions are fourfold.

  • Conceptual: define crypto-agility as an observable delivery-system property rather than a vague architectural aspiration.
  • Methodological: provide a repeatable design science methodology for studying cryptographic migration in CI/CD.
  • Technical: deliver a CBOM-centered framework that links discovery, risk scoring, migration, verification, and rollout.
  • Practical: give platform teams a path to PQC readiness that fits existing engineering workflows and preserves availability.

11. Conclusion

Post-quantum migration will not be won by replacing algorithms in a slide deck. It will be won or lost in repositories, build systems, certificate pipelines, service meshes, key stores, and incident runbooks. The central research challenge is to make that estate visible and changeable without stopping the business.

PQC-Auto proposes a way forward: treat cryptography as infrastructure, represent it as a living CBOM, govern it with policy-as-code, migrate it through normal delivery pipelines, and prove zero-downtime behavior with evidence. If the hypothesis holds, the same framework that prepares an organization for PQC will also improve its ability to handle the next cryptographic change, because crypto-agility is not a destination. It is the capacity to change safely, repeatedly, and with proof.

Sources

Caleb Ngeno

About the author

Caleb Ngeno

Lead Developer

Founder and lead developer with expertise in full-stack development and cloud solutions.

Share this article

Work with TechGaetano

Hardening a production environment?

TechGaetano helps teams design zero-trust controls, review identity and network boundaries, and turn security policy into engineering practice.

Talk to a security engineer

Frequently asked questions

What is Post-Quantum Cryptography Automation in CI/CD Pipelines?

Abstract. Cryptographic migration is no longer a distant research topic. NIST finalized ML KEM, ML DSA, and SLH DSA in 2024; migration guidance now points toward deprecating quantum vulnerable algorithms by 2030 and disallowing them by 2035. Yet most organizat.

How should a team get started with Post-Quantum Cryptography Automation in CI/CD Pipelines?

Start with asset and identity inventory, define the trust boundaries, and roll out controls in phases: identity, device posture, least-privilege access, segmentation, then continuous verification.

What should teams avoid when working on Post-Quantum Cryptography Automation in CI/CD Pipelines?

The main risks are treating zero trust as a product purchase, leaving standing privileges in place, and assuming the model or the network perimeter is a security boundary.

Further reading

Related posts