Update app.py

app.py

@@ -4,37 +4,62 @@ import string
 import time
 import multiprocessing
 import math
+import zxcvbn
+import hashlib
+import random
 
 def generate_passwords(chars, length, start, end):
     for attempt in itertools.islice(itertools.product(chars, repeat=length), start, end):
         yield ''.join(attempt)
 
 def crack_chunk(args):
-    chars, length, start, end, password, chunk_id, progress_queue = args
+    chars, length, start, end, password_hash, hash_function, chunk_id, progress_queue = args
     attempts = 0
     for attempt in generate_passwords(chars, length, start, end):
         attempts += 1
-        if attempts % 1000000 == 0:  # Update progress every million attempts
+        if attempts % 1000000 == 0:
             progress_queue.put((chunk_id, attempts))
-        if attempt == password:
+        if hash_function(attempt.encode()).hexdigest() == password_hash:
             progress_queue.put((chunk_id, attempts))
             return attempts, attempt
     progress_queue.put((chunk_id, attempts))
     return attempts, None
 
-def optimized_brute_force(password, progress=gr.Progress()):
+def optimized_brute_force(password, hash_type='sha256', use_common_passwords=True, use_dictionary=True, progress=gr.Progress()):
     start_time = time.time()
     total_attempts = 0
     chars = string.ascii_letters + string.digits + string.punctuation
     cpu_count = multiprocessing.cpu_count()
 
+    hash_function = getattr(hashlib, hash_type)
+    password_hash = hash_function(password.encode()).hexdigest()
+
+    # Feature 1: Common password check
+    if use_common_passwords:
+        common_passwords = ['123456', 'password', 'qwerty', 'admin', '123456789', '12345', '1234', '12345678', '111111', '1234567']
+        for common_pwd in common_passwords:
+            total_attempts += 1
+            if hash_function(common_pwd.encode()).hexdigest() == password_hash:
+                end_time = time.time()
+                return create_result_output(common_pwd, total_attempts, start_time, end_time, password)
+
+    # Feature 2: Dictionary attack
+    if use_dictionary:
+        with open('english_words.txt', 'r') as f:
+            dictionary_words = f.read().splitlines()
+        for word in dictionary_words:
+            total_attempts += 1
+            if hash_function(word.encode()).hexdigest() == password_hash:
+                end_time = time.time()
+                return create_result_output(word, total_attempts, start_time, end_time, password)
+
     for length in range(1, len(password) + 1):
         chunk_size = math.ceil(len(chars) ** length / cpu_count)
         manager = multiprocessing.Manager()
         progress_queue = manager.Queue()
         
         chunks = [
-            (chars, length, i * chunk_size, (i + 1) * chunk_size, password, i, progress_queue)
+            (chars, length, i * chunk_size, (i + 1) * chunk_size, password_hash, hash_function, i, progress_queue)
             for i in range(cpu_count)
         ]
 
@@ -56,21 +81,107 @@ def optimized_brute_force(password, progress=gr.Progress()):
             total_attempts += attempts
             if cracked:
                 end_time = time.time()
-                return f"Password cracked: {cracked}\nAttempts: {total_attempts:,}\nTime taken: {round((end_time - start_time) * 1000, 2)} ms"
+                return create_result_output(cracked, total_attempts, start_time, end_time, password)
 
     end_time = time.time()
-    return f"Password not found\nAttempts: {total_attempts:,}\nTime taken: {round((end_time - start_time) * 1000, 2)} ms"
+    return create_result_output(None, total_attempts, start_time, end_time, password)
+
+def create_result_output(cracked_password, attempts, start_time, end_time, original_password):
+    time_taken = round((end_time - start_time) * 1000, 2)
+    
+    output = []
+    if cracked_password:
+        output.append(f"Password cracked: {cracked_password}")
+    else:
+        output.append("Password not found")
+    
+    output.append(f"Attempts: {attempts:,}")
+    output.append(f"Time taken: {time_taken} ms")
+    
+    # Feature 3: Password strength evaluation
+    strength = zxcvbn.zxcvbn(original_password)
+    output.append(f"Password strength score: {strength['score']}/4")
+    output.append(f"Estimated guesses: {strength['guesses']:,}")
+    
+    # Feature 4: Entropy calculation
+    entropy = calculate_entropy(original_password)
+    output.append(f"Password entropy: {entropy:.2f} bits")
+    
+    # Feature 5: Suggestions for improvement
+    if strength['score'] < 3:
+        output.append("Suggestions for improvement:")
+        for suggestion in strength['feedback']['suggestions']:
+            output.append(f"- {suggestion}")
+    
+    return "\n".join(output)
+
+def calculate_entropy(password):
+    char_set = set(password)
+    return len(password) * math.log2(len(char_set))
+
+def generate_password(length=12, complexity='medium'):
+    if complexity == 'low':
+        chars = string.ascii_lowercase + string.digits
+    elif complexity == 'medium':
+        chars = string.ascii_letters + string.digits
+    else:
+        chars = string.ascii_letters + string.digits + string.punctuation
+    
+    return ''.join(random.choice(chars) for _ in range(length))
 
-def brute_force_interface(password):
-    return optimized_brute_force(password)
+def brute_force_interface(password, hash_type='sha256', use_common_passwords=True, use_dictionary=True):
+    return optimized_brute_force(password, hash_type, use_common_passwords, use_dictionary)
+
+def analyze_password(password):
+    strength = zxcvbn.zxcvbn(password)
+    entropy = calculate_entropy(password)
+    
+    output = [
+        f"Password strength score: {strength['score']}/4",
+        f"Estimated guesses: {strength['guesses']:,}",
+        f"Password entropy: {entropy:.2f} bits",
+    ]
+    
+    if strength['score'] < 3:
+        output.append("Suggestions for improvement:")
+        for suggestion in strength['feedback']['suggestions']:
+            output.append(f"- {suggestion}")
+    
+    return "\n".join(output)
 
 iface = gr.Interface(
     fn=brute_force_interface,
-    inputs=gr.Textbox(label="Enter password to crack"),
+    inputs=[
+        gr.Textbox(label="Enter password to crack"),
+        gr.Dropdown(choices=['md5', 'sha1', 'sha256', 'sha512'], label="Hash type", value='sha256'),
+        gr.Checkbox(label="Use common passwords", value=True),
+        gr.Checkbox(label="Use dictionary attack", value=True),
+    ],
+    outputs="text",
+    title="Advanced Brute-Force Password Cracker Simulator",
+    description="This simulator attempts to crack a given password using various methods. It utilizes multiple CPU cores for faster cracking. Note: This is for educational purposes only.",
+)
+
+password_analyzer = gr.Interface(
+    fn=analyze_password,
+    inputs=gr.Textbox(label="Enter password to analyze"),
     outputs="text",
-    title="Brute-Force Password Cracker Simulator",
-    description="This simulator attempts to crack a given password using a brute-force approach. It utilizes multiple CPU cores for faster cracking. Note: This is for educational purposes only and should not be used for malicious activities.",
+    title="Password Strength Analyzer",
+    description="Analyze the strength of a given password without attempting to crack it.",
 )
 
+password_generator = gr.Interface(
+    fn=generate_password,
+    inputs=[
+        gr.Slider(minimum=8, maximum=32, step=1, label="Password Length", value=12),
+        gr.Dropdown(choices=['low', 'medium', 'high'], label="Complexity", value='medium'),
+    ],
+    outputs=gr.Textbox(label="Generated Password"),
+    title="Secure Password Generator",
+    description="Generate a secure password based on specified length and complexity.",
+)
+
+demo = gr.TabbedInterface([iface, password_analyzer, password_generator], ["Brute-Force Simulator", "Password Analyzer", "Password Generator"])
+
 if __name__ == "__main__":
-    iface.launch()
+    demo.launch()