A physically-anchored, bidirectionally-bounded time-locked encryption scheme can be constructed by combining two mechanisms: (1) cryptographic keys derived from the phase-coherent timing residuals of a minimum three-pulsar array at a target epoch T_target, preventing pre-epoch decryption since the required physical observables do not exist until T_target; and (2) an ephemeral session key transmitted exclusively during the T_target ± window and never stored, preventing post-epoch decryption since archived pulsar timing data recovers only the outer key while the session key is permanently destroyed. Together these designate the universe as the root of trust for the forward TTL and irreversible key erasure for the backward TTL — producing a message that is physically undecryptable both before and after its intended window, without relying on any trusted third party or mathematical hardness assumptions vulnerable to quantum attack.

A bidirectionally time-locked encryption scheme (BTLE) can be constructed such that: (1) a ciphertext C encrypted at time T_enc < T_target remains computationally and physically undecryptable until epoch T_target, because the outer decryption key K_outer is derived deterministically from the phase-coherent timing residuals R(T_target) of ≥3 millisecond pulsars (MSPs) observed simultaneously at T_target, residuals that do not physically exist before T_target; and (2) the same ciphertext becomes permanently undecryptable after T_target + Δ (where Δ is a defined window, e.g., 60–3600 seconds), because an ephemeral session key K_session required to decrypt the inner layer is transmitted only during [T_target, T_target + Δ], never stored, and irreversibly erased. The scheme requires no trusted third party, no mathematical hardness assumption vulnerable to Grover's or Shor's algorithms, and no pre-committed secret. Falsifiable prediction: any adversary — including one with a quantum computer — cannot decrypt C outside [T_target, T_target + Δ] with probability > 2^-128, given that (a) K_session erasure is verified, (b) pulsar timing residuals at T_target are unpredictable to within σ_residual < 1 μs before T_target, and (c) the key derivation function maps residuals to keys with ≥128-bit entropy.

PHASE 0 — SIMULATION BASELINE (Weeks 1–4): Simulate the full BTLE scheme using historical pulsar timing data from IPTA DR2 (International Pulsar Timing Array Data Release 2) as a proxy for "future" residuals. Treat data from epoch T_sim as the target epoch and data before T_sim as the adversary's knowledge base.

PHASE 1 — ENTROPY QUANTIFICATION (Weeks 3–8): Using IPTA DR2 and NANOGrav 15-year dataset, compute the conditional entropy H(R_i(T) | {R_i(t): t < T-24h}) for 5 MSPs across 50 target epochs. Fit timing noise models (ENTERPRISE/TEMPO2) and measure residual unpredictability.

PHASE 2 — KEY DERIVATION SECURITY (Weeks 5–10): Implement HKDF-SHA3-256 key derivation from simulated residuals. Run 10,000 Monte Carlo trials varying residual noise realizations. Measure key entropy, collision probability, and sensitivity to residual quantization (1 ns, 10 ns, 100 ns bins).

PHASE 3 — PROTOCOL IMPLEMENTATION (Weeks 8–16): Build full BTLE stack: encryption engine (Python/Rust), HSM integration (SoftHSM2 for simulation, Thales Luna for hardware test), session key transmission protocol (TLS 1.3 + pre-shared key), and erasure verification module.

PHASE 4 — LIVE TELESCOPE PILOT (Weeks 16–32): Partner with Parkes Pulsar Timing Array (PPTA) or MeerKAT for a live test: encrypt a test message at T_enc, derive K_outer from actual MSP residuals at T_target (T_target = T_enc + 7 days), transmit K_session during Δ = 300 seconds, verify decryption succeeds only within window.

PHASE 5 — ADVERSARIAL RED-TEAM (Weeks 20–36): Engage independent cryptographers and astrophysicists to attempt: (a) residual prediction attacks, (b) K_session recovery after erasure, (c) spoofing simulations, (d) side-channel attacks on HSM.

# BTLE System Architecture — Pseudocode Outline
# ================================================

# === ENCRYPTION (at T_enc) ===
def btle_encrypt(plaintext, T_target, delta_seconds, pulsar_ids, salt):
    # 1. Generate ephemeral session key
    K_session = HSM.generate_csprng_key(256)  # Never leaves HSM until T_target
    HSM.store_with_release_schedule(K_session, T_target, T_target + delta_seconds)
    
    # 2. Encrypt plaintext with session key (inner layer)
    inner_ciphertext = AES_256_GCM.encrypt(K_session, plaintext)
    
    # 3. Construct pulsar key derivation commitment
    commitment = {
        'T_target': T_target,
        'pulsar_ids': pulsar_ids,  # e.g., ['J0437-4715', 'J1909-3744', 'J1713+0747']
        'quantization_ns': 10,     # 10 ns bins
        'salt': salt,              # 256-bit random salt, public
        'kdf': 'HKDF-SHA3-256'
    }
    
    # 4. Encrypt inner ciphertext with placeholder outer key
    # (outer key K_outer does not exist yet — commitment is stored in header)
    outer_ciphertext = ChaCha20_Poly1305.encrypt_with_commitment(
        commitment, inner_ciphertext
    )
    
    # 5. Package ciphertext bundle
    bundle = {
        'version': 'BTLE-1.0',
        'commitment': commitment,
        'outer_ciphertext': outer_ciphertext,
        'hsm_endpoint': HSM.get_public_endpoint(),
        'hsm_attestation': HSM.sign(commitment)
    }
    return bundle

# === KEY DERIVATION (at T_target, by authorized receiver) ===
def derive_outer_key(pulsar_residuals, commitment):
    # pulsar_residuals: dict {pulsar_id: residual_ns (float)}
    # Quantize residuals to 10 ns bins
    quantized = []
    for pid in commitment['pulsar_ids']:
        r = pulsar_residuals[pid]
        r_q = round(r / commitment['quantization_ns']) * commitment['quantization_ns']
        quantized.append(r_q.to_bytes(8, 'big'))  # 64-bit signed integer
    
    # Concatenate and derive key
    residual_bytes = b''.join(quantized)
    K_outer = HKDF_SHA3_256(
        ikm=residual_bytes,
        salt=commitment['salt'],
        info=f"BTLE-outer-{commitment['T_target']}".encode(),
        length=32  # 256 bits
    )
    return K_outer

# === DECRYPTION (during [T_target, T_target + delta]) ===
def btle_decrypt(bundle, telescope_data):
    T_now = get_verified_utc_time()  # GPS-disciplined clock
    commitment = bundle['commitment']
    
    # Verify timing window
    assert commitment['T_target'] <= T_now <= commitment['T_target'] + commitment['delta']
    
    # Step 1: Compute pulsar residuals from telescope data
    residuals = compute_timing_residuals(
        telescope_data,
        pulsar_ids=commitment['pulsar_ids'],
        ephemeris='DE440',
        timing_model='TEMPO2'
    )
    
    # Step 2: Derive outer key from physical observables
    K_outer = derive_outer_key(residuals, commitment)
    
    # Step 3: Decrypt outer layer
    inner_ciphertext = ChaCha20_Poly1305.decrypt(K_outer, bundle['outer_ciphertext'])
    
    # Step 4: Retrieve session key from HSM (only available during window)
    K_session = HSM.retrieve_session_key(
        endpoint=bundle['hsm_endpoint'],
        attestation=bundle['hsm_attestation'],
        T_now=T_now
    )
    # HSM enforces: returns K_session only if T_target <= T_now <= T_target + delta
    # HSM executes secure erase at T_target + delta regardless of retrieval
    
    # Step 5: Decrypt inner layer
    plaintext = AES_256_GCM.decrypt(K_session, inner_ciphertext)
    return plaintext

# === HSM SESSION KEY MANAGER ===
class BTLESessionKeyHSM:
    def store_with_release_schedule(self, K_session, T_release, T_erase):
        self.vault[id] = {
            'key': K_session,
            'T_release': T_release,
            'T_erase': T_erase,
            'retrieved': False
        }
        self.audit_log.append(('STORE', id, T_release, T_erase))
    
    def retrieve_session_key(self, id, T_now):
        entry = self.vault[id]
        if not (entry['T_release'] <= T_now <= entry['T_erase']):
            raise WindowViolationError("Outside decryption window")
        entry['retrieved'] = True
        self.audit_log.append(('RETRIEVE', id, T_now))
        return entry['key']
    
    def scheduled_erase(self):
        # Runs continuously; erases keys at T_erase
        for id, entry in self.vault.items():
            if get_utc_time() >= entry['T_erase']:
                secure_overwrite(entry['key'], passes=7)  # DoD 5220.22-M
                del self.vault[id]
                self.audit_log.append(('ERASE', id, get_utc_time()))

# === ENTROPY ESTIMATION PIPELINE ===
def estimate_residual_entropy(ipta_data, target_epochs, cutoff_hours=24):
    entropies = []
    for T_sim in target_epochs:
        # Train timing model