GAP-Q1: Post-Quantum Signature Hardening - EPCC Implementation Plan¶

HybridSignature = Ed25519(message) || ML-DSA-44(message)

Total size: 64 + 2,420 = 2,484 bytes
Verification: Both must pass

┌─────────────────────────────────────────────────────────────────────┐
│                     Override Workflow                                │
│  ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐        │
│  │  DomainLead     │ │   RiskOfficer   │ │  Verification   │        │
│  │  (Signer 1)     │ │   (Signer 2)    │ │                 │        │
│  └────────┬────────┘ └────────┬────────┘ └────────┬────────┘        │
└───────────┼────────────────────┼────────────────────┼───────────────┘
            │                    │                    │
            ▼                    ▼                    ▼
┌─────────────────────────────────────────────────────────────────────┐
│                    HybridSignatureProvider                          │
│  ┌─────────────────────────────────────────────────────────────┐    │
│  │  sign(message, keypair) → HybridSignature                   │    │
│  │  verify(signature, message, public_keys) → bool             │    │
│  │  generate_keypair() → HybridKeyPair                         │    │
│  └─────────────────────────────────────────────────────────────┘    │
└───────────────────────────────────┬─────────────────────────────────┘
                                    │
            ┌───────────────────────┼───────────────────────┐
            ▼                       ▼                       ▼
┌─────────────────────┐ ┌─────────────────────┐ ┌─────────────────────┐
│   Ed25519Provider   │ │   MLDSAProvider     │ │   KeyStorage        │
│   (cryptography)    │ │   (liboqs-python)   │ │   (encrypted)       │
└─────────────────────┘ └─────────────────────┘ └─────────────────────┘

from dataclasses import dataclass
from enum import Enum
from typing import Optional

class SignatureAlgorithm(str, Enum):
    """Signature algorithm identifiers."""
    ED25519 = "Ed25519"
    ML_DSA_44 = "ML-DSA-44"
    ML_DSA_65 = "ML-DSA-65"
    HYBRID_ED25519_ML_DSA_44 = "Ed25519+ML-DSA-44"

@dataclass
class HybridPublicKey:
    """Combined classical + post-quantum public key."""
    classical: bytes          # Ed25519 public key (32 bytes)
    post_quantum: bytes       # ML-DSA public key (1,312 bytes)
    algorithm: SignatureAlgorithm = SignatureAlgorithm.HYBRID_ED25519_ML_DSA_44

@dataclass
class HybridPrivateKey:
    """Combined classical + post-quantum private key."""
    classical: bytes          # Ed25519 private key (32 bytes)
    post_quantum: bytes       # ML-DSA private key (2,560 bytes)
    algorithm: SignatureAlgorithm = SignatureAlgorithm.HYBRID_ED25519_ML_DSA_44

@dataclass
class HybridKeyPair:
    """Complete hybrid key pair."""
    public: HybridPublicKey
    private: HybridPrivateKey

@dataclass
class HybridSignature:
    """Combined classical + post-quantum signature."""
    classical: bytes          # Ed25519 signature (64 bytes)
    post_quantum: bytes       # ML-DSA signature (2,420 bytes)
    algorithm: SignatureAlgorithm = SignatureAlgorithm.HYBRID_ED25519_ML_DSA_44

    def to_bytes(self) -> bytes:
        """Serialize to bytes for storage."""
        return self.classical + self.post_quantum

    @classmethod
    def from_bytes(cls, data: bytes) -> "HybridSignature":
        """Deserialize from bytes."""
        return cls(
            classical=data[:64],
            post_quantum=data[64:],
        )

-- Update WorkflowTransition to handle larger signatures
ALTER TABLE workflow_transitions
    ALTER COLUMN signature TYPE BYTEA,
    ADD COLUMN signature_algorithm VARCHAR(50) DEFAULT 'Ed25519';

-- Index for algorithm-based queries
CREATE INDEX idx_transition_algorithm ON workflow_transitions(signature_algorithm);

-- Key storage table (encrypted at rest)
CREATE TABLE governance_keys (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    actor_id VARCHAR(100) NOT NULL UNIQUE,
    public_key_classical BYTEA NOT NULL,        -- 32 bytes
    public_key_pq BYTEA NOT NULL,               -- 1,312 bytes
    encrypted_private_key BYTEA NOT NULL,       -- Encrypted blob
    algorithm VARCHAR(50) NOT NULL DEFAULT 'Ed25519+ML-DSA-44',
    created_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT NOW(),
    rotated_at TIMESTAMP WITH TIME ZONE,
    expires_at TIMESTAMP WITH TIME ZONE
);

# src/crypto/pqc.py
"""Post-Quantum Cryptography primitives using liboqs."""

import oqs
from dataclasses import dataclass
from typing import Tuple

ALGORITHM = "Dilithium2"  # ML-DSA-44

def generate_ml_dsa_keypair() -> Tuple[bytes, bytes]:
    """Generate ML-DSA-44 key pair.

    Returns:
        Tuple of (public_key, private_key)
    """
    with oqs.Signature(ALGORITHM) as signer:
        public_key = signer.generate_keypair()
        private_key = signer.export_secret_key()
        return public_key, private_key

def ml_dsa_sign(message: bytes, private_key: bytes) -> bytes:
    """Sign message with ML-DSA-44.

    Args:
        message: Message to sign
        private_key: ML-DSA private key

    Returns:
        Signature bytes (~2,420 bytes)
    """
    with oqs.Signature(ALGORITHM, private_key) as signer:
        return signer.sign(message)

def ml_dsa_verify(signature: bytes, message: bytes, public_key: bytes) -> bool:
    """Verify ML-DSA-44 signature.

    Args:
        signature: Signature to verify
        message: Original message
        public_key: ML-DSA public key

    Returns:
        True if valid, False otherwise
    """
    with oqs.Signature(ALGORITHM) as verifier:
        return verifier.verify(message, signature, public_key)

# src/crypto/hybrid.py
"""Hybrid signature scheme: Ed25519 + ML-DSA-44."""

from cryptography.hazmat.primitives.asymmetric.ed25519 import (
    Ed25519PrivateKey,
    Ed25519PublicKey,
)
from dataclasses import dataclass
from . import pqc

@dataclass
class HybridSignatureProvider:
    """Provider for hybrid classical + post-quantum signatures."""

    def generate_keypair(self) -> HybridKeyPair:
        """Generate new hybrid key pair."""
        # Classical (Ed25519)
        classical_private = Ed25519PrivateKey.generate()
        classical_public = classical_private.public_key()

        # Post-quantum (ML-DSA-44)
        pq_public, pq_private = pqc.generate_ml_dsa_keypair()

        return HybridKeyPair(
            public=HybridPublicKey(
                classical=classical_public.public_bytes_raw(),
                post_quantum=pq_public,
            ),
            private=HybridPrivateKey(
                classical=classical_private.private_bytes_raw(),
                post_quantum=pq_private,
            ),
        )

    def sign(self, message: bytes, private_key: HybridPrivateKey) -> HybridSignature:
        """Create hybrid signature.

        Both Ed25519 and ML-DSA signatures are generated.
        """
        # Classical signature
        ed_key = Ed25519PrivateKey.from_private_bytes(private_key.classical)
        classical_sig = ed_key.sign(message)

        # Post-quantum signature
        pq_sig = pqc.ml_dsa_sign(message, private_key.post_quantum)

        return HybridSignature(
            classical=classical_sig,
            post_quantum=pq_sig,
        )

    def verify(
        self,
        signature: HybridSignature,
        message: bytes,
        public_key: HybridPublicKey,
    ) -> bool:
        """Verify hybrid signature.

        Both signatures must be valid.
        """
        # Verify classical
        try:
            ed_key = Ed25519PublicKey.from_public_bytes(public_key.classical)
            ed_key.verify(signature.classical, message)
            classical_valid = True
        except Exception:
            classical_valid = False

        # Verify post-quantum
        pq_valid = pqc.ml_dsa_verify(
            signature.post_quantum,
            message,
            public_key.post_quantum,
        )

        return classical_valid and pq_valid

Phase A: Preparation (Week 1-2)
├── Deploy liboqs-python to all environments
├── Generate hybrid key pairs for all governance actors
├── Update database schema
└── Deploy new code (backward compatible)

Phase B: Parallel Operation (Week 3-6)
├── New overrides use hybrid signatures
├── Old overrides remain valid (Ed25519 only)
├── Monitor for issues
└── Validate audit trail integrity

Phase C: Cutover (Week 7+)
├── Require hybrid signatures for new overrides
├── Mark Ed25519-only as deprecated
└── Plan Ed25519 sunset date

def verify_signature(
    signature: bytes,
    message: bytes,
    public_key: bytes,
    algorithm: SignatureAlgorithm,
) -> bool:
    """Verify signature with algorithm-specific logic."""
    if algorithm == SignatureAlgorithm.ED25519:
        # Legacy Ed25519 only
        return ed25519_verify(signature, message, public_key)

    elif algorithm == SignatureAlgorithm.HYBRID_ED25519_ML_DSA_44:
        # Hybrid verification
        hybrid_sig = HybridSignature.from_bytes(signature)
        hybrid_key = HybridPublicKey.from_bytes(public_key)
        return provider.verify(hybrid_sig, message, hybrid_key)

    else:
        raise ValueError(f"Unknown algorithm: {algorithm}")

# requirements.txt additions
liboqs-python>=0.9.0       # Post-quantum algorithms

GAP-M4 (BIP-322) ──────► GAP-Q1 (Post-Quantum)
                         │
                         ├── liboqs-python
                         ├── Database schema update
                         └── Key management infrastructure