initial commit

README.md

@@ -1,8 +1,8 @@
 ---
 title: Encrypted Face Matching And Search
 emoji: 🔥
-colorFrom: gray
-colorTo: green
+colorFrom: yellow
+colorTo: red
 sdk: gradio
 sdk_version: 5.38.2
 app_file: app.py

app.py

@@ -0,0 +1,411 @@
+import gradio as gr
+import numpy as np
+from PIL import Image
+import cv2
+from insightface.app import FaceAnalysis
+from huggingface_hub import snapshot_download
+import time
+import subprocess
+import os
+
+# --- Configuration ---
+SECURITYLEVELS = ["128", "196", "256"]
+FRMODELS = ["AuraFace-v1"]
+EXAMPLE_IMAGES_ENROLL = ['./VGGFace2/n000001/0002_01.jpg', './VGGFace2/n000149/0002_01.jpg', './VGGFace2/n000082/0001_02.jpg', './VGGFace2/n000148/0014_01.jpg']
+EXAMPLE_IMAGES_AUTH = ['./VGGFace2/n000001/0013_01.jpg', './VGGFace2/n000149/0019_01.jpg', './VGGFace2/n000082/0003_03.jpg', './VGGFace2/n000148/0043_01.jpg']
+
+# --- Global Variables ---
+face_app = None
+DB_SUBJECT_COUNT = 1
+ENROLLED_SEARCH_IMAGES = []
+
+# --- Helper Functions ---
+def initialize_face_app():
+    """Initializes the FaceAnalysis model."""
+    global face_app
+    if face_app is None:
+        print("Initializing FaceAnalysis model...")
+        snapshot_download("fal/AuraFace-v1", local_dir="./models/auraface")
+        face_app = FaceAnalysis(name="auraface", providers=["CPUExecutionProvider"], root=".")
+        face_app.prepare(ctx_id=0, det_size=(128, 128))
+        print("FaceAnalysis model initialized.")
+    return face_app
+
+def run_binary(bin_path, *args):
+    """Runs a compiled binary file and returns the result."""
+    if not os.path.isfile(bin_path):
+        raise gr.Error(f"Error: Compiled binary not found at {bin_path}")
+    
+    command = [bin_path] + [str(arg) for arg in args]
+    print(f"Running command: {' '.join(command)}")
+    
+    try:
+        os.chmod(bin_path, 0o755)
+        start_time = time.time()
+        result = subprocess.run(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, check=True)
+        duration = time.time() - start_time
+        print(f"Binary execution successful. Duration: {duration:.2f}s")
+        return result.stdout, duration
+    except subprocess.CalledProcessError as e:
+        print(f"Error executing binary: {e.stderr}")
+        raise gr.Error(f"Execution failed: {e.stderr}")
+    except Exception as e:
+        print(f"An unexpected error occurred: {e}")
+        raise gr.Error(f"An unexpected error occurred: {str(e)}")
+
+def extract_embedding(image_path, mode=None):
+    """Extracts face embedding from an image path."""
+    if image_path is None:
+        raise gr.Error("Please upload or select an image first.")
+    
+    app = initialize_face_app()
+    
+    try:
+        pil_image = Image.open(image_path).convert("RGB")
+    except Exception as e:
+        raise gr.Error(f"Failed to open or read image file: {e}")
+
+    cv2_image = np.array(pil_image)
+    cv2_image = cv2_image[:, :, ::-1]
+    faces = app.get(cv2_image)
+
+    if not faces:
+        raise gr.Error("No face detected. Please try another image.")
+    
+    embedding = faces[0].normed_embedding
+    
+    if mode:
+        # For 1:1 recognition, save to the respective binary folder
+        if mode in ["enroll", "auth"]:
+            emb_path = f'./{mode}-emb.txt'
+        # For 1:N search, create a subject-specific path in the search folder
+        else: # search_enroll, search_auth
+            if "VGGFace2" in image_path:
+                subject = image_path.split('/')[-2]
+            else:
+                subject = 'uploadedSubj'
+            os.makedirs(f'./embeddings/{subject}', exist_ok=True)
+            emb_path = f'./embeddings/{subject}/{mode}-emb.txt'
+        
+        np.savetxt(emb_path, embedding.reshape(1, -1), fmt="%.6f", delimiter=',')
+        return embedding.tolist(), emb_path
+        
+    return embedding.tolist()
+
+# --- UI Components ---
+def create_image_selection_ui(label, gallery_images):
+    with gr.Group():
+        gr.HTML(f'<h3 class="step-header">{label}</h3>')
+        image_state = gr.State()
+        image_display = gr.Image(type="filepath", label="Selected Image", interactive=False)
+        with gr.Tabs():
+            with gr.TabItem("Upload"):
+                image_upload = gr.Image(type="filepath", label=f"Upload Image")
+            with gr.TabItem("Select from Gallery"):
+                image_gallery = gr.Gallery(value=gallery_images, columns=4, height="auto", object_fit="contain")
+    
+    # Event handlers that directly update both the hidden state and the visible display
+    def on_select(evt: gr.SelectData):
+        selected_image = gallery_images[evt.index]  # Get the actual image path from the gallery list
+        return selected_image, selected_image
+
+    def on_upload(filepath):
+        return filepath, filepath
+
+    image_upload.change(on_upload, inputs=image_upload, outputs=[image_state, image_display])
+    image_gallery.select(on_select, None, outputs=[image_state, image_display])
+    
+    return image_state
+
+# --- UI Styling and Theming ---
+css = """
+@import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap');
+:root {
+  --background: #EEEEEC; --background-alt: #EEEEEC; --card-bg: #FFFFFF; --card-bg-alt: rgba(255, 208, 134, 0.3);
+  --foreground: #222; --foreground-muted: #333; --accent-orange: rgb(255, 208, 134);
+  --accent-gradient: linear-gradient(90deg, var(--accent-orange) 0%, #333333 100%);
+  --font-sans: 'Inter', Arial, Helvetica, sans-serif; --gray-333: #333333;
+}
+body, .gradio-container { background: var(--background); color: var(--foreground); font-family: var(--font-sans); font-size: 16px; line-height: 1.6; }
+.main-header { padding: 1rem; text-align: center; margin-bottom: 2rem; background: var(--gray-333); color: var(--background); border-radius: 15px; }
+.main-header h1 { font-size: 2.5rem; font-weight: 700; color: var(--accent-orange); margin:0; }
+.main-header p { font-size: 1.1rem; opacity: 0.9; margin: 0.5rem 0 0 0; }
+.main-header a { color: var(--background); text-decoration: none; background: transparent; padding: 0.6rem 1.5rem; border-radius: 25px; border: 1px solid var(--accent-orange); font-weight: 500; transition: all 0.3s ease; display: inline-block; margin-top: 1rem; }
+.main-header a:hover { background: var(--accent-orange); color: var(--gray-333); }
+.section-header { text-align: center; margin: 2rem 0; padding: 0 1rem; }
+.section-header h1 { color: var(--foreground); font-size: 2.2rem; font-weight: 600; margin-bottom: 0.5rem; }
+.section-header h2 { color: var(--foreground-muted); font-size: 1.5rem; font-weight: 400; margin: 0; }
+.narrative-section { background: var(--card-bg); border-top: 4px solid var(--accent-orange); padding: 2rem; margin: 1.5rem 0; border-radius: 12px; box-shadow: 0 4px 15px rgba(0,0,0,0.05); }
+.narrative-header { color: var(--foreground); margin: 0 0 1.5rem 0; font-size: 1.8rem; font-weight: 600; }
+.step-header { color: var(--foreground); margin: 0 0 1.5rem 0; font-size: 1.3rem; font-weight: 600; }
+.info-card { background: var(--card-bg-alt); border: 1px solid var(--accent-orange); border-radius: 12px; padding: 1.5rem; margin: 1.5rem 0; }
+.info-card h3 { color: var(--foreground); margin: 0 0 1rem 0; font-size: 1.3rem; font-weight: 600; }
+.info-card p { margin: 0 0 1rem 0; color: var(--foreground-muted); line-height: 1.6; }
+.warning-card { background: #ffebee; border: 1px solid #c62828; border-radius: 12px; padding: 1.5rem; margin: 1.5rem 0; }
+.warning-card h3 { color: #c62828; margin: 0 0 1rem 0; font-size: 1.3rem; font-weight: 600; }
+.warning-card p { margin: 0; color: #424242; line-height: 1.6; }
+.result-container { padding: 2rem; border-radius: 15px; text-align: center; margin-top: 1rem; color: white; }
+.result-container h2 { margin: 0 0 0.5rem 0; font-size: 2rem; font-weight: 600; color: white; }
+.result-container p { margin: 0; opacity: 0.95; font-size: 1rem; }
+.match-verified { background: linear-gradient(135deg, #4caf50 0%, #45a049 100%); }
+.no-match { background: linear-gradient(135deg, #f44336 0%, #d32f2f 100%); }
+.icon-lock { font-size: 4rem; margin: 1rem; }
+.status-text { font-size: 1.1rem; color: var(--foreground-muted); margin-top: 1rem; }
+"""
+
+# --- Gradio UI Definition ---
+with gr.Blocks(css=css) as demo:
+    # --- Header ---
+    gr.HTML("""
+        <div class="main-header">            
+            <h1>Suraksh AI</h1>
+            <p style="color: #EEEEEC; opacity: 0.9;">The Future of Secure Biometrics</p>
+            <a href="https://suraksh.ai/" target="_blank">🌐 Visit Our Website</a>
+        </div>
+    """)
+
+    # --- Key Generation on Load ---
+    # Generate keys once for each demo when the app starts up
+    demo.load(lambda: run_binary("./bin/genKeys.bin", "128", "genkeys"), None, None)
+    demo.load(lambda: run_binary("./bin/search.bin", "128", "genkeys"), None, None)
+
+
+    # --- Main Tabs for Demo Mode ---
+    with gr.Tabs() as mode_tabs:
+        # --- 1:1 Recognition Demo ---
+        with gr.TabItem("👁️ Face Recognition (1:1)"):
+            gr.HTML("""<div class="section-header"><h1>Is this the same person?</h1><h2>A one-to-one verification demo.</h2></div>""")
+            
+            with gr.Tabs():
+                # --- Vulnerable System Tab ---
+                with gr.TabItem("🚨 The Vulnerable System"):
+                    with gr.Group(elem_classes="narrative-section"):
+                        gr.HTML('<h2 class="narrative-header">The Problem: How Your Face Can Be Stolen</h2>')
+                        gr.HTML("""<div class="warning-card"><h3>⚠️ Your Biometric Data is Exposed!</h3><p>Most systems handle biometric data in plaintext. This means your facial embedding—a digital map of your face—can be stolen and used to reconstruct your image, creating a major privacy risk.</p></div>""")
+                        
+                        with gr.Column():
+                            gr.HTML('<h3 class="step-header">1. Original Image</h3>')
+                            gr.Image(value=EXAMPLE_IMAGES_ENROLL[2], label="Original Face", interactive=False, show_label=False, container=False)
+
+                            gr.HTML('<h3 class="step-header" style="margin-top: 2rem;">2. Simulate Attack: Steal Data</h3><p>An attacker breaches the system and steals the stored facial embedding. Click the button to simulate this theft.</p>')
+                            extract_btn = gr.Button("😱 Steal Biometric Data", variant="primary")
+
+                            with gr.Group(visible=False) as stolen_data_group:
+                                feature_output = gr.JSON(label="Stolen Feature Vector (Face Embedding)")
+                                gr.HTML('<h3 class="step-header" style="margin-top: 2rem;">3. Simulate Attack: Reconstruct Face</h3><p>Now, the attacker uses the stolen features to create a reconstruction of the face, completely compromising the user\'s privacy.</p>')
+                                reconstruct_btn = gr.Button("🎭 Reconstruct Face from Stolen Data", variant="stop")
+
+                            with gr.Group(visible=False) as reconstructed_image_group:
+                                reconstructed_output = gr.Image(label="Reconstructed Face", interactive=False, show_label=False)
+
+                        def extract_and_reveal(image_path):
+                            embedding = extract_embedding(image_path)
+                            feature_json = {"embedding": embedding}
+                            return {
+                                feature_output: feature_json,
+                                stolen_data_group: gr.update(visible=True),
+                                extract_btn: gr.update(value="Data Stolen!", interactive=False)
+                            }
+
+                        def show_reconstruction():
+                            reconstructed_image_path = "./static/reconstructed.png"
+                            return {
+                                reconstructed_output: reconstructed_image_path,
+                                reconstructed_image_group: gr.update(visible=True),
+                                reconstruct_btn: gr.update(interactive=False)
+                            }
+
+                        extract_btn.click(
+                            fn=extract_and_reveal,
+                            inputs=gr.State(EXAMPLE_IMAGES_ENROLL[0]),
+                            outputs=[feature_output, stolen_data_group, extract_btn]
+                        )
+
+                        reconstruct_btn.click(
+                            fn=show_reconstruction,
+                            inputs=None,
+                            outputs=[reconstructed_output, reconstructed_image_group, reconstruct_btn]
+                        )
+
+                # --- Secure System Tab ---
+                with gr.TabItem("✅ The Suraksh.AI Solution"):
+                    with gr.Group(elem_classes="narrative-section"):
+                        gr.HTML('<h2 class="narrative-header">The Solution: Verification with FHE</h2>')
+                        gr.HTML("""<div class="info-card"><h3>The Locked Box Analogy</h3><p>With Suraksh.AI, your biometric data is encrypted inside a "locked box" before it ever leaves your device. We can perform the verification on the encrypted data without ever seeing your real face. It's mathematically impossible for us to decrypt it.</p></div>""")
+                        
+                        with gr.Row():
+                            with gr.Column():
+                                rec_ref_img = create_image_selection_ui("1. Provide Reference Image", EXAMPLE_IMAGES_ENROLL)
+                                with gr.Group(visible=False) as rec_ref_features_group:
+                                    rec_ref_raw_features = gr.JSON(label="Raw Features (Plaintext)")
+                                    rec_ref_encrypted_features = gr.Textbox(label="Encrypted Features (Ciphertext)", interactive=False, lines=5)
+                            with gr.Column():
+                                rec_probe_img = create_image_selection_ui("2. Provide Probe Image", EXAMPLE_IMAGES_AUTH)
+                                with gr.Group(visible=False) as rec_probe_features_group:
+                                    rec_probe_raw_features = gr.JSON(label="Raw Features (Plaintext)")
+                                    rec_probe_encrypted_features = gr.Textbox(label="Encrypted Features (Ciphertext)", interactive=False, lines=5)
+
+                        with gr.Accordion("Advanced Settings", open=False):
+                            rec_threshold = gr.Slider(-512*5, 512*5, value=133, label="Match Strictness", info="A higher value means a stricter match is required.")
+                            rec_sec_level = gr.Dropdown(SECURITYLEVELS, value="128", label="Security Level")
+
+                        rec_run_btn = gr.Button("🚀 Perform Secure 1:1 Match", variant="primary", size="lg")
+                        
+                        rec_status = gr.HTML(elem_classes="status-text")
+                        rec_result = gr.HTML()
+
+                        def secure_recognition_flow(ref_img, probe_img, threshold, sec_level):
+                            # Reset UI
+                            yield "Initializing...", "", gr.update(visible=False), None, None, gr.update(visible=False), None, None
+
+                            # Process Reference Image
+                            yield "Extracting reference features...", "", gr.update(visible=False), None, None, gr.update(visible=False), None, None
+                            ref_emb, _ = extract_embedding(ref_img, "enroll")
+                            
+                            yield "Encrypting reference features...", "", gr.update(visible=True), {"embedding": ref_emb}, None, gr.update(visible=False), None, None
+                            run_binary("./bin/encReference.bin", sec_level, "encrypt")
+                            ref_ciphertext, _ = run_binary("./bin/encReference.bin", sec_level, "print")
+
+
+                            # Process Probe Image
+                            yield "✅ Reference Encrypted. Extracting probe features...", "", gr.update(visible=True), {"embedding": ref_emb}, ref_ciphertext, gr.update(visible=False), None, None
+                            probe_emb, _ = extract_embedding(probe_img, "auth")
+
+                            yield "Encrypting probe features...", "", gr.update(visible=True), {"embedding": ref_emb}, ref_ciphertext, gr.update(visible=True), {"embedding": probe_emb}, None
+                            run_binary("./bin/encProbe.bin", sec_level, "encrypt")
+                            probe_ciphertext, _ = run_binary("./bin/encProbe.bin", sec_level, "print")
+
+                            # Perform Match
+                            yield "✅ Probe Encrypted. Performing Secure Match...", "", gr.update(visible=True), {"embedding": ref_emb}, ref_ciphertext, gr.update(visible=True), {"embedding": probe_emb}, probe_ciphertext
+                            run_binary("./bin/recDecision.bin", sec_level, "decision", threshold)
+                            
+                            yield "✅ Match Computed. Decrypting Result...", "", gr.update(visible=True), {"embedding": ref_emb}, ref_ciphertext, gr.update(visible=True), {"embedding": probe_emb}, probe_ciphertext
+                            output, _ = run_binary("./bin/decDecision.bin", sec_level, "decision")
+                            
+                            if output.strip().lower() == "match":
+                                result_html = f"""<div class="result-container match-verified"><h2>✅ MATCH VERIFIED</h2><p>Identity successfully confirmed under FHE.</p></div>"""
+                            else:
+                                result_html = f"""<div class="result-container no-match"><h2>❌ NO MATCH</h2><p>Identity verification failed.</p></div>"""
+                            yield "Done!", result_html, gr.update(visible=True), {"embedding": ref_emb}, ref_ciphertext, gr.update(visible=True), {"embedding": probe_emb}, probe_ciphertext
+
+                        rec_run_btn.click(
+                            fn=secure_recognition_flow,
+                            inputs=[rec_ref_img, rec_probe_img, rec_threshold, rec_sec_level],
+                            outputs=[rec_status, rec_result, rec_ref_features_group, rec_ref_raw_features, rec_ref_encrypted_features, rec_probe_features_group, rec_probe_raw_features, rec_probe_encrypted_features]
+                        )
+
+        # --- 1:N Search Demo ---
+        with gr.TabItem("🔍 Face Search (1:N)"):
+            gr.HTML("""<div class="section-header"><h1>Who is this person?</h1><h2>A one-to-many search demo against an encrypted database.</h2></div>""")
+            
+            with gr.Tabs():
+                # --- Secure System Tab ---
+                with gr.TabItem("✅ The Suraksh.AI Solution"):
+                    with gr.Group(elem_classes="narrative-section"):
+                        gr.HTML('<h2 class="narrative-header">Building and Searching a Secure Database</h2>')
+                        gr.HTML("""<div class="info-card"><h3>From Verification to Identification</h3><p>This demo shows how FHE can be used to search for a person in a database without ever decrypting the database itself. This is ideal for large-scale, privacy-preserving identification systems.</p></div>""")
+
+                        with gr.Row():
+                            with gr.Column():
+                                gr.HTML('<h3 class="step-header">1. Enroll Subjects into DB</h3>')
+                                search_enroll_img = create_image_selection_ui("Select Image to Enroll", EXAMPLE_IMAGES_ENROLL)
+                                search_enroll_btn = gr.Button("➕ Encrypt & Add to Database", variant="secondary")
+                                with gr.Group(visible=False) as enroll_features_group:
+                                    enroll_raw_features = gr.JSON(label="Raw Features (Plaintext)")
+                                    enroll_encrypted_features = gr.Textbox(label="Encrypted Features (Ciphertext)", interactive=False, lines=5)
+                                search_enroll_status = gr.HTML()
+
+                            with gr.Column():
+                                gr.HTML('<h3 class="step-header">2. Search for a Subject</h3>')
+                                search_probe_img = create_image_selection_ui("Select Image to Search", EXAMPLE_IMAGES_AUTH)
+                                search_run_btn = gr.Button("🚀 Perform Secure 1:N Search", variant="primary", size="lg")
+                                with gr.Group(visible=False) as search_features_group:
+                                    search_raw_features = gr.JSON(label="Raw Features (Plaintext)")
+                                    search_encrypted_features = gr.Textbox(label="Encrypted Features (Ciphertext)", interactive=False, lines=5)
+                                search_status = gr.HTML(elem_classes="status-text")
+                        
+                        search_result = gr.HTML()
+                        search_result_image = gr.Image(label="Found Reference Image", interactive=False, visible=False)
+                        
+                        with gr.Accordion("Advanced Settings", open=False):
+                            search_threshold = gr.Slider(-512*5, 512*5, value=133, label="Match Strictness")
+                            search_sec_level = gr.Dropdown(SECURITYLEVELS, value="128", label="Security Level")
+                        
+                        def secure_enroll_flow(image, sec_level):
+                            global DB_SUBJECT_COUNT, ENROLLED_SEARCH_IMAGES
+                            if image is None: raise gr.Error("Please provide an image to enroll.")
+                            
+                            current_id = DB_SUBJECT_COUNT
+                            
+                            yield "Extracting features...", gr.update(visible=False), None, None
+                            embedding, emb_path = extract_embedding(image, "search_enroll")
+                            
+                            yield "Encrypting features...", gr.update(visible=True), {"embedding": embedding}, None
+                            run_binary("./bin/search.bin", sec_level, "encRef", emb_path, current_id)
+                            ciphertext, _ = run_binary("./bin/search.bin", sec_level, "printVectorCipher", "encRef", "print")
+                            
+                            yield "Adding to secure database...", gr.update(visible=True), {"embedding": embedding}, ciphertext
+                            run_binary("./bin/search.bin", sec_level, "addRef")
+                            
+                            ENROLLED_SEARCH_IMAGES.append(image)
+                            DB_SUBJECT_COUNT += 1
+                            yield f"✅ Subject with ID {current_id} added. Total subjects: {DB_SUBJECT_COUNT - 1}.", gr.update(visible=True), {"embedding": embedding}, ciphertext
+
+                        def secure_search_flow(image, threshold, sec_level):
+                            global ENROLLED_SEARCH_IMAGES
+                            if image is None: raise gr.Error("Please provide an image to search.")
+                            
+                            yield "Extracting probe features...", "", gr.update(visible=False), None, None, gr.update(visible=False)
+                            embedding, emb_path = extract_embedding(image, "search_auth")
+
+                            yield "Encrypting probe features...", "", gr.update(visible=True), {"embedding": embedding}, None, gr.update(visible=False)
+                            run_binary("./bin/search.bin", sec_level, "encProbe", emb_path)
+                            ciphertext, _ = run_binary("./bin/search.bin", sec_level, "printProbe", "print")
+
+                            yield "✅ Probe encrypted. Searching database...", "", gr.update(visible=True), {"embedding": embedding}, ciphertext, gr.update(visible=False)
+                            run_binary("./bin/search.bin", sec_level, "search")
+                            
+                            yield "✅ Search complete. Decrypting results...", "", gr.update(visible=True), {"embedding": embedding}, ciphertext, gr.update(visible=False)
+                            # output, _ = run_binary("./bin/search.bin", sec_level, "decDecisionClear", threshold)
+                            output, _ = run_binary("./bin/search.bin", sec_level, "decScoreClear", threshold)
+                            print(f"Search binary output: >>>{output}<<<")
+                            
+                            lines = output.strip().split('\n')
+                            decision = lines[0].lower()
+    
+                            if decision == "found":
+                                try:
+                                    # Assuming output is "found\nID: <id>"
+                                    found_id_line = next(line for line in lines if "id:" in line.lower())
+                                    found_id = int(found_id_line.split(':')[1].strip())
+                                    
+                                    # Binary ID is 1-based, list is 0-based
+                                    found_image_path = ENROLLED_SEARCH_IMAGES[found_id - 1]
+                                    
+                                    result_html = f"""<div class="result-container match-verified"><h2>✅ SUBJECT FOUND</h2><p>The subject was successfully found in the database with ID {found_id}.</p></div>"""
+                                    result_image_update = gr.update(value=found_image_path, visible=True)
+                                
+                                except (StopIteration, IndexError, ValueError):
+                                    result_html = f"""<div class="result-container match-verified"><h2>✅ SUBJECT FOUND</h2><p>Could not parse ID from binary output: {output.strip()}</p></div>"""
+                                    result_image_update = gr.update(visible=False)
+                            else:
+                                result_html = """<div class="result-container no-match"><h2>❌ NOT FOUND</h2><p>The subject was not found in the database.</p></div>"""
+                                result_image_update = gr.update(visible=False)
+
+                            yield "Done!", result_html, gr.update(visible=True), {"embedding": embedding}, ciphertext, result_image_update
+
+                        search_enroll_btn.click(
+                            fn=secure_enroll_flow,
+                            inputs=[search_enroll_img, search_sec_level],
+                            outputs=[search_enroll_status, enroll_features_group, enroll_raw_features, enroll_encrypted_features]
+                        )
+                        
+                        search_run_btn.click(
+                            fn=secure_search_flow,
+                            inputs=[search_probe_img, search_threshold, search_sec_level],
+                            outputs=[search_status, search_result, search_features_group, search_raw_features, search_encrypted_features, search_result_image]
+                        )
+
+# --- Launch the Application ---
+if __name__ == "__main__":
+    demo.launch()

bin/decDecision.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f7675db4cd1c61743d73b78364ccefa313b408b09713e3b16e19f5a6eee087bb
+size 8045152

bin/encProbe.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3959987099fb521134b6c46c367b2b6f6106bf9bb45eda98108e26710376f078
+size 8030536

bin/encReference.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6705fbd4703ab2bc52d4af5719f5ece369de22d214dda966b124a85803c3a92d
+size 8069184

bin/genKeys.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:30c5e81854404a40c06ac9b727a17907536b1490defb055831921022b25e6e7c
+size 8079376

bin/recDecision.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:97d6a8be345463779f296ae73c70a082ea90e2c41add0f99f6875d75ff753c75
+size 8057936

bin/search.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:179c1865afefee41d161bf77a4cd45d18becbd8d47d8c3bb16b6fd5d006c6093
+size 8294280

lookupTables/Borders_nB_3_dimF_512.txt

@@ -0,0 +1 @@
+-0.050880,-0.029846,-0.014102,-0.000000,0.014102,0.029846,0.050880

lookupTables/MFIP_nB_3_dQ_0.001_dimF_512.txt

@@ -0,0 +1,8 @@
+5,3,2,1,-1,-2,-3,-5
+3,2,1,0,0,-1,-2,-3
+2,1,0,0,0,0,-1,-2
+1,0,0,0,0,0,0,-1
+-1,0,0,0,0,0,0,1
+-2,-1,0,0,0,0,1,2
+-3,-2,-1,0,0,1,2,3
+-5,-3,-2,-1,1,2,3,5

requirements.txt

@@ -0,0 +1,7 @@
+gradio
+opencv-python
+pillow
+insightface
+onnxruntime
+numpy
+huggingface_hub