Update app.py

app.py

@@ -1,95 +1,63 @@
 import gradio as gr
-import hashlib
-import zlib
 
+# -----------------------------
+# JAVA HASHCODE
+# -----------------------------
 
 def java_hash(s):
     h = 0
     for c in s:
         h = (31 * h + ord(c)) & 0xFFFFFFFF
 
+    # convert to signed 32-bit
     if h >= 0x80000000:
         h -= 0x100000000
 
-    return str(h)
+    return h
 
 
-def crc32_hash(s):
-    return str(zlib.crc32(s.encode()))
+# -----------------------------
+# NORMALIZATION (KEY FIX)
+# -----------------------------
 
-
-def adler32_hash(s):
-    return str(zlib.adler32(s.encode()))
-
-
-def djb2(s):
-    h = 5381
-    for c in s:
-        h = ((h << 5) + h) + ord(c)
-    return str(h & 0xFFFFFFFF)
-
-
-def fnv1a(s):
-    h = 0x811c9dc5
-    for c in s:
-        h ^= ord(c)
-        h *= 0x01000193
-        h &= 0xFFFFFFFF
-    return str(h)
-
-
-def normalize_int(value):
+def normalize_java_target(value):
     try:
         v = int(value)
 
         signed = v if v < 0x80000000 else v - 0x100000000
         unsigned = v & 0xFFFFFFFF
 
-        return {str(v), str(signed), str(unsigned)}
-    except:
-        return {str(value).strip()}
-
-
-def detect(hash_value):
-    candidates = []
-
-    if hash_value.startswith("$2"):
-        candidates.append("bcrypt")
-
-    try:
-        int(hash_value)
-        candidates += [
-            "java_hash",
-            "crc32",
-            "adler32",
-            "djb2",
-            "fnv1a"
-        ]
+        return {v, signed, unsigned}
     except:
-        pass
+        return {value}
 
-    return list(dict.fromkeys(candidates))
 
+# -----------------------------
+# CLEAN WORDLIST
+# -----------------------------
 
 def clean_wordlist(text):
     return [
         w.strip()
-        .replace("\r", "")
-        .replace("\n", "")
         for w in text.splitlines()
         if w.strip()
     ]
 
 
-def try_match(func, target, words):
+# -----------------------------
+# CRACK ENGINE (JAVA ONLY)
+# -----------------------------
+
+def crack_java(target_hash, words):
     matches = []
 
-    targets = normalize_int(target)
+    targets = normalize_java_target(target_hash)
 
     for w in words:
         try:
-            result = str(func(w)).strip()
+            result = java_hash(w)
 
+            # compare ALL representations automatically
             if result in targets:
                 matches.append(w)
 
@@ -99,6 +67,10 @@ def try_match(func, target, words):
     return matches
 
 
+# -----------------------------
+# MAIN
+# -----------------------------
+
 def analyze(hash_value, wordlist_text):
 
     if wordlist_text.strip():
@@ -110,49 +82,25 @@ def analyze(hash_value, wordlist_text):
             "test23"
         ]
 
-    detected = detect(hash_value)
-    matches = {}
+    matches = crack_java(hash_value, wordlist)
 
-    if "java_hash" in detected:
-        m = try_match(java_hash, hash_value, wordlist)
-        if m:
-            matches["Java hashCode"] = m
-
-    if "crc32" in detected:
-        m = try_match(crc32_hash, hash_value, wordlist)
-        if m:
-            matches["CRC32"] = m
-
-    if "adler32" in detected:
-        m = try_match(adler32_hash, hash_value, wordlist)
-        if m:
-            matches["Adler32"] = m
-
-    if "djb2" in detected:
-        m = try_match(djb2, hash_value, wordlist)
-        if m:
-            matches["DJB2"] = m
-
-    if "fnv1a" in detected:
-        m = try_match(fnv1a, hash_value, wordlist)
-        if m:
-            matches["FNV1a"] = m
-
-    detected_out = "\n".join(detected) if detected else "Unknown"
+    detected_out = "Java String.hashCode() (detected by integer format)"
 
     if matches:
-        result_out = "\n".join(
-            f"{k}: {v[:10]}" for k, v in matches.items()
-        )
+        result_out = f"Matches: {matches}"
     else:
         result_out = "No matches found (try larger wordlist)"
 
     return detected_out, result_out
 
 
+# -----------------------------
+# UI
+# -----------------------------
+
 with gr.Blocks() as demo:
 
-    gr.Markdown("# 🔍 CTF Hash Reverser (Fixed)")
+    gr.Markdown("# 🔍 Java hashCode Reverser")
 
     hash_input = gr.Textbox(label="Hash / Integer Value")
 
@@ -161,9 +109,9 @@ with gr.Blocks() as demo:
         lines=10
     )
 
-    run_btn = gr.Button("Analyze & Crack")
+    run_btn = gr.Button("Crack")
 
-    detected_out = gr.Textbox(label="Detected Algorithms")
+    detected_out = gr.Textbox(label="Detected Algorithm")
     result_out = gr.Textbox(label="Recovered Matches")
 
     run_btn.click(