Create app.py

app.py

@@ -0,0 +1,128 @@
+import numpy as np
+import gradio as gr
+import pennylane as qml
+from qiskit import QuantumCircuit
+from qiskit_aer import Aer
+from qiskit.primitives import Sampler
+from cryptography.fernet import Fernet
+import random
+import base64
+
+# 1. Quantum Key Distribution (BB84 Protocol)
+def generate_qkd_key(length=8):
+    alice_bits = [random.randint(0, 1) for _ in range(length)]
+    alice_bases = [random.randint(0, 1) for _ in range(length)]
+    bob_bases = [random.randint(0, 1) for _ in range(length)]
+
+    shared_key = ""
+    for i in range(length):
+        if alice_bases[i] == bob_bases[i]:
+            shared_key += str(alice_bits[i])
+    return shared_key
+
+# 2. Convert QKD binary key to Fernet key
+def bb84_to_fernet_key(qkey_binary_str):
+    padded = qkey_binary_str.ljust(128, '0')  # pad to 128 bits
+    int_val = int(padded, 2)
+    byte_val = int_val.to_bytes(16, 'big')  # 128 bits = 16 bytes
+    fernet_key = base64.urlsafe_b64encode(byte_val)
+    return fernet_key
+
+# 3. Encryption using QKD key
+def quantum_encrypt(message, qkd_key):
+    if not qkd_key or len(qkd_key) < 8:
+        return "QKD key not generated or too short", ""
+    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()
+    except Exception as e:
+        return f"Encryption error: {str(e)}", ""
+
+# 4. Decryption using QKD key
+def quantum_decrypt(encrypted_message, key):
+    try:
+        f = Fernet(key.encode())
+        decrypted_message = f.decrypt(encrypted_message.encode())
+        return decrypted_message.decode()
+    except Exception as e:
+        return f"Decryption error: {str(e)}"
+
+# 5. Quantum Intrusion Detection
+def quantum_intrusion_detection(data_stream):
+    dev = qml.device("default.qubit", wires=2)
+
+    @qml.qnode(dev)
+    def quantum_classifier(x):
+        qml.RY(x[0], wires=0)
+        qml.RY(x[1], wires=1)
+        qml.CNOT(wires=[0, 1])
+        return qml.expval(qml.PauliZ(0))
+
+    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"
+    except:
+        return "Invalid input. Please enter two comma-separated numbers like 0.3,0.7"
+
+# 6. Gradio Interface
+def create_interface():
+    with gr.Blocks(title="Quantum Cybersecurity Suite") as demo:
+        gr.Markdown("# 🔐 Quantum Computing for Cyber Defense")
+
+        # State to store QKD key across tabs
+        qkd_key_state = gr.State("")
+
+        # Tab 1: QKD
+        with gr.Tab("1️⃣ Quantum Key Distribution"):
+            key_length = gr.Slider(minimum=8, maximum=32, step=8, label="Select Key Length")
+            qkd_btn = gr.Button("Generate Quantum Key")
+            qkd_output = gr.Textbox(label="Generated QKD Key")
+
+            def generate_and_store_key(length):
+                key = generate_qkd_key(length)
+                return key, key  # update both output and state
+
+            qkd_btn.click(fn=generate_and_store_key, inputs=[key_length],
+                          outputs=[qkd_output, qkd_key_state])
+
+        # Tab 2: Quantum 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")
+
+            encrypt_btn.click(fn=quantum_encrypt,
+                              inputs=[msg_input, qkd_key_state],
+                              outputs=[encrypted_output, key_used_output])
+
+        # Tab 3: Quantum 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,
+                              inputs=[encrypted_input, key_input],
+                              outputs=[decrypted_output])
+
+        # Tab 4: Quantum Intrusion Detection
+        with gr.Tab("4️⃣ Quantum Intrusion Detection"):
+            data_input = gr.Textbox(label="Data Stream (comma-separated, 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])
+
+    return demo
+
+# 7. Launch
+if __name__ == "__main__":
+    demo = create_interface()
+    demo.launch(share=True)