┌─────────────────────────────────────────────────────────────────────────────┐
│                    QUANTUM THREAT TO BLOCKCHAIN                             │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    DIGITAL SIGNATURES                                │   │
│  │  • ECDSA (Elliptic Curve Digital Signature Algorithm)               │   │
│  │  • Ed25519 (Edwards-curve Digital Signature Algorithm)              │   │
│  │  • RSA Signatures                                                  │   │
│  │  • Impact: Private keys can be derived from public keys             │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    PUBLIC KEY CRYPTOGRAPHY                          │   │
│  │  • ECC (Elliptic Curve Cryptography)                               │   │
│  │  • RSA (Rivest-Shamir-Adleman)                                     │   │
│  │  • Impact: Secure communication can be decrypted                   │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    HASH FUNCTIONS                                   │   │
│  │  • SHA-256 (Bitcoin, many blockchains)                             │   │
│  │  • Keccak-256 (Ethereum)                                          │   │
│  │  • Impact: Grover's algorithm reduces security from 2^256 to 2^128 │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    KEY EXCHANGE                                     │   │
│  │  • Diffie-Hellman                                                  │   │
│  │  • Impact: Secure key agreement can be broken                       │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

# ===================================================================
# MODULE 8, LESSON 5: QUANTUM COMPUTING AND POST-QUANTUM CRYPTOGRAPHY
# ===================================================================

import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
from typing import Dict, List
import warnings
warnings.filterwarnings('ignore')

print("="*70)
print("QUANTUM COMPUTING AND POST-QUANTUM CRYPTOGRAPHY")
print("="*70)

# ----------------------------------------------------------------
# PART A: QUANTUM THREAT ASSESSMENT
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART A: Quantum Threat Assessment")
print("-"*60)

class QuantumThreatAssessment:
    """
    Assesses quantum threat to blockchain components.
    """
    def __init__(self):
        self.components = {
            'Digital Signatures': {
                'vulnerability': 'High',
                'affected_algorithms': ['ECDSA', 'Ed25519', 'RSA', 'DSA'],
                'time_to_break': '~4,000 qubits',
                'urgency': 'High'
            },
            'Hash Functions': {
                'vulnerability': 'Medium',
                'affected_algorithms': ['SHA-256', 'SHA-512', 'Keccak-256'],
                'time_to_break': '~Grover (2^128)',
                'urgency': 'Medium'
            },
            'Key Exchange': {
                'vulnerability': 'High',
                'affected_algorithms': ['Diffie-Hellman', 'ECDH'],
                'time_to_break': '~4,000 qubits',
                'urgency': 'High'
            },
            'Symmetric Encryption': {
                'vulnerability': 'Low',
                'affected_algorithms': ['AES-256', 'ChaCha20'],
                'time_to_break': '~2^128 operations',
                'urgency': 'Low'
            }
        }
    
    def get_assessment(self) -> pd.DataFrame:
        data = []
        for component, details in self.components.items():
            data.append({
                'Component': component,
                'Vulnerability': details['vulnerability'],
                'Algorithms': ', '.join(details['affected_algorithms']),
                'Time to Break': details['time_to_break'],
                'Urgency': details['urgency']
            })
        return pd.DataFrame(data)

assessment = QuantumThreatAssessment()
print("Quantum Threat Assessment:")
print(assessment.get_assessment().to_string(index=False))

# ----------------------------------------------------------------
# PART B: POST-QUANTUM ALGORITHM COMPARISON
# -----------------------------------------------------------------

print("\n" + "-"*60)
print("PART B: Post-Quantum Algorithm Comparison")
print("-"*60)

pq_data = {
    'Algorithm': ['CRYSTALS-Dilithium', 'FALCON', 'SPHINCS+', 'CRYSTALS-Kyber', 'Classic McEliece'],
    'Type': ['Lattice (Sig)', 'Lattice (Sig)', 'Hash-based (Sig)', 'Lattice (KEM)', 'Code-based (KEM)'],
    'Public Key (bytes)': [1312, 1792, 32, 1184, 261000],
    'Signature/Cipher (bytes)': [2420, 666, 7856, 1088, 128],
    'Speed (relative)': ['Fast', 'Very Fast', 'Slow', 'Fast', 'Slow'],
    'Security Level': ['128+ bits', '128+ bits', '128+ bits', '128+ bits', '128+ bits']
}

pq_df = pd.DataFrame(pq_data)
print(pq_df.to_string(index=False))

# ----------------------------------------------------------------
# PART C: KEY SIZE COMPARISON
# -----------------------------------------------------------------

print("\n" + "-"*60)
print("PART C: Key and Signature Size Comparison")
print("-"*60)

size_data = {
    'Algorithm': ['ECDSA-256', 'Ed25519', 'Dilithium-2', 'Falcon-512', 'SPHINCS+'],
    'Public Key (bytes)': [33, 32, 1312, 1792, 32],
    'Private Key (bytes)': [32, 32, 2528, 1281, 64],
    'Signature (bytes)': [64, 64, 2420, 666, 7856],
    'Total (bytes)': [129, 128, 6260, 3739, 7952]
}

size_df = pd.DataFrame(size_data)
print(size_df.to_string(index=False))

# Visualise
fig, ax = plt.subplots(figsize=(12, 5))
x = np.arange(len(size_data['Algorithm']))
width = 0.25

ax.bar(x - width, size_data['Public Key (bytes)'], width, label='Public Key', color='blue', alpha=0.7)
ax.bar(x, size_data['Private Key (bytes)'], width, label='Private Key', color='green', alpha=0.7)
ax.bar(x + width, size_data['Signature (bytes)'], width, label='Signature', color='orange', alpha=0.7)

ax.set_xlabel('Algorithm')
ax.set_ylabel('Size (bytes)')
ax.set_title('Cryptographic Key and Signature Sizes')
ax.set_xticks(x)
ax.set_xticklabels(size_data['Algorithm'], rotation=45, ha='right')
ax.legend()
ax.grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig('pq_key_sizes.png', dpi=300, bbox_inches='tight')
plt.show()
print("Post-quantum key size chart saved as 'pq_key_sizes.png'")

# ----------------------------------------------------------------
# PART D: QUANTUM THREAT TIMELINE
# -----------------------------------------------------------------

print("\n" + "-"*60)
print("PART D: Quantum Threat Timeline")
print("-"*60)

timeline_data = {
    'Year': ['2024', '2026', '2028', '2030', '2035', '2040'],
    'Qubit Capability': ['<100', '100-500', '500-1000', '1000-2000', '2000-4000', '4000+'],
    'Threat Level': ['Low', 'Low-Medium', 'Medium', 'Medium-High', 'High', 'Critical'],
    'Key Milestone': [
        'NIST standards finalised',
        'Early implementations',
        'Prototype quantum attacks',
        'First RSA/ECC breaks?',
        'Significant breaks likely',
        'All current crypto broken'
    ]
}

timeline_df = pd.DataFrame(timeline_data)
print(timeline_df.to_string(index=False))

# ----------------------------------------------------------------
# PART E: SUMMARY AND RECOMMENDATIONS
# -----------------------------------------------------------------

print("\n" + "="*70)
print("PART E: Summary and Recommendations")
print("="*70)

print("""
Quantum Computing and Post-Quantum Cryptography – Key Takeaways:

1. Quantum computing poses a significant threat to current blockchain cryptography.
2. Vulnerable: ECDSA signatures, ECC public key cryptography, RSA.
3. Shor's algorithm breaks discrete log and factoring-based crypto.
4. Grover's algorithm reduces hash function security (SHA-256 -> 2^128).
5. Post-quantum solutions: NIST standards (Dilithium, Kyber, Falcon, SPHINCS+).
6. Hybrid approach: use both classical and post-quantum crypto during transition.
7. Migration timeline: 2025-2035 for full transition.

Recommendations:
  - Assess quantum risk for your systems.
  - Adopt cryptographic agility (ability to switch algorithms).
  - Plan for post-quantum migration early.
  - Use hybrid signatures during transition.
  - Monitor NIST standards and industry developments.
  - Consider "harvest now, decrypt later" threats.
""")