Blog

Durante anos, a segurança digital se apoiou em um dogma simples: se é matematicamente difícil, é seguro. Mas e se, de repente, o que era impossível se tornasse trivial? É isso que o avanço da computação quântica promete — ou ameaça — fazer.

Os algoritmos que sustentam praticamente toda a infraestrutura de confiança do mundo digital — RSA, ECDSA, Ed25519 — estão com os dias contados. E para quem vive no universo DevSecOps, isso significa uma coisa: chegou a hora de adicionar um Q a mais nas suas pipelines.

O Q que muda tudo

O “Q” de quântico não é apenas uma letra a mais. É uma nova variável na equação da segurança.

Computadores quânticos não são apenas máquinas mais rápidas; eles pensam diferente. Enquanto um computador clássico tenta quebrar uma chave de criptografia testando bilhões de combinações sequenciais, um quântico explora milhões de estados simultâneos — e encontra o caminho direto.

Em outras palavras, o que antes levava séculos de tentativa e erro agora pode ser resolvido em minutos. Quando isso acontecer, toda assinatura digital clássica poderá ser adulterada, e toda comunicação “segura” poderá ser aberta como um livro.

O novo campo de batalha

O NIST, órgão americano que define padrões globais de segurança, encerrou em 2024 uma das maiores corridas científicas da história moderna: o processo de padronização da criptografia pós-quântica.

O resultado foi uma nova geração de algoritmos projetados não apenas para resistir aos ataques clássicos, mas também aos ataques de computadores quânticos.

Entre eles, o destaque vai para:

⚫CRYSTALS-Dilithium, o novo padrão para assinaturas digitais;
⚫ CRYSTALS-Kyber, para troca de chaves seguras;
⚫ e Falcon e SPHINCS+, para cenários específicos que exigem assinaturas mais compactas ou baseadas em hashes.

Esses nomes vão se tornar tão comuns quanto “RSA” e “AES” foram um dia. São as novas fundações da confiança digital.

O impacto nas pipelines e na cultura DevSecOps

Para quem vive o ciclo contínuo de build, teste, release e monitoramento, a segurança já não é mais uma etapa — é um DNA. E esse DNA agora precisa evoluir.

A assinatura de builds, a validação de artefatos e a publicação de imagens Docker dependem de algoritmos clássicos. Eles ainda funcionam, mas têm um prazo de validade criptográfico.

É aqui que entra o modelo híbrido, o primeiro passo da adaptação quântica: combinar uma assinatura tradicional com uma assinatura pós-quântica sobre o mesmo artefato.

Hoje, você assina com Ed25519. Amanhã, adiciona o Dilithium no mesmo pipeline. O resultado é um build duplamente confiável — compatível com o presente, mas pronto para o futuro.

Exemplo prático: pipeline híbrida (clássica + pós-quântica)

A seguir, um exemplo completo de pipeline GitLab CI/CD que implementa a abordagem híbrida: ela gera um manifesto de hashes, assina com RSA-3072 (clássico) e depois com Dilithium3 (pós-quântico) usando liboqs-python.

O resultado é um bundle JSON contendo ambas as assinaturas, pronto para auditoria e validação.

Estrutura do projeto

Script de assinatura PQC — ci/sign_pqc.py

import base64, hashlib, os, sys
from oqs import Signature

ALG = os.environ.get("OQS_SIG_ALG", "Dilithium3")
ART = os.environ.get("ARTIFACT_PATH", "artifact/.filehashes")

with open(ART, "rb") as f:
    data = f.read()
digest = hashlib.sha256(data).digest()

PQC_SK_B64 = os.environ.get("PQC_SK_B64")
PQC_PK_B64 = os.environ.get("PQC_PK_B64", "")

if not PQC_SK_B64:
    print("PQC_SK_B64 não definida", file=sys.stderr)
    sys.exit(2)

sk = base64.b64decode(PQC_SK_B64)
pk = base64.b64decode(PQC_PK_B64) if PQC_PK_B64 else None

sig = Signature(ALG, secret_key=sk)
signature = sig.sign(digest)
sig_b64 = base64.b64encode(signature).decode()

print(sig_b64)  # stdout: assinatura PQC em base64

if pk:
    with open("artifact/.filehashes.dilithium.pub", "wb") as f:
        f.write(base64.b64encode(pk))

Pipeline GitLab — .gitlab-ci.yml

image: python:3.11-slim

stages:
  - package
  - sign
  - bundle

variables:
  CODE_DIR: "app"
  OQS_SIG_ALG: "Dilithium3"

package_artifact:
  stage: package
  image: alpine:latest
  before_script:
    - apk add --no-cache tar coreutils
  script:
    - mkdir -p artifact/
    - find "$CODE_DIR" -type f ! -name "artifact/.filehashes" -exec sha256sum {} \; > artifact/.filehashes
  artifacts:
    paths:
      - artifact/.filehashes

sign_classic:
  stage: sign
  image: alpine:latest
  needs: [package_artifact]
  before_script:
    - apk add --no-cache openssl coreutils
    - printf '%s' "$CLASSIC_SK_PEM" > classic_sk.pem
  script:
    - ARTIFACT_PATH="artifact/.filehashes"
    - openssl dgst -sha256 -sign classic_sk.pem -out "$ARTIFACT_PATH.rsa.sig" "$ARTIFACT_PATH"
    - base64 -w0 "$ARTIFACT_PATH.rsa.sig" > "$ARTIFACT_PATH.rsa.b64"
    - sha256sum "$ARTIFACT_PATH" | awk '{print $1}' > "$ARTIFACT_PATH.sha256"
  artifacts:
    paths:
      - artifact/.filehashes.*
    expire_in: 1 week

sign_pqc:
  stage: sign
  image: python:3.11-slim
  needs: [package_artifact]
  before_script:
    - apt-get update && apt-get install -y --no-install-recommends git build-essential cmake ninja-build pkg-config libssl-dev
    - pip install --no-cache-dir liboqs-python==0.14.0
  script:
    - python ci/sign_pqc.py > artifact/.filehashes.dilithium.sig.b64
  artifacts:
    paths:
      - artifact/.filehashes.dilithium.*
    expire_in: 1 week

bundle_signatures:
  stage: bundle
  image: alpine:latest
  needs:
    - sign_classic
    - sign_pqc
  before_script:
    - apk add --no-cache jq coreutils
  script:
    - ART="artifact/.filehashes"
    - HASH_HEX=$(cat "$ART.sha256")
    - SIG_CLASSIC_B64=$(cat "$ART.rsa.b64")
    - SIG_PQC_B64=$(cat "$ART.dilithium.sig.b64")
    - PK_PQC_B64=$(cat "$ART.dilithium.pub" 2>/dev/null || echo "")
    - |
      jq -n \
        --arg hash "$HASH_HEX" \
        --arg sig_classic_b64 "$SIG_CLASSIC_B64" \
        --arg sig_pqc_b64 "$SIG_PQC_B64" \
        --arg pk_pqc_b64 "$PK_PQC_B64" \
        '{
          hash_sha256: $hash,
          signatures: [
            { scheme: "classic", algorithm: "RSA-PSS-SHA256", signature_b64: $sig_classic_b64 },
            { scheme: "pqc", algorithm: "Dilithium3", signature_b64: $sig_pqc_b64, public_key_b64: $pk_pqc_b64 }
          ]
        }' > artifact/.filehashes.sigbundle.json
  artifacts:
    paths:
      - artifact/.filehashes.sigbundle.json

Esse modelo demonstra o princípio da assinatura híbrida: duas camadas de confiança coexistindo no mesmo artefato.
Hoje, a assinatura clássica garante compatibilidade. Amanhã, a pós-quântica garantirá a sobrevivência.

O DevSecOps do futuro é pós-quântico

A chegada da computação quântica é inevitável — mas a perda da segurança não precisa ser.

Aqueles que incorporarem desde já práticas e ferramentas pós-quânticas terão uma vantagem gigantesca quando o colapso da criptografia clássica começar.

Isso vai além da tecnologia. É sobre preparação.

É sobre escrever código que sobreviva ao tempo — e ao avanço da ciência. Cada build assinado com Dilithium, cada chave migrada para um padrão resistente a qubits, é um investimento no amanhã.

Conclusão — o commit que vai atravessar o tempo

A revolução quântica não será um “dia zero” de caos — será uma transição silenciosa. Os sistemas preparados continuarão funcionando. Os outros, simplesmente, deixarão de ser confiáveis.

Adicionar um “Q” ao seu DevSecOps não é uma tendência futurista. É um movimento inevitável de quem entende que segurança não é apenas reagir a ameaças, mas antecipar o futuro.

A próxima revolução da segurança digital já começou — e ela assina seu código em duas dimensões: a clássica e a quântica.