Shor's Algorithm — Retroactive Decryption of RSA Archives

# io.thecodeforge.quantum.factoring.ShorClassicalSimulation

from math import gcd
from random import randrange
import time


def classical_order_finding(a: int, N: int) -> int:
    """Find the order r of a modulo N: smallest r > 0 where a^r ≡ 1 (mod N).

    This is the CLASSICAL bottleneck — O(r) time, and r can be up to N.
    Shor's quantum speedup replaces this with QFT-based period finding in O(n²).
    """
    x = 1
    for r in range(1, N):
        x = (x * a) % N
        if x == 1:
            return r
    return None


def shor_factor(N: int, max_trials: int = 20) -> tuple:
    """Shor's factoring algorithm (classical simulation of the quantum part).

    Steps:
    1. Handle trivial cases (even, perfect power)
    2. Pick random a coprime to N
    3. Find the order r of a mod N (this is where quantum speedup lives)
    4. If r is even, extract factors via GCD
    5. Repeat if necessary
    """
    # Trivial cases
    if N % 2 == 0:
        return (2, N // 2)
    if N <= 3:
        return None

    # Check if N is a perfect power
    for b in range(2, int(N**0.5) + 1):
        a_root = round(N ** (1.0 / b))
        if a_root ** b == N:
            return (a_root, N // a_root)

    for trial in range(max_trials):
        # Step 1: random a coprime to N
        a = randrange(2, N)
        g = gcd(a, N)
        if g > 1:
            # Lucky: a shares a factor with N directly
            print(f"  Trial {trial+1}: a={a}, gcd(a,N)={g} (lucky find!)")
            return (g, N // g)

        # Step 2: find order r (the quantum speedup point)
        r = classical_order_finding(a, N)

        if r is None or r % 2 != 0:
            print(f"  Trial {trial+1}: a={a}, r={r} (odd or None, retrying)")
            continue

        # Step 3: extract factors
        half_power = pow(a, r // 2, N)
        p = gcd(half_power - 1, N)
        q = gcd(half_power + 1, N)

        if 1 < p < N:
            print(f"  Trial {trial+1}: a={a}, r={r}, a^(r/2)={half_power}")
            print(f"    gcd({half_power}-1, {N}) = {p}")
            print(f"    gcd({half_power}+1, {N}) = {q}")
            return (p, N // p)
        if 1 < q < N:
            print(f"  Trial {trial+1}: a={a}, r={r}, a^(r/2)={half_power}")
            print(f"    gcd({half_power}-1, {N}) = {p}")
            print(f"    gcd({half_power}+1, {N}) = {q}")
            return (q, N // q)

        print(f"  Trial {trial+1}: a={a}, r={r} (trivial GCD, retrying)")

    return None


# --- Detailed walkthrough of N = 21 ---
print("=" * 60)
print("WALKTHROUGH: Factoring N = 21")
print("=" * 60)

N = 21
a = 2
print(f"\nN = {N}, chosen a = {a}")
print(f"gcd({a}, {N}) = {gcd(a, N)} — coprime, proceed.")

print(f"\nCompute sequence a^x mod N:")
x = 1
for i in range(1, 15):
    x = (x * a) % N
    print(f"  {a}^{i} mod {N} = {x}", end="")
    if x == 1:
        print(f"  ← period r = {i}")
        r = i
        break
    print()

print(f"\nr = {r} (even ✓)")
half = pow(a, r // 2, N)
print(f"a^(r/2) = {a}^{r//2} mod {N} = {half}")
print(f"gcd({half} - 1, {N}) = gcd({half-1}, {N}) = {gcd(half-1, N)}")
print(f"gcd({half} + 1, {N}) = gcd({half+1}, {N}) = {gcd(half+1, N)}")
print(f"\nFactors: {N} = {gcd(half-1, N)} × {N // gcd(half-1, N)}")

# --- Factor several numbers ---
print("\n" + "=" * 60)
print("FACTORIZATION DEMOS")
print("=" * 60)

for N in [15, 21, 35, 77, 143, 253, 1073]:
    print(f"\nFactoring N = {N}:")
    result = shor_factor(N, max_trials=10)
    if result:
        p, q = result
        print(f"  Result: {N} = {p} × {q}")
    else:
        print(f"  Failed after max trials")

# --- Timing comparison: classical order finding gets exponentially slower ---
print("\n" + "=" * 60)
print("CLASSICAL ORDER FINDING: TIME SCALING")
print("=" * 60)
print("\n  N (bits)  |  Max r  |  Classical steps  |  Quantum gates")
print("  ---------|---------|-------------------|----------------")
for bits in [4, 8, 12, 16, 32, 64, 128, 256, 512, 1024, 2048]:
    max_r = 2**bits
    classical = f"~2^{bits}"
    quantum = f"~{bits}² = {bits**bits if bits <= 10 else f'{bits}^{bits}'}"
    quantum_gates = f"~{bits**2:,}"
    print(f"  {bits:>7}  | 2^{bits:<4} |  {classical:<17} |  {quantum_gates}")

# io.thecodeforge.quantum.factoring.ShorQuantumSimulation

import numpy as np
from fractions import Fraction


def quantum_fourier_transform(n_qubits: int) -> np.ndarray:
    """Construct the Quantum Fourier Transform matrix for n qubits.

    The QFT maps |j⟩ → (1/√N) Σ_k exp(2πi·jk/N) |k⟩
    where N = 2^n.

    This is the quantum analogue of the DFT, but computed with
    O(n²) gates instead of O(n·2ⁿ) for classical FFT.
    """
    N = 2 ** n_qubits
    omega = np.exp(2j * np.pi / N)
    qft = np.zeros((N, N), dtype=complex)
    for j in range(N):
        for k in range(N):
            qft[j, k] = omega ** (j * k) / np.sqrt(N)
    return qft


def continued_fraction(x: float, max_denominator: int = 1000) -> list:
    """Compute continued fraction expansion of x.

    Returns list of partial quotients [a0, a1, a2, ...].
    This is the key step most explanations skip: how do you go from
    the measured value y/2^n to the period r?
    """
    quotients = []
    while len(quotients) < 20:
        a = int(np.floor(x))
        quotients.append(a)
        frac = x - a
        if abs(frac) < 1e-10:
            break
        x = 1.0 / frac
        if quotients[-1] > max_denominator:
            break
    return quotients


def convergents(quotients: list) -> list:
    """Compute convergents (rational approximations) from continued fraction.

    Each convergent p/q is a candidate for the period r.
    The last convergent with denominator ≤ 2^n is our best guess.
    """
    results = []
    for i in range(len(quotients)):
        num, denom = 1, 0
        for j in range(i, -1, -1):
            num, denom = quotients[j] * num + denom, num
        results.append((denom, num))  # (numerator, denominator)
    return results


def simulate_shor_period_finding(a: int, N: int, n_precision: int = 10) -> int:
    """Simulate the quantum period finding subroutine.

    In a real quantum computer:
    1. Hadamard gates create superposition of |0⟩ to |2^n - 1⟩
    2. Controlled modular exponentiation maps |x⟩ → |x⟩|a^x mod N⟩
    3. QFT on first register extracts period via interference
    4. Measurement gives y ≈ k·(2^n / r) for some integer k
    5. Continued fractions extract r from y/2^n

    This simulation directly computes the period (replacing the quantum steps)
    but shows the continued fraction extraction that would happen after measurement.
    """
    # Classical order finding (this is what the quantum computer replaces)
    x = 1
    for r in range(1, N):
        x = (x * a) % N
        if x == 1:
            break
    else:
        return None

    # Simulate what the quantum measurement would give:
    # y/2^n ≈ k/r for some random k coprime to r
    from random import randrange
    from math import gcd
    k = randrange(1, r)
    while gcd(k, r) != 1:
        k = randrange(1, r)

    total_states = 2 ** n_precision
    y_approx = k * total_states // r
    measured_ratio = y_approx / total_states

    # Continued fraction extraction (this is the actual post-processing)
    quotients = continued_fraction(measured_ratio)
    convs = convergents(quotients)

    print(f"  a = {a}, N = {N}")
    print(f"  True period r = {r}")
    print(f"  Simulated measurement: y = {y_approx} / {total_states}")
    print(f"  Measured ratio: {measured_ratio:.6f}")
    print(f"  True ratio k/r: {k}/{r} = {k/r:.6f}")
    print(f"  Continued fraction: {quotients}")
    print(f"  Convergents (p/q): ", end="")
    for p, q in convs[:6]:
        print(f"{p}/{q}", end="  ")
    print()

    # Find the convergent whose denominator equals r
    for p, q in convs:
        if q == r:
            print(f"  → Recovered period: r = {q} ✓")
            return q

    # If exact match not found, return largest denominator ≤ N
    candidates = [q for p, q in convs if q <= N]
    if candidates:
        recovered = max(candidates)
        print(f"  → Best candidate: r = {recovered}")
        return recovered

    return None


# --- Demonstrate the quantum measurement → continued fraction pipeline ---
print("=" * 60)
print("QUANTUM PERIOD FINDING SIMULATION")
print("=" * 60)
print("\nThis simulates what happens AFTER the quantum measurement.")
print("The quantum computer outputs y; continued fractions extract r.\n")

for a, N in [(2, 21), (2, 15), (3, 35), (2, 143)]:
    print(f"\nFactoring N = {N} with a = {a}:")
    simulate_shor_period_finding(a, N, n_precision=12)

# --- Show QFT matrix for 3 qubits ---
print("\n" + "=" * 60)
print("QFT MATRIX (3 qubits = 8×8)")
print("=" * 60)
qft3 = quantum_fourier_transform(3)
print("\nRows/columns are computational basis states |000⟩ to |111⟩.")
print("Each entry is (1/√8) × exp(2πi·jk/8).\n")
for i in range(8):
    for j in range(8):
        val = qft3[i, j]
        mag = abs(val)
        phase = np.angle(val) / np.pi
        print(f"  {mag:.2f}·e^{phase:+.2f}π", end="")
    print()

# --- Complexity comparison table ---
print("\n" + "=" * 60)
print("COMPLEXITY: CLASSICAL vs QUANTUM")
print("=" * 60)
print(f"\n  {'Step':<35} {'Classical':<20} {'Quantum':<20}")
print(f"  {'-'*35} {'-'*20} {'-'*20}")
print(f"  {'Superposition (Hadamard gates)':<35} {'N/A':<20} {'O(n)':<20}")
print(f"  {'Modular exponentiation':<35} {'O(n³)':<20} {'O(n³)':<20}")
print(f"  {'Period finding (the hard part)':<35} {'O(r) ~ O(2^n)':<20} {'O(n²) via QFT':<20}")
print(f"  {'GCD / factor extraction':<35} {'O(n³)':<20} {'O(n³)':<20}")
print(f"  {'TOTAL':<35} {'O(2^n) sub-exp':<20} {'O(n³)':<20}")

# io.thecodeforge.quantum.factoring.ShorDiscreteLog

from math import gcd
from random import randrange


def classical_discrete_log(g: int, h: int, p: int) -> int:
    """Solve g^x ≡ h (mod p) by brute force — O(p) time.

    This is what Shor's quantum algorithm replaces with O(log(p)³) time.
    """
    x = 1
    current = g % p
    for candidate in range(1, p):
        if current == h:
            return candidate
        current = (current * g) % p
    return None


def baby_step_giant_step(g: int, h: int, p: int) -> int:
    """Classical BSGS algorithm — O(√p) time and space.

    Best known classical algorithm for generic DLP.
    Still exponential in bit-length: O(2^(n/2)) where n = log(p).
    Shor's quantum algorithm is O(n³) — exponential speedup over this.
    """
    import math
    m = int(math.isqrt(p - 1)) + 1

    # Baby step: build table g^j mod p for j = 0..m
    table = {}
    power = 1
    for j in range(m):
        table[power] = j
        power = (power * g) % p

    # Giant step: g^(-m) mod p
    g_inv_m = pow(g, -m, p)  # Python 3.8+

    # Check h * (g^(-m))^i for i = 0..m
    gamma = h
    for i in range(m):
        if gamma in table:
            return i * m + table[gamma]
        gamma = (gamma * g_inv_m) % p

    return None


# --- Demonstrate DLP solving ---
print("=" * 60)
print("DISCRETE LOGARITHM PROBLEM")
print("=" * 60)

# Small example
g, p = 2, 29
print(f"\nFind x such that {g}^x ≡ h (mod {p})")
print(f"\n  h  |  x (brute force)  |  x (BSGS)")
print(f"  ---|-------------------|----------")
for h in [3, 7, 12, 18, 25]:
    x_bf = classical_discrete_log(g, h, p)
    x_bs = baby_step_giant_step(g, h, p)
    verify = pow(g, x_bf, p) if x_bf else None
    print(f"  {h:>2}  |  {x_bf:>15}  |  {x_bs:>8}  (verify: {g}^{x_bf} mod {p} = {verify})")

# --- Show why quantum is exponentially faster ---
print("\n" + "=" * 60)
print("DLP COMPLEXITY: CLASSICAL vs QUANTUM")
print("=" * 60)
print(f"\n  {'Bit-length n':<15} {'BSGS O(√p)':<20} {'Shor O(n³)':<15} {'Speedup'}")
print(f"  {'-'*15} {'-'*20} {'-'*15} {'-'*15}")
for bits in [128, 256, 384, 521]:
    bsgs_ops = 2 ** (bits // 2)
    shor_ops = bits ** 3
    speedup = bsgs_ops / shor_ops
    print(f"  {bits:<15} 2^{bits//2:<14} {shor_ops:<15,} {speedup:.2e}x")

# --- What Shor breaks vs what survives ---
print("\n" + "=" * 60)
print("CRYPTOGRAPHIC IMPACT SUMMARY")
print("=" * 60)
algorithms = [
    ("RSA-2048", "Factoring", "Shor", "O(n³)", "BROKEN"),
    ("ECC P-256", "ECDLP", "Shor variant", "O(n³)", "BROKEN"),
    ("Diffie-Hellman", "DLP", "Shor", "O(n³)", "BROKEN"),
    ("Ed25519", "ECDLP", "Shor variant", "O(n³)", "BROKEN"),
    ("AES-128", "Key search", "Grover", "O(2^64)", "WEAKENED"),
    ("AES-256", "Key search", "Grover", "O(2^128)", "SAFE"),
    ("SHA-256", "Preimage", "Grover", "O(2^128)", "SAFE"),
    ("CRYSTALS-Kyber", "Lattice", "None known", "N/A", "PQ-SAFE"),
    ("CRYSTALS-Dilithium", "Lattice", "None known", "N/A", "PQ-SAFE"),
    ("SPHINCS+", "Hash-based", "None known", "N/A", "PQ-SAFE"),
]
print(f"\n  {'Algorithm':<20} {'Problem':<12} {'Q-Attack':<15} {'Q-Complexity':<14} {'Status'}")
print(f"  {'-'*20} {'-'*12} {'-'*15} {'-'*14} {'-'*10}")
for alg, prob, attack, complexity, status in algorithms:
    print(f"  {alg:<20} {prob:<12} {attack:<15} {complexity:<14} {status}")

# io.thecodeforge.quantum.factoring.QubitRequirements

import math


def estimate_logical_qubits(rsa_bits: int) -> int:
    """Estimate logical qubits needed to factor RSA-n using Shor's algorithm.

    Rough formula from Gidney & Ekerå (2021):
    logical_qubits ≈ 2n + 3 (for the period register)
    + n (for the exponentiation workspace)
    + some overhead for uncomputation

    More precise: ~2.5n for practical implementations.
    """
    # Conservative estimate based on Gidney-Ekerå 2021
    return int(2.5 * rsa_bits)


def estimate_physical_qubits(logical_qubits: int, phys_per_logical: int) -> int:
    """Convert logical qubits to physical qubits given error correction overhead."""
    return logical_qubits * phys_per_logical


def estimate_time_seconds(rsa_bits: int, gate_speed_ghz: float = 1.0) -> float:
    """Rough estimate of computation time for Shor's algorithm.

    Total gates ≈ O(n³). At 1 GHz gate speed, time ≈ n³ / 10⁹ seconds.
    This is very approximate — real implementations have significant overhead.
    """
    n = rsa_bits
    total_gates = n ** 3  # O(n³) — simplified
    gates_per_second = gate_speed_ghz * 1e9
    return total_gates / gates_per_second


# --- Qubit requirements for different RSA key sizes ---
print("=" * 70)
print("QUBIT REQUIREMENTS: SHOR'S ALGORITHM FOR RSA FACTORING")
print("=" * 70)
print(f"\n  {'RSA bits':<10} {'Logical':<10} {'Physical':<15} {'Physical':<15} {'Est. time'}")
print(f"  {'':10} {'qubits':<10} {'@1k/logical':<15} {'@10k/logical':<15} {'@1GHz'}")
print(f"  {'-'*10} {'-'*10} {'-'*15} {'-'*15} {'-'*15}")

for bits in [256, 512, 1024, 2048, 4096]:
    logical = estimate_logical_qubits(bits)
    phys_1k = estimate_physical_qubits(logical, 1000)
    phys_10k = estimate_physical_qubits(logical, 10000)
    time_sec = estimate_time_seconds(bits)

    if time_sec < 60:
        time_str = f"{time_sec:.1f}s"
    elif time_sec < 3600:
        time_str = f"{time_sec/60:.1f}m"
    elif time_sec < 86400:
        time_str = f"{time_sec/3600:.1f}h"
    else:
        time_str = f"{time_sec/86400:.1f}d"

    print(f"  {bits:<10} {logical:<10} {phys_1k:<15,} {phys_10k:<15,} {time_str}")

# --- Current hardware comparison ---
print("\n" + "=" * 70)
print("CURRENT QUANTUM HARDWARE vs REQUIREMENTS FOR RSA-2048")
print("=" * 70)

hardware = [
    ("IBM Condor (2023)", 1121, "Superconducting", 99.5),
    ("Google Willow (2024)", 105, "Superconducting", 99.7),
    ("IonQ Forte (2024)", 36, "Trapped Ion", 99.9),
    ("Quantinuum H2 (2024)", 56, "Trapped Ion", 99.9),
]

print(f"\n  {'System':<25} {'Physical':<12} {'Type':<18} {'Gate fidelity'}")
print(f"  {'-'*25} {'-'*12} {'-'*18} {'-'*13}")
for name, qubits, qtype, fidelity in hardware:
    print(f"  {name:<25} {qubits:<12} {qtype:<18} {fidelity}%")

print(f"\n  {'REQUIRED FOR RSA-2048':<25} {'4,000,000+':<12} {'Fault-tolerant':<18} {'99.99%+'}")
print(f"  {'GAP':<25} {'~4000x':<12} {'':18} {'':13}")

# --- Post-quantum migration timeline ---
print("\n" + "=" * 70)
print("POST-QUANTUM MIGRATION TIMELINE")
print("=" * 70)
print("\n  Year    Milestone")
print("  ----    ---------")
milestones = [
    ("1994",  "Shor publishes factoring algorithm"),
    ("2001",  "IBM factors 15 on 7-qubit NMR quantum computer"),
    ("2016",  "NIST launches Post-Quantum Cryptography standardization"),
    ("2019",  "Google claims quantum supremacy (53 qubits, random circuit sampling)"),
    ("2022",  "NIST selects CRYSTALS-Kyber, CRYSTALS-Dilithium, SPHINCS+ as standards"),
    ("2024",  "NIST publishes FIPS 203 (Kyber), 204 (Dilithium), 205 (SPHINCS+)"),
    ("2024",  "Google demonstrates below-threshold error correction (Willow)"),
    ("2025",  "Signal, Chrome, Cloudflare begin PQC deployment"),
    ("2026",  "YOU ARE HERE — begin migration planning if you haven't already"),
    ("2030",  "Conservative estimate: first CRQC (Cryptographically Relevant QC)"),
    ("2035",  "NSA deadline for national security systems migration"),
    ("2040",  "Widely accepted outer bound for CRQC arrival"),
]
for year, desc in milestones:
    marker = " ←" if "YOU ARE HERE" in desc else ""
    print(f"  {year}    {desc}{marker}")

# io.thecodeforge.quantum.migration.PostQuantumAudit

import json
from datetime import datetime


class CryptoInventoryItem:
    """Represents a single cryptographic dependency in your infrastructure."""

    def __init__(self, system: str, algorithm: str, key_size: int,
                 purpose: str, data_lifetime_years: int,
                 pq_vulnerable: bool, migration_priority: str):
        self.system = system
        self.algorithm = algorithm
        self.key_size = key_size
        self.purpose = purpose
        self.data_lifetime_years = data_lifetime_years
        self.pq_vulnerable = pq_vulnerable
        self.migration_priority = migration_priority

    def to_dict(self):
        return vars(self)


def classify_risk(algorithm: str, key_size: int, data_lifetime: int) -> str:
    """Classify migration priority based on algorithm and data lifetime.

    Priority levels:
    - CRITICAL: Asymmetric crypto + data lifetime > 10 years
    - HIGH: Asymmetric crypto + data lifetime 5-10 years
    - MEDIUM: Asymmetric crypto + data lifetime < 5 years
    - LOW: Symmetric crypto with adequate key size (AES-256)
    - INFO: Already post-quantum safe
    """
    vulnerable_algs = ['RSA', 'ECC', 'ECDSA', 'ECDH', 'Ed25519', 'DSA',
                       'Diffie-Hellman', 'X25519', 'P-256', 'P-384']
    weakened_algs = ['AES-128', '3DES']
    safe_algs = ['AES-256', 'ChaCha20', 'SHA-256', 'SHA-3',
                 'CRYSTALS-Kyber', 'CRYSTALS-Dilithium', 'SPHINCS+']

    alg_upper = algorithm.upper()

    if any(v in alg_upper for v in ['KYBER', 'DILITHIUM', 'SPHINCS', 'ML-KEM', 'ML-DSA', 'SLH-DSA']):
        return 'INFO (already PQ-safe)'

    if any(v in alg_upper for v in vulnerable_algs):
        if data_lifetime >= 10:
            return 'CRITICAL — harvest-now-decrypt-later risk'
        elif data_lifetime >= 5:
            return 'HIGH — migrate within 2 years'
        else:
            return 'MEDIUM — migrate within 5 years'

    if any(w in alg_upper for w in weakened_algs):
        return 'MEDIUM — use AES-256 instead'

    if any(s in alg_upper for s in ['AES-256', 'CHACHA', 'SHA-256', 'SHA-3']):
        return 'LOW — symmetric, adequate key size'

    return 'UNKNOWN — manual review needed'


def generate_migration_report(inventory: list) -> dict:
    """Generate a summary migration report from a crypto inventory."""
    report = {
        'generated': datetime.now().isoformat(),
        'total_items': len(inventory),
        'by_priority': {},
        'critical_items': [],
        'recommendations': []
    }

    for item in inventory:
        priority = item.migration_priority
        report['by_priority'][priority] = report['by_priority'].get(priority, 0) + 1
        if 'CRITICAL' in priority:
            report['critical_items'].append(item.system)

    if report['critical_items']:
        report['recommendations'].append(
            'IMMEDIATE: Deploy hybrid key exchange (ECDH + Kyber) for systems '
            'handling data with 10+ year confidentiality requirements.'
        )
    report['recommendations'].extend([
        'Enable CRYSTALS-Kyber (ML-KEM) in TLS via OpenSSL 3.x.',
        'Test PQC support at pq.cloudflareresearch.com.',
        'Begin testing CRYSTALS-Dilithium for code/document signing.',
        'Inventory all SSH keys and plan migration to hybrid SSH.',
        'Update key management systems to handle larger PQC key sizes.',
    ])

    return report


# --- Example: build a crypto inventory for a typical organisation ---
print("=" * 70)
print("POST-QUANTUM CRYPTOGRAPHIC AUDIT")
print("=" * 70)

inventory = [
    CryptoInventoryItem('TLS (web server)', 'RSA-2048', 2048, 'Key exchange', 0, True,
                        classify_risk('RSA', 2048, 0)),
    CryptoInventoryItem('TLS (API gateway)', 'ECDH P-256', 256, 'Key exchange', 1, True,
                        classify_risk('ECDH', 256, 1)),
    CryptoInventoryItem('SSH (production)', 'Ed25519', 256, 'Authentication', 0, True,
                        classify_risk('Ed25519', 256, 0)),
    CryptoInventoryItem('Code signing cert', 'RSA-4096', 4096, 'Signature', 3, True,
                        classify_risk('RSA', 4096, 3)),
    CryptoInventoryItem('Database encryption', 'AES-256-GCM', 256, 'Symmetric encryption', 15, False,
                        classify_risk('AES-256', 256, 15)),
    CryptoInventoryItem('JWT tokens', 'RS256', 2048, 'Signature', 0, True,
                        classify_risk('RSA', 2048, 0)),
    CryptoInventoryItem('VPN (WireGuard)', 'X25519', 256, 'Key exchange', 0, True,
                        classify_risk('X25519', 256, 0)),
    CryptoInventoryItem('Medical records archive', 'RSA-2048', 2048, 'Key wrapping', 30, True,
                        classify_risk('RSA', 2048, 30)),
    CryptoInventoryItem('Internal PKI root CA', 'ECDSA P-384', 384, 'Certificate signing', 20, True,
                        classify_risk('ECDSA', 384, 20)),
    CryptoInventoryItem('Backup encryption', 'ChaCha20-Poly1305', 256, 'Symmetric encryption', 10, False,
                        classify_risk('ChaCha20', 256, 10)),
]

print(f"\n  {'System':<28} {'Algorithm':<20} {'Lifetime':<10} {'Priority'}")
print(f"  {'-'*28} {'-'*20} {'-'*10} {'-'*40}")
for item in inventory:
    print(f"  {item.system:<28} {item.algorithm:<20} {item.data_lifetime_years:<10} {item.migration_priority}")

report = generate_migration_report(inventory)
print(f"\n{'='*70}")
print("MIGRATION REPORT SUMMARY")
print(f"{'='*70}")
print(f"\n  Total items audited: {report['total_items']}")
print(f"  By priority:")
for priority, count in report['by_priority'].items():
    print(f"    {priority}: {count}")
print(f"\n  Critical systems (harvest-now-decrypt-later risk):")
for system in report['critical_items']:
    print(f"    - {system}")
print(f"\n  Recommendations:")
for i, rec in enumerate(report['recommendations'], 1):
    print(f"    {i}. {rec}")