Update app.py

app.py

@@ -2,78 +2,264 @@ import gradio as gr
 import spaces
 import subprocess
 import os
+import sys
 
-# --- 1. THE INSTALLER (Restored) ---
+# --- 1. THE INSTALLER ---
 def get_hashcat_binary():
-    # If the file exists from your previous run, use it.
-    if os.path.exists("hashcat-6.2.6/hashcat"):
-        return "./hashcat-6.2.6/hashcat"
-        
-    # If missing, quick compile
-    print("⚡ Downloading & Compiling Hashcat...")
-    subprocess.run("wget https://github.com/hashcat/hashcat/archive/refs/tags/v6.2.6.tar.gz", shell=True)
-    subprocess.run("tar -xzf v6.2.6.tar.gz", shell=True)
-    subprocess.run("make -C hashcat-6.2.6 -j8", shell=True)
-    return "./hashcat-6.2.6/hashcat"
+    """Returns path to hashcat binary, compiling if needed."""
+    binary_path = "./hashcat-6.2.6/hashcat.bin"  # Changed to .bin
+    
+    if os.path.exists(binary_path):
+        print(f"✓ Found existing binary: {binary_path}")
+        return binary_path
+    
+    try:
+        print("⚡ Downloading & Compiling Hashcat...")
+        
+        # Download
+        result = subprocess.run(
+            "wget -q https://github.com/hashcat/hashcat/archive/refs/tags/v6.2.6.tar.gz",
+            shell=True, capture_output=True, text=True
+        )
+        if result.returncode != 0:
+            raise RuntimeError(f"Download failed: {result.stderr}")
+        
+        # Extract
+        result = subprocess.run(
+            "tar -xzf v6.2.6.tar.gz",
+            shell=True, capture_output=True, text=True
+        )
+        if result.returncode != 0:
+            raise RuntimeError(f"Extract failed: {result.stderr}")
+        
+        # Compile
+        print("Compiling (this takes 2-3 minutes)...")
+        result = subprocess.run(
+            "make -C hashcat-6.2.6 -j$(nproc)",
+            shell=True, capture_output=True, text=True, timeout=300
+        )
+        
+        print("Make stdout:", result.stdout[-500:])  # Last 500 chars
+        print("Make stderr:", result.stderr[-500:])
+        print("Make return code:", result.returncode)
+        
+        # Check what was actually built
+        print("\nFiles in hashcat-6.2.6:")
+        for f in os.listdir("hashcat-6.2.6"):
+            if "hashcat" in f.lower():
+                full_path = os.path.join("hashcat-6.2.6", f)
+                print(f"  {f} - exists: {os.path.exists(full_path)}, "
+                      f"size: {os.path.getsize(full_path) if os.path.exists(full_path) else 0}")
+        
+        # Try multiple possible binary names
+        possible_binaries = [
+            "./hashcat-6.2.6/hashcat.bin",
+            "./hashcat-6.2.6/hashcat",
+            "./hashcat-6.2.6/hashcat.exe"
+        ]
+        
+        for binary in possible_binaries:
+            if os.path.exists(binary):
+                print(f"✓ Found binary: {binary}")
+                os.chmod(binary, 0o755)
+                return binary
+        
+        raise FileNotFoundError(
+            f"Compilation completed but no binary found. Checked: {possible_binaries}"
+        )
+            
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(f"Failed to install hashcat: {e.stderr}")
+    except subprocess.TimeoutExpired:
+        raise RuntimeError("Compilation timed out after 5 minutes")
 
 # --- 2. THE ATTACK LOGIC ---
 @spaces.GPU(duration=300)
 def run_hashcat(hash_input, wordlist_input, allowed_symbols, attack_mode):
-    # A. Get Binary & Fix Permissions
-    hc_bin = get_hashcat_binary()
-    subprocess.run(f"chmod +x {hc_bin}", shell=True)
-
-    # B. Sanity Check (Logs the version to prove it's alive)
-    check = subprocess.run(f"{hc_bin} --version", shell=True, capture_output=True, text=True)
-    logs = [f"--- DEBUG START ---", f"Binary: {hc_bin}", f"Version Check: {check.stdout.strip()}"]
-
-    # C. Prepare Files
-    with open("target.hash", "w") as f: f.write(hash_input.strip())
-    with open("custom.dict", "w") as f: f.write(wordlist_input.strip())
-
-    # D. Build Command
-    # 2>&1 merges errors into output so you can see crashes
-    base_cmd = f"{hc_bin} -m 1000 --force -O"
-    charset = f"-1 {allowed_symbols}"
-    
-    if attack_mode == "Quick Check (NTLM)":
-        cmd = f"{base_cmd} -a 0 target.hash custom.dict"
-    elif attack_mode == "Hybrid (Words + 4 Custom Chars)":
-        cmd = f"{base_cmd} -a 6 {charset} target.hash custom.dict ?1?1?1?1"
-    elif attack_mode == "Hybrid (Words + 6 Custom Chars)":
-        cmd = f"{base_cmd} -a 6 {charset} target.hash custom.dict ?1?1?1?1?1?1"
-    elif attack_mode == "Rules-Based Mutations":
-        cmd = f"{base_cmd} -a 0 target.hash custom.dict -r ./hashcat-6.2.6/rules/best66.rule"
-    else:
-        return "Error: Invalid Mode"
-
-    logs.append(f"Command: {cmd}")
-    logs.append("--- RUNNING... ---")
-
-    # E. Run & Capture Everything
-    process = subprocess.run(f"{cmd} 2>&1", shell=True, capture_output=True, text=True)
-    logs.append(process.stdout)
+    """Run hashcat with specified parameters."""
+    logs = []
     
-    return "\n".join(logs)
+    try:
+        # A. Validate inputs
+        if not hash_input or not hash_input.strip():
+            return "❌ Error: Hash input is required"
+        if not wordlist_input or not wordlist_input.strip():
+            return "❌ Error: Wordlist input is required"
+        
+        logs.append("=== HASHCAT GPU CRACKER ===\n")
+        
+        # B. Get Binary
+        logs.append("📦 Locating hashcat binary...")
+        hc_bin = get_hashcat_binary()
+        logs.append(f"✓ Binary: {hc_bin}\n")
+        
+        # C. Version Check
+        logs.append("🔍 Checking version...")
+        version_check = subprocess.run(
+            [hc_bin, "--version"], 
+            capture_output=True, 
+            text=True, 
+            timeout=10
+        )
+        logs.append(version_check.stdout.strip())
+        logs.append("")
+        
+        # D. Device Info
+        logs.append("🎮 Checking GPU...")
+        device_check = subprocess.run(
+            [hc_bin, "-I"],
+            capture_output=True,
+            text=True,
+            timeout=10
+        )
+        logs.append(device_check.stdout.strip())
+        logs.append("")
+        
+        # E. Prepare Files
+        logs.append("📝 Preparing attack files...")
+        with open("target.hash", "w") as f:
+            f.write(hash_input.strip() + "\n")
+        
+        word_count = len(wordlist_input.strip().split('\n'))
+        with open("custom.dict", "w") as f:
+            f.write(wordlist_input.strip())
+        logs.append(f"✓ Hash file created")
+        logs.append(f"✓ Wordlist created ({word_count} words)\n")
+        
+        # F. Build Command
+        base_cmd = [hc_bin, "-m", "1000", "--force", "-O", "--potfile-path", "hashcat.potfile"]
+        
+        if attack_mode == "Quick Check (NTLM)":
+            cmd = base_cmd + ["-a", "0", "target.hash", "custom.dict"]
+            logs.append(f"⚔️ Attack: Dictionary ({word_count} words)")
+        
+        elif attack_mode == "Hybrid (Words + 4 Custom Chars)":
+            cmd = base_cmd + ["-a", "6", "-1", allowed_symbols, 
+                             "target.hash", "custom.dict", "?1?1?1?1"]
+            keyspace = word_count * (len(allowed_symbols) ** 4)
+            logs.append(f"⚔️ Attack: Hybrid (words + 4 chars)")
+            logs.append(f"   Keyspace: ~{keyspace:,} combinations")
+        
+        elif attack_mode == "Hybrid (Words + 6 Custom Chars)":
+            cmd = base_cmd + ["-a", "6", "-1", allowed_symbols,
+                             "target.hash", "custom.dict", "?1?1?1?1?1?1"]
+            keyspace = word_count * (len(allowed_symbols) ** 6)
+            logs.append(f"⚔️ Attack: Hybrid (words + 6 chars)")
+            logs.append(f"   Keyspace: ~{keyspace:,} combinations")
+        
+        elif attack_mode == "Rules-Based Mutations":
+            rules_path = "./hashcat-6.2.6/rules/best66.rule"
+            if not os.path.exists(rules_path):
+                return "❌ Error: Rules file not found"
+            cmd = base_cmd + ["-a", "0", "target.hash", "custom.dict", "-r", rules_path]
+            logs.append(f"⚔️ Attack: Rules-based (best66)")
+        else:
+            return f"❌ Error: Invalid attack mode"
+        
+        logs.append(f"   Charset: {allowed_symbols}\n")
+        logs.append("🚀 Starting attack...\n")
+        logs.append("=" * 60)
+        
+        # G. Execute
+        process = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=270
+        )
+        
+        logs.append(process.stdout)
+        
+        if process.stderr:
+            logs.append("\n--- STDERR ---")
+            logs.append(process.stderr)
+        
+        # H. Check Results
+        logs.append("\n" + "=" * 60)
+        if os.path.exists("hashcat.potfile"):
+            with open("hashcat.potfile", "r") as f:
+                potfile_content = f.read().strip()
+                if potfile_content:
+                    logs.append("\n🎉 PASSWORD CRACKED!")
+                    logs.append("=" * 60)
+                    for line in potfile_content.split('\n'):
+                        if ':' in line:
+                            hash_part, password = line.split(':', 1)
+                            logs.append(f"Password: {password}")
+                else:
+                    logs.append("\n❌ Password not found")
+        else:
+            logs.append("\n❌ Password not found")
+        
+        return "\n".join(logs)
+        
+    except subprocess.TimeoutExpired:
+        return "\n".join(logs) + "\n\n⏱️ TIMEOUT: Attack exceeded time limit"
+    except Exception as e:
+        return "\n".join(logs) + f"\n\n❌ ERROR: {str(e)}\n{type(e).__name__}"
+    finally:
+        # Cleanup
+        for tmp_file in ["target.hash", "custom.dict"]:
+            try:
+                if os.path.exists(tmp_file):
+                    os.remove(tmp_file)
+            except:
+                pass
 
 # --- 3. THE INTERFACE ---
-with gr.Blocks() as demo:
-    gr.Markdown("# ⚡ Direct Hashcat Runner (Complete)")
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# ⚡ Hashcat GPU Cracker")
+    gr.Markdown("*Educational/Research Use Only*")
     
     with gr.Row():
-        txt_hash = gr.Textbox(label="1. Hash", placeholder="Paste NTLM hash")
-        txt_words = gr.Textbox(label="2. Wordlist", lines=5, placeholder="Word1\nWord2")
+        txt_hash = gr.Textbox(
+            label="🎯 NTLM Hash", 
+            placeholder="8846F7EAEE8FB117AD06BDD830B7586C",
+            info="32-character hex hash"
+        )
+        txt_words = gr.Textbox(
+            label="📚 Wordlist", 
+            lines=6, 
+            placeholder="password\nadmin\nwelcome\n123456",
+            info="One word per line"
+        )
     
     with gr.Row():
-        txt_symbols = gr.Textbox(label="3. Allowed Chars", value="acdegilmnorstuvwxz0123456789!@#$&*?.")
+        txt_symbols = gr.Textbox(
+            label="🔤 Character Set", 
+            value="abcdefghijklmnopqrstuvwxyz0123456789!@#$",
+            info="Characters for hybrid attacks"
+        )
         mode_select = gr.Dropdown(
-            ["Quick Check (NTLM)", "Hybrid (Words + 4 Custom Chars)", "Hybrid (Words + 6 Custom Chars)", "Rules-Based Mutations"], 
-            label="4. Mode", value="Hybrid (Words + 6 Custom Chars)"
+            choices=[
+                "Quick Check (NTLM)", 
+                "Hybrid (Words + 4 Custom Chars)", 
+                "Hybrid (Words + 6 Custom Chars)", 
+                "Rules-Based Mutations"
+            ],
+            label="⚔️ Attack Mode", 
+            value="Quick Check (NTLM)",
+            info="Start with Quick Check"
         )
     
-    btn_run = gr.Button("🔓 CRACK NOW", variant="primary")
-    output_log = gr.Code(label="Hashcat Raw Output", language="shell")
+    with gr.Row():
+        btn_run = gr.Button("🚀 Start Attack", variant="primary", size="lg")
+    
+    output_log = gr.Code(label="📊 Attack Log", language="shell", lines=25)
+    
+    gr.Markdown("""
+    ### 💡 Tips:
+    - **Quick Check**: Tests wordlist directly
+    - **Hybrid**: Appends random characters to each word
+    - **Rules**: Applies mutations (l33t speak, caps, etc.)
+    - Start simple, escalate if needed
+    """)
     
-    btn_run.click(fn=run_hashcat, inputs=[txt_hash, txt_words, txt_symbols, mode_select], outputs=output_log)
+    btn_run.click(
+        fn=run_hashcat, 
+        inputs=[txt_hash, txt_words, txt_symbols, mode_select], 
+        outputs=output_log
+    )
 
-demo.launch()
+if __name__ == "__main__":
+    demo.launch()