A post-quantum authenticated key exchange protocol (CRYSTALS-Kyber combined with a lattice-based digital signature) can be securely composed with a pulsar-timing-derived time-lock to authenticate ephemeral session key transmission during the T_target window, ensuring only pre-authorised parties can receive the session key even if the pulsar timing channel is observed by an adversary with a quantum computer.

A cryptographic protocol combining CRYSTALS-Kyber (NIST PQC KEM, security level 3, ~AES-192 equivalent) with CRYSTALS-Dilithium (lattice-based digital signature) can be securely composed with a pulsar-timing-array (PTA)-derived time-lock mechanism such that: (1) ephemeral session keys are encapsulated and released only within a deterministic time window T_target (±δ seconds, where δ ≤ 10s) derived from pulsar timing residuals; (2) the composition is IND-CCA2 secure against a quantum adversary with access to a fault-tolerant quantum computer running Shor's algorithm; (3) a pre-authorised party holding a valid Dilithium keypair can authenticate and decrypt the session key within T_target; and (4) an adversary observing the full pulsar timing channel and possessing quantum computational resources cannot recover the session key outside T_target with probability greater than 2^(-128).

Phase 1 — Formal Security Analysis (Weeks 1–6): Conduct a machine-checked security proof of the composed protocol using the EasyCrypt or CryptoVerif proof assistant. Model the PTA time-lock as a timed commitment scheme and prove the composition theorem under MLWE hardness. Target: produce a formal proof or identify a composition gap.

Phase 2 — Pulsar Timing Simulation (Weeks 4–10): Use TEMPO2/PINT pulsar timing software with real archival PTA data (NANOGrav 15-year dataset) to simulate T_target window generation. Measure timing residual distributions, window reliability, and susceptibility to adversarial timing prediction. Target: characterise δ achievable with ≥ 3 pulsars.

Phase 3 — Protocol Implementation and Benchmarking (Weeks 8–16): Implement the full protocol stack using liboqs (Open Quantum Safe) for Kyber-768/Dilithium3, integrated with a PTA timing oracle. Benchmark on commodity x86-64 hardware and ARM Cortex-A72. Measure: key generation time, encapsulation/decapsulation latency, signature generation/verification latency, end-to-end session establishment time within T_target.

Phase 4 — Adversarial Simulation (Weeks 12–20): Simulate quantum adversary capabilities using classical worst-case lattice reduction (BKZ-2.0 with block size β=40–60) as a proxy for quantum attacks. Attempt timing prediction attacks using full NANOGrav dataset. Measure attack success probability and compare against 2^(-128) threshold.

Phase 5 — Integration and Red-Team Testing (Weeks 18–24): Deploy prototype on a testbed with 2 geographically separated nodes. Conduct red-team exercises including replay attacks, timing manipulation, and side-channel probing. Measure protocol failure rate and security margin.

# ============================================================
# POST-QUANTUM PTA TIME-LOCK AUTHENTICATED KEY EXCHANGE
# Architecture Sketch (Python pseudocode)
# ============================================================

# --- DEPENDENCIES ---
# liboqs-python >= 0.8.0 (Kyber-768, Dilithium3)
# pint >= 0.9 (pulsar timing)
# tempo2 (pulsar ephemeris)
# numpy, scipy (timing analysis)

import oqs  # liboqs Python bindings
import pint_pulsar  # PINT pulsar timing
import hashlib, time, struct

# ============================================================
# COMPONENT 1: PTA TIME-LOCK ORACLE
# ============================================================

class PTATimeLockOracle:
    """
    Derives T_target windows from pulsar timing residuals.
    Uses ≥3 millisecond pulsars for robustness.
    """
    def __init__(self, pulsar_list, ephemeris_path, delta_seconds=120):
        self.pulsars = pulsar_list  # e.g., ['J0437-4715', 'J1713+0747', 'J1909-3744']
        self.ephemeris = load_ephemeris(ephemeris_path)  # TEMPO2/PINT ephemeris
        self.delta = delta_seconds  # window width in seconds

    def get_timing_residuals(self, utc_now):
        """
        Query current timing residuals for all pulsars.
        Returns: dict {pulsar_name: residual_ns}
        Precision target: ≤100 ns RMS
        """
        residuals = {}
        for psr in self.pulsars:
            toa = pint_pulsar.get_toa(psr, utc_now, self.ephemeris)
            predicted_toa = pint_pulsar.predict_toa(psr, utc_now, self.ephemeris)
            residuals[psr] = (toa - predicted_toa).to('ns').value
        return residuals

    def derive_window_seed(self, residuals):
        """
        Deterministically derive a window seed from timing residuals.
        Uses SHA3-256 over sorted residual vector.
        Both parties must observe same pulsars to agree on seed.
        """
        residual_bytes = b''.join(
            struct.pack('>d', residuals[psr]) for psr in sorted(self.pulsars)
        )
        return hashlib.sha3_256(residual_bytes).digest()  # 32 bytes

    def compute_T_target(self, utc_now):
        """
        Returns (t_open, t_close) as UTC timestamps.
        t_open = next pulse arrival time rounded to nearest δ boundary
        t_close = t_open + delta
        """
        residuals = self.get_timing_residuals(utc_now)
        seed = self.derive_window_seed(residuals)
        # Derive window offset from seed (0 to delta seconds)
        offset = int.from_bytes(seed[:4], 'big') % self.delta
        t_open = utc_now - (utc_now % self.delta) + offset
        if t_open <= utc_now:
            t_open += self.delta
        t_close = t_open + self.delta
        return (t_open, t_close, seed)

# ============================================================
# COMPONENT 2: KEY GENERATION
# ============================================================

class PartyKeyMaterial:
    """
    Generates and stores Kyber + Dilithium keypairs.
    """
    def __init__(self):
        # Kyber-768: KEM for session key encapsulation
        self.kem = oqs.KeyEncapsulation('Kyber768')
        self.kyber_pk = self.kem.generate_keypair()  # returns public key
        # kyber_sk stored internally in self.kem

        # Dilithium3: Digital signature for authentication
        self.sig = oqs.Signature('Dilithium3')
        self.dilithium_pk = self.sig.generate_keypair()  # returns public key
        # dilithium_sk stored internally in self.sig

    def export_public_keys(self):
        return {
            'kyber_pk': self.kyber_pk,      # 1184 bytes (Kyber-768)
            'dilithium_pk': self.dilithium_pk  # 1952 bytes (Dilithium3)
        }

# ============================================================
# COMPONENT 3: TIME-LOCKED ENCAPSULATION (SENDER/INITIATOR)
# ============================================================

def time_locked_encapsulate(
    recipient_kyber_pk,    # recipient's Kyber-768 public key
    sender_dilithium_sk,   # sender's Dilithium3 signing key (via oqs.Signature object)
    sender_dilithium_pk,   # sender's Dilithium3 public key (for verification)
    pta_oracle,            # PTATimeLockOracle instance
    sender_id,             # bytes: authenticated sender identifier
    recipient_id           # bytes: authenticated recipient identifier
):
    """
    Encapsulates a session key bound to T_target.
    Returns: (ciphertext_bundle, T_target_window)
    """
    # Step 1: Get current T_target window
    utc_now = time.time()
    t_open, t_close, window_seed = pta_oracle.compute_T_target(utc_now)

    # Step 2: Kyber encapsulation — generates session key + ciphertext
    kem_instance = oqs.KeyEncapsulation('Kyber768', secret_key=None)
    kyber_ciphertext, session_key = kem_instance.encap_secret(recipient_kyber_pk)
    # session_key: 32 bytes (256-bit shared secret)
    # kyber_ciphertext: 1088 bytes (Kyber-768)

    # Step 3: Bind ciphertext to T_target window
    # Commitment: H(kyber_ciphertext || t_open || t_close || sender_id || recipient_id)
    binding_data = (
        kyber_ciphertext +
        struct.pack('>QQ', int(t_open), int(t_close)) +
        sender_id + recipient_id
    )
    time_binding_hash = hashlib.sha3_256(binding_data).digest()

    # Step 4: Dilithium signature over binding
    # Signs: (kyber_ciphertext || time_binding_hash || window_seed)
    message_to_sign = kyber_ciphertext + time_binding_hash + window_seed
    signature = sender_dilithium_sk.sign(message_to_sign)
    # signature: 3293 bytes (Dilithium3)

    # Step 5: Assemble ciphertext bundle
    ciphertext_bundle = {
        'kyber_ciphertext': kyber_ciphertext,    # 1088 bytes
        'time_binding_hash': time_binding_hash,  # 32 bytes
        'window_seed': window_seed,              # 32 bytes
        't_open': t_open,                        # 8 bytes
        't_close': t_close,                      # 8 bytes
        'dilithium_signature': signature,        # 3293 bytes
        'sender_dilithium_pk': sender_dilithium_pk,  # 1952 bytes
        'sender_id': sender_id,
        'recipient_id': recipient_id
    }
    # Total bundle size: ~7.5 KB

    return ciphertext_bundle, (t_open, t_close)

# ============================================================
# COMPONENT 4: TIME-LOCKED DECAPSULATION (RECIPIENT)
# ============================================================

def time_locked_decapsulate(
    ciphertext_bundle,     # bundle from time_locked_encapsulate
    recipient_kem,         # oqs.KeyEncapsulation with recipient's Kyber-768 secret key
    pta_oracle,            # PTATimeLockOracle instance
    expected_sender_pk,    # pre-registered sender Dilithium3 public key
    recipient_id           # bytes: recipient's own identifier