fixed app

app.py

@@ -85,7 +85,7 @@ def keygen():
     return [list(evaluation_key)[:ENCRYPTED_DATA_BROWSER_LIMIT], user_id]
 
 
-def encode_quantize_encrypt(test_file, eval_key):
+def encode_quantize(test_file, eval_key):
     ugly = ['Machine', 'SizeOfOptionalHeader', 'Characteristics',
        'MajorLinkerVersion', 'MinorLinkerVersion', 'SizeOfCode',
        'SizeOfInitializedData', 'SizeOfUninitializedData',
@@ -119,6 +119,10 @@ def encode_quantize_encrypt(test_file, eval_key):
 
     encodings = np.array(encodings).reshape(1, -1)
 
+    return encodings
+
+def encrypt_encoded_quantize(encodings):
+    
     quantized_encodings = fhe_api.model.quantize_input(encodings).astype(numpy.uint8)
     encrypted_quantized_encoding = fhe_api.quantize_encrypt_serialize(encodings)
 
@@ -132,7 +136,6 @@ def encode_quantize_encrypt(test_file, eval_key):
     encrypted_quantized_encoding_shorten_hex = "".join(f"{i:02x}" for i in encrypted_quantized_encoding_shorten)
     return (encodings[0],quantized_encodings[0],encrypted_quantized_encoding_shorten_hex)
 
-
 def run_fhe(user_id):
     encoded_data_path = Path(f"tmp/tmp_encrypted_quantized_encoding_{user_id}.npy")
     encrypted_quantized_encoding = numpy.load(encoded_data_path)
@@ -182,15 +185,6 @@ def decrypt_prediction(user_id):
     return predictions
 
 
-def process_pipeline(test_file):
-
-    eval_key = keygen()
-    encodings = encode_quantize_encrypt(test_file, eval_key)
-    encrypted_quantized_encoding = run_fhe(eval_key[1])
-    encrypted_prediction = decrypt_prediction(eval_key[1])
-
-    return eval_key, encodings, encrypted_quantized_encoding, encrypted_prediction
-
 if __name__ == "__main__":
     """
     with gr.Blocks() as demo:
@@ -216,34 +210,240 @@ if __name__ == "__main__":
 
 
     """
-    with gr.Blocks() as demo:
-        print("Starting the FHE Model")
 
-        
-        inputs = (
-            [
-                gr.File(label="Test File"),
-            ],
+    print("🚀 Starting the ClairVault demo...")
+    with gr.Blocks(css=".gradio-container { font-size: 20px; }") as demo:
+
+        gr.Markdown(
+            """
+            <p align="center">
+                <img width=200 src="/api/placeholder/200/200" alt="ClairVault Logo">
+            </p>
+            <h2 align="center">🔒 ClairVault: Privacy-Preserving Cloud-Based Malware Scanning</h2>
+            <p align="center">
+                <a href="#">GitHub</a>
+                —
+                <a href="#">Documentation</a>
+                —
+                <a href="#">Community</a>
+                —
+                <a href="#">@ClairVault</a>
+            </p>
+            <p align="center">
+            <img src="/api/placeholder/600/300" alt="ClairVault Concept" width="60%" height="60%">
+            </p>
+            """
         )
-        outputs = (
-            [
-                gr.Textbox(label="Evaluation Key"),
-                gr.Textbox(label="Encodings"),
-                gr.Textbox(label="Encrypted Quantized Encoding"),
-                gr.Textbox(label="Encrypted Prediction"),
-            ],
+
+        gr.Markdown("## 📋 Executive Summary")
+        gr.Markdown(
+        """
+        ### ClairVault is a **malware scanning service**, cloud-based and machine-learning enabled, that leverages fully homomorphic encryption (FHE) to securely scan files without seeing your data.
+        """
         )
-        title = ("FHE Model",)
-        description = ("This is a FHE Model",)
 
-        #gr.Interface(fn, inputs, outputs, title=title, description=description).launch()
+        gr.Markdown("## 🚨 The Problem")
+        gr.Markdown(
+        """
+        1. Privacy: do you really trust the Russian-based Kaspersky and that there is no back-door built in McAfee by Oncle Sam?
+            - Require access to plaintext data, posing privacy and security risks
+            - Often closed-source, lacking transparency
+        2. Protection: 
+            - The malware scanner itself might be compromised
+            - Require frequent local updates
+            - Mostly rule-based → need machine learning - but mostly on cloud
+        3. Resources
+            - Consume local resources (Windows Defender only runs ML based models on the cloud)
+        """
+        )
 
-        run_bottn = gr.Button("Run")
+        gr.Markdown("## 💡 Our Solution: ClairVault")
+        gr.Markdown(
+        """
+        Key features include:
+        - Local extraction of features and encryption of user data (files, logs)
+        - Transmission of encrypted data to secure, open-source cloud servers
+        - Malware classification performed on encrypted data
+        - Return of encrypted classification results
+        """
+        )
 
-        run_bottn.click(
-            fn=(process_pipeline),
-            inputs=inputs, outputs=outputs
+        gr.Markdown("### 🛠️ Technical Implementation")
+        gr.Markdown(
+        """
+        - **Encryption Method**: Fully Homomorphic Encryption using the TFHE (Fast Fully Homomorphic Encryption over the Torus) library
+        - **Machine Learning Model**: Linear classifier optimized for FHE computations using ConcreteML
+        - **Performance Metrics**:
+            - Encrypted file scanning: ~30 seconds per MB
+            - Plaintext file scanning: ~0.5 seconds per MB
+            - Estimated time to scan 1GB: ~8.5 hours (encrypted) vs. ~8.5 minutes (plaintext)
+        *Note: These are preliminary figures based on our proof-of-concept. We aim to significantly improve performance in future iterations.*
+        """
         )
 
 
-    demo.launch() #share=True)
+
+        gr.Markdown("# 🗝️ Step 1: Generate the keys")
+
+        b_gen_key = gr.Button("🔑 Generate the keys and send public part to server")
+
+        evaluation_key = gr.Textbox(
+            label="Evaluation key (truncated):",
+            max_lines=4,
+            interactive=False,
+        )
+
+        gr.Markdown("# 📤 Step 2: Upload a file for scanning")
+        gr.Markdown("## Client side")
+        gr.Markdown(
+            "Upload a file you want to scan for malware. ClairVault will encrypt it locally before sending it to the cloud."
+        )
+        file_input = gr.File(label="Upload a file:")
+
+        gr.Markdown("# 📥 Step 3: Extract executable file features")
+
+        b_extract = gr.Button("📥 Extract features and save")
+
+        extracted_vector = gr.Textbox(
+            label="Extracted vector:",
+            max_lines=4,
+            interactive=False,
+        )
+
+        gr.Markdown("# 🔒 Step 4: Encrypt the file with the private key")
+        b_encrypt_file = gr.Button(
+            "🔐 Encrypt the file and send to server"
+        )
+
+        encrypted_file = gr.Textbox(
+            label="Encrypted file content (truncated):",
+            max_lines=4,
+            interactive=False,
+        )
+
+        gr.Markdown("# 🖥️ Step 5: Run the FHE-based malware scan")
+        gr.Markdown("## Server side")
+        gr.Markdown(
+            "The encrypted file is received by the server. Using the evaluation key and FHE, the server can perform the malware scan directly on the encrypted data. Once the scan is finished, the server returns the encrypted result to the client."
+        )
+
+        b_run_fhe_scan = gr.Button("🛡️ Run FHE-based malware scan")
+        encrypted_scan_result = gr.Textbox(
+            label="Encrypted scan result (truncated):",
+            max_lines=4,
+            interactive=False,
+        )
+
+        gr.Markdown("# 🔓 Step 6: Decrypt the scan result")
+        gr.Markdown("## Client side")
+        gr.Markdown(
+            "The encrypted scan result is sent back to the client, who can finally decrypt it with their private key. Only the client is aware of the original file content and the scan result."
+        )
+        b_decrypt_result = gr.Button("🔍 Decrypt scan result")
+
+        scan_result = gr.Textbox(label="Scan Result:")
+
+        eval_key = keygen()
+        encodings = encode_quantize(file_input, eval_key)
+        encrypted_quantized_encoding = encrypt_encoded_quantize(encodings)
+        encrypted_prediction = run_fhe(eval_key[1])
+        decrypted_encryption = decrypt_prediction(eval_key[1])
+
+        # Button for key generation
+        b_gen_key.click(eval_key, inputs=[], outputs=[evaluation_key])
+
+        # Button to extract vector
+        b_extract.click(
+            encodings,
+            inputs=[],
+            outputs=[extracted_vector],
+        )
+
+        # Button to encrypt file
+        b_encrypt_file.click(
+            encrypted_quantized_encoding,
+            inputs=[],
+            outputs=[encrypted_file],
+        )
+
+        # Button to run FHE-based malware scan
+        b_run_fhe_scan.click(encrypted_prediction, inputs=[], outputs=[encrypted_scan_result])
+
+        # Button to decrypt the scan result
+        b_decrypt_result.click(decrypted_encryption, inputs=[], outputs=[scan_result])
+
+        gr.Markdown(
+            "ClairVault is built using advanced Fully Homomorphic Encryption techniques to ensure your data remains private and secure throughout the entire malware scanning process."
+        )
+        gr.Markdown("## 🌍 Market Opportunity")
+        gr.Markdown(
+        """
+        The global cybersecurity market is valued at $60 billion in 2024 with an annual growth rate of 15% projected by Morgan Stanley. In 2023, there were 6 billion cyberattacks, a 10% increase from 2022.
+        **Target Industries**: Finance, Healthcare, Government, Legal Services, Individuals 
+        **Estimated TAM (Total Addressable Market) for Privacy-Preserving Malware Scanning**:
+        While exact figures for malware scanning are not available, we estimate it to be approximately 10% of the total cybersecurity market, or $6 billion. (Kaspersky has 700 million of revenue, Norton 1.5 billion, McAfee 2.5 billion.)
+        Based on the critical need in our target industries we estimate privacy-preserving to be 5-10% of that, approximately $300-600 million.
+        """
+        )
+
+        gr.Markdown("## 🏆 Competitive Advantage")
+        gr.Markdown(
+        """
+        Unlike traditional solutions:
+        1. Complete data privacy through FHE
+        2. Open-source transparency
+        3. Cloud-based scanning without local resource consumption
+        4. Immunity to local malware compromise
+        """
+        )
+
+        gr.Markdown("## 🚀 Go-To-Market Strategy")
+        gr.Markdown("### 🎯 Target Customers")
+        gr.Markdown(
+        """
+        1. Enterprise Clients in sensitive industries
+        2. Cloud Service Providers
+        3. Cybersecurity Firms 
+        4. Privacy-conscious individuals
+        """
+        )
+
+        gr.Markdown("### 💰 Revenue Model")
+        gr.Markdown(
+        """
+        1. Enterprise Licensing
+        2. Tiered Subscription Plans
+        3. API Access Fees
+        """
+        )
+
+        gr.Markdown("### 📈 Sales and Marketing Channels")
+        gr.Markdown(
+        """
+        1. Direct Enterprise Sales
+        2. Partnerships with cloud providers and cybersecurity firms
+        3. Industry events and conferences
+        4. Content marketing (whitepapers, case studies)
+        """
+        )
+
+        gr.Markdown("## 🏅 Achievements and Roadmap")
+        gr.Markdown("### 🏆 Current Achievements")
+        gr.Markdown(
+        """
+        - Developed a proof-of-concept multiscanner using the TFHE library
+        - Successfully demonstrated end-to-end process from local encryption to cloud scanning
+        - Implemented a linear classifier for malware detection on encrypted data
+        """
+        )
+
+        gr.Markdown("### 🔮 Future Development")
+        gr.Markdown(
+        """
+        1. Develop real-time scanning capabilities
+        2. Add behavior analysis through encrypted log processing 
+        3. Expand to support a wider range of file types and encryption schemes
+        """
+        )
+
+    demo.launch(share=False)