Update app.py

app.py

@@ -6,8 +6,12 @@ from qiskit_aer import Aer
 from cryptography.fernet import Fernet
 import random
 import base64
+import matplotlib.pyplot as plt
+import qrcode
+from io import BytesIO
+from PIL import Image
 
-# 1. Quantum Key Distribution (BB84 Protocol)
+# 1. Generate QKD Key (respects target usable length)
 def generate_qkd_key(length=128):
     shared_key = ""
     while len(shared_key) < length:
@@ -18,49 +22,56 @@ def generate_qkd_key(length=128):
             shared_key += str(alice_bit)
     return shared_key
 
-# 2. Convert QKD binary key to 32-byte Fernet-compatible key
+# 2. Convert QKD key to Fernet key (needs 256 bits)
 def bb84_to_fernet_key(qkey_binary_str):
     if len(qkey_binary_str) < 256:
         raise ValueError("QKD key must be at least 256 bits to generate Fernet key.")
-
     binary_256 = qkey_binary_str[:256]
     int_val = int(binary_256, 2)
-    byte_val = int_val.to_bytes(32, 'big')  # 256 bits = 32 bytes
+    byte_val = int_val.to_bytes(32, 'big')
     fernet_key = base64.urlsafe_b64encode(byte_val)
-
     if len(fernet_key) != 44:
-        raise ValueError("Generated Fernet key is not 32 url-safe base64-encoded bytes")
-
+        raise ValueError("Generated Fernet key is invalid.")
     return fernet_key
 
-# 3. Encrypt message using QKD key
+# 3. Encrypt using Fernet key
 def quantum_encrypt(message, qkd_key):
     if not qkd_key or len(qkd_key) < 72:
-        return "❌ QKD key too short. Minimum usable bits: 72", ""
-
+        return "❌ QKD key too short. Minimum 72 bits required.", "", None
     try:
         fernet_key = bb84_to_fernet_key(qkd_key)
         f = Fernet(fernet_key)
         encrypted_message = f.encrypt(message.encode())
-        return encrypted_message.decode(), fernet_key.decode()
+        qr_img = generate_qr_image(fernet_key.decode())
+        return encrypted_message.decode(), fernet_key.decode(), qr_img
     except Exception as e:
-        return f"Encryption error: {str(e)}", ""
+        return f"Encryption error: {str(e)}", "", None
 
-# 4. Decrypt message using QKD key
+# 4. Decrypt
 def quantum_decrypt(encrypted_message, key):
     try:
         f = Fernet(key.encode())
-        decrypted_message = f.decrypt(encrypted_message.encode())
-        return decrypted_message.decode()
+        return f.decrypt(encrypted_message.encode()).decode()
     except Exception as e:
         return f"Decryption error: {str(e)}"
 
-# 5. Quantum Intrusion Detection using PennyLane
+# 5. QR Code Generator
+def generate_qr_image(data):
+    qr = qrcode.QRCode(box_size=6, border=2)
+    qr.add_data(data)
+    qr.make(fit=True)
+    img = qr.make_image(fill_color="black", back_color="white")
+    buffer = BytesIO()
+    img.save(buffer, format="PNG")
+    buffer.seek(0)
+    return Image.open(buffer)
+
+# 6. Intrusion Detection
 def quantum_intrusion_detection(data_stream):
     dev = qml.device("default.qubit", wires=2)
 
     @qml.qnode(dev)
-    def quantum_classifier(x):
+    def classifier(x):
         qml.RY(x[0], wires=0)
         qml.RY(x[1], wires=1)
         qml.CNOT(wires=[0, 1])
@@ -68,12 +79,38 @@ def quantum_intrusion_detection(data_stream):
 
     try:
         x = [float(i) for i in data_stream.split(',')]
-        anomaly_score = abs(quantum_classifier(x))
-        return "🚨 Intrusion Detected" if anomaly_score > 0.7 else "✅ Normal Activity"
+        score = abs(classifier(x))
+        return "🚨 Intrusion Detected" if score > 0.7 else "✅ Normal Activity"
     except:
-        return "❌ Invalid input. Please enter two comma-separated numbers like 0.3,0.7"
-
-# 6. Quantum Random Number Generator
+        return "❌ Invalid input. Format: 0.3,0.7"
+
+# 7. Quantum Noise Simulation
+def simulate_noise(bits=100):
+    original = np.random.choice([0, 1], size=bits)
+    noisy = [bit if random.random() > 0.1 else 1 - bit for bit in original]
+    plt.figure(figsize=(10, 1))
+    plt.plot(original, 'bo', label="Original")
+    plt.plot(noisy, 'rx', label="With Noise")
+    plt.yticks([0, 1])
+    plt.legend()
+    plt.title("Quantum Noise Simulation (Eavesdropper Effect)")
+    buf = BytesIO()
+    plt.savefig(buf, format='png')
+    buf.seek(0)
+    return Image.open(buf)
+
+# 8. Randomness Visualizer
+def visualize_qkd_bits(qkd_key):
+    ones = qkd_key.count('1')
+    zeros = qkd_key.count('0')
+    plt.bar(['0', '1'], [zeros, ones], color=['blue', 'green'])
+    plt.title("Randomness Distribution in QKD Key")
+    buf = BytesIO()
+    plt.savefig(buf, format='png')
+    buf.seek(0)
+    return Image.open(buf)
+
+# 9. Quantum Random Number Generator
 def quantum_random_number():
     backend = Aer.get_backend('aer_simulator')
     circuit = QuantumCircuit(1, 1)
@@ -84,17 +121,15 @@ def quantum_random_number():
     counts = result.get_counts()
     return list(counts.keys())[0]
 
-# 7. Gradio Interface
+# 10. Gradio Interface
 def create_interface():
     with gr.Blocks(title="Quantum Cybersecurity Suite") as demo:
         gr.Markdown("# 🛡️ Quantum Cybersecurity Suite")
-        gr.Markdown("Simulate secure quantum protocols for key distribution, encryption, intrusion detection, and randomness.")
-
         qkd_key_state = gr.State("")
 
-        # Tab 1: QKD Key Generation
+        # Tab 1: QKD Key
         with gr.Tab("1️⃣ Quantum Key Distribution"):
-            key_length = gr.Slider(minimum=72, maximum=512, step=8, value=128, label="Select QKD Key Length (≥ 72 bits)")
+            key_length = gr.Slider(72, 512, step=8, value=128, label="Select QKD Key Length (≥ 72 bits)")
             qkd_btn = gr.Button("Generate Quantum Key")
             qkd_output = gr.Textbox(label="Generated QKD Key")
 
@@ -102,45 +137,59 @@ def create_interface():
                 key = generate_qkd_key(length)
                 return key, key
 
-            qkd_btn.click(fn=generate_and_store_key,
+            qkd_btn.click(generate_and_store_key,
                           inputs=[key_length],
                           outputs=[qkd_output, qkd_key_state])
 
-        # Tab 2: Quantum Encryption
+        # Tab 2: Encryption
         with gr.Tab("2️⃣ Quantum Encryption"):
             msg_input = gr.Textbox(label="Message to Encrypt")
             encrypt_btn = gr.Button("Encrypt with QKD Key")
             encrypted_output = gr.Textbox(label="Encrypted Message")
             key_used_output = gr.Textbox(label="Fernet Key Used")
+            qr_code_output = gr.Image(label="QR Code of Key")
 
-            encrypt_btn.click(fn=quantum_encrypt,
+            encrypt_btn.click(quantum_encrypt,
                               inputs=[msg_input, qkd_key_state],
-                              outputs=[encrypted_output, key_used_output])
+                              outputs=[encrypted_output, key_used_output, qr_code_output])
 
-        # Tab 3: Quantum Decryption
+        # Tab 3: Decryption
         with gr.Tab("3️⃣ Quantum Decryption"):
             encrypted_input = gr.Textbox(label="Encrypted Message")
             key_input = gr.Textbox(label="Fernet Key")
             decrypt_btn = gr.Button("Decrypt")
             decrypted_output = gr.Textbox(label="Decrypted Message")
 
-            decrypt_btn.click(fn=quantum_decrypt,
+            decrypt_btn.click(quantum_decrypt,
                               inputs=[encrypted_input, key_input],
                               outputs=[decrypted_output])
 
-        # Tab 4: Quantum Intrusion Detection
+        # Tab 4: Intrusion Detection
         with gr.Tab("4️⃣ Quantum Intrusion Detection"):
             data_input = gr.Textbox(label="Data Stream (e.g. 0.3,0.7)")
             detect_btn = gr.Button("Analyze")
             detection_output = gr.Textbox(label="Detection Result")
-
             detect_btn.click(quantum_intrusion_detection,
                              inputs=[data_input],
                              outputs=[detection_output])
 
+        # Tab 5: Quantum Noise Simulation
+        with gr.Tab("5️⃣ Eavesdropper Noise Simulation"):
+            noise_btn = gr.Button("Simulate Noise")
+            noise_output = gr.Image(label="Quantum Channel with Noise")
+            noise_btn.click(simulate_noise, outputs=noise_output)
+
+        # Tab 6: Randomness Distribution
+        with gr.Tab("6️⃣ QKD Key Randomness Visualizer"):
+            viz_btn = gr.Button("Visualize Randomness")
+            viz_output = gr.Image(label="Randomness Bar Graph")
+            viz_btn.click(fn=visualize_qkd_bits,
+                          inputs=[qkd_key_state],
+                          outputs=[viz_output])
+
     return demo
 
-# 8. Launch App
+# 11. Launch
 if __name__ == "__main__":
     demo = create_interface()
     demo.launch(share=True)