app.py

import gradio as gr
import itertools
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_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:
            progress_queue.put((chunk_id, attempts))
        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, 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_hash, hash_function, i, progress_queue)
            for i in range(cpu_count)
        ]

        with multiprocessing.Pool(processes=cpu_count) as pool:
            results = pool.map_async(crack_chunk, chunks)
            
            chunk_progress = [0] * cpu_count
            while not results.ready():
                while not progress_queue.empty():
                    chunk_id, attempts = progress_queue.get()
                    chunk_progress[chunk_id] = attempts
                total_attempts = sum(chunk_progress)
                progress(total_attempts, desc=f"Trying {length}-character passwords")
                time.sleep(0.1)

            results = results.get()

        for attempts, cracked in results:
            total_attempts += attempts
            if cracked:
                end_time = time.time()
                return create_result_output(cracked, total_attempts, start_time, end_time, password)

    end_time = time.time()
    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, 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"),
        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="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__":
    demo.launch()