Cryptography Fundamentals for Cybersecurity Beginners

python3 -m venv .venv-zip-cracker
source .venv-zip-cracker/bin/activate
pip install --upgrade pip
pip install zipfile36 pyzipper numpy scikit-learn tqdm

#!/usr/bin/env python3
"""
ZIP File Handler
Handles encrypted ZIP file operations
"""

import zipfile
import pyzipper
import os
from typing import Optional

class ZIPFileHandler:
    def __init__(self, zip_path: str):
        self.zip_path = zip_path
        if not os.path.exists(zip_path):
            raise FileNotFoundError(f"ZIP file not found: {zip_path}")
    
    def test_password(self, password: str) -> bool:
        """Test if password is correct"""
        try:
            with pyzipper.AESZipFile(self.zip_path, 'r') as zf:
                zf.setpassword(password.encode())
                # Try to read first file
                file_list = zf.namelist()
                if file_list:
                    zf.read(file_list[0])
                return True
        except (RuntimeError, zipfile.BadZipFile):
            return False
        except Exception as e:
            # Other errors might indicate wrong password
            return False
    
    def get_file_info(self) -> dict:
        """Get information about the ZIP file"""
        info = {
            "file_count": 0,
            "encrypted": False,
            "compression": None,
            "total_size": 0
        }
        
        try:
            with zipfile.ZipFile(self.zip_path, 'r') as zf:
                info["file_count"] = len(zf.namelist())
                info["total_size"] = sum(f.file_size for f in zf.filelist)
                
                # Check if encrypted
                if zf.filelist:
                    info["encrypted"] = zf.filelist[0].flag_bits & 0x1
                    info["compression"] = zf.filelist[0].compress_type
        except Exception as e:
            print(f"Error reading ZIP info: {e}")
        
        return info
    
    def extract_with_password(self, password: str, extract_to: str = ".") -> bool:
        """Extract ZIP file with password"""
        try:
            with pyzipper.AESZipFile(self.zip_path, 'r') as zf:
                zf.setpassword(password.encode())
                zf.extractall(extract_to)
            return True
        except Exception as e:
            print(f"Extraction failed: {e}")
            return False

# Example: Create test encrypted ZIP
def create_test_zip(password: str = "test123", output_file: str = "test_encrypted.zip"):
    """Create a test encrypted ZIP file for demonstration"""
    test_content = b"This is test content for educational purposes."
    
    with pyzipper.AESZipFile(output_file, 'w', compression=pyzipper.ZIP_DEFLATED, encryption=pyzipper.WZ_AES) as zf:
        zf.setpassword(password.encode())
        zf.writestr("test_file.txt", test_content)
    
    print(f"Created test ZIP: {output_file} with password: {password}")
    return output_file

if __name__ == "__main__":
    # Create test file
    test_zip = create_test_zip("password123")
    
    # Test handler
    handler = ZIPFileHandler(test_zip)
    info = handler.get_file_info()
    print(f"ZIP Info: {info}")
    
    # Test password
    print(f"Testing password 'password123': {handler.test_password('password123')}")
    print(f"Testing password 'wrong': {handler.test_password('wrong')}")

#!/usr/bin/env python3
"""
Password Cracking Engine
Implements dictionary and brute force attacks
"""

from zip_handler import ZIPFileHandler
from tqdm import tqdm
import itertools
import string
from typing import List, Optional, Callable

class PasswordCracker:
    def __init__(self, zip_path: str):
        self.handler = ZIPFileHandler(zip_path)
        self.attempts = 0
        self.found_password = None
    
    def dictionary_attack(self, wordlist: List[str], max_attempts: Optional[int] = None) -> Optional[str]:
        """Try passwords from dictionary"""
        print(f"Starting dictionary attack with {len(wordlist)} passwords...")
        
        for password in tqdm(wordlist, desc="Testing passwords"):
            self.attempts += 1
            
            if self.handler.test_password(password):
                self.found_password = password
                print(f"\n✓ Password found: {password} (after {self.attempts} attempts)")
                return password
            
            if max_attempts and self.attempts >= max_attempts:
                print(f"\n✗ Stopped after {max_attempts} attempts")
                return None
        
        print(f"\n✗ Password not found in dictionary (tried {self.attempts} passwords)")
        return None
    
    def brute_force_attack(self, min_length: int = 1, max_length: int = 4, 
                          charset: str = string.ascii_lowercase + string.digits,
                          max_attempts: Optional[int] = None) -> Optional[str]:
        """Brute force attack with character set"""
        print(f"Starting brute force attack (length {min_length}-{max_length}, charset: {len(charset)} chars)...")
        
        for length in range(min_length, max_length + 1):
            total_combinations = len(charset) ** length
            print(f"Trying length {length} ({total_combinations} combinations)...")
            
            for attempt in tqdm(itertools.product(charset, repeat=length), 
                              total=total_combinations, desc=f"Length {length}"):
                password = ''.join(attempt)
                self.attempts += 1
                
                if self.handler.test_password(password):
                    self.found_password = password
                    print(f"\n✓ Password found: {password} (after {self.attempts} attempts)")
                    return password
                
                if max_attempts and self.attempts >= max_attempts:
                    print(f"\n✗ Stopped after {max_attempts} attempts")
                    return None
        
        print(f"\n✗ Password not found (tried {self.attempts} combinations)")
        return None
    
    def hybrid_attack(self, base_words: List[str], suffixes: List[str] = None, 
                     prefixes: List[str] = None, max_attempts: Optional[int] = None) -> Optional[str]:
        """Hybrid attack: dictionary + common modifications"""
        if suffixes is None:
            suffixes = ["123", "!", "2024", "1", "12"]
        if prefixes is None:
            prefixes = ["", "123", "!"]
        
        print(f"Starting hybrid attack (base words: {len(base_words)}, variations)...")
        
        variations = []
        for word in base_words:
            # Add word as-is
            variations.append(word)
            # Add suffixes
            for suffix in suffixes:
                variations.append(word + suffix)
            # Add prefixes
            for prefix in prefixes:
                if prefix:
                    variations.append(prefix + word)
        
        print(f"Generated {len(variations)} password variations")
        return self.dictionary_attack(variations, max_attempts)

# Example usage
if __name__ == "__main__":
    # Create test ZIP
    from zip_handler import create_test_zip
    test_zip = create_test_zip("cat123", "test.zip")
    
    # Try dictionary attack
    cracker = PasswordCracker(test_zip)
    
    wordlist = ["password", "123456", "cat", "dog", "test", "hello", "cat123"]
    result = cracker.dictionary_attack(wordlist)
    
    if result:
        print(f"Successfully cracked with password: {result}")

#!/usr/bin/env python3
"""
AI Password Prediction Model
Uses ML to predict likely passwords based on patterns
"""

import numpy as np
import pandas as pd
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
import joblib
import string
import re
from typing import List, Tuple

class AIPasswordPredictor:
    def __init__(self):
        self.model = None
        self.vectorizer = None
        self.is_trained = False
    
    def extract_features(self, password: str) -> List[float]:
        """Extract features from password"""
        features = [
            len(password),  # Length
            sum(1 for c in password if c.islower()),  # Lowercase count
            sum(1 for c in password if c.isupper()),  # Uppercase count
            sum(1 for c in password if c.isdigit()),  # Digit count
            sum(1 for c in password if c in string.punctuation),  # Special chars
            password.count('123'),  # Common patterns
            password.count('abc'),
            1 if any(word in password.lower() for word in ['password', 'pass', 'admin']) else 0,
            1 if re.search(r'\d+$', password) else 0,  # Ends with digits
            1 if re.search(r'^\d+', password) else 0,  # Starts with digits
        ]
        return features
    
    def train_on_breached_passwords(self, passwords: List[str], labels: List[int] = None):
        """Train model on breached password patterns"""
        if labels is None:
            # Auto-label: assume all are "likely" passwords
            labels = [1] * len(passwords)
        
        # Extract features
        X = np.array([self.extract_features(pwd) for pwd in passwords])
        y = np.array(labels)
        
        # Train model
        self.model = RandomForestClassifier(n_estimators=100, random_state=42)
        self.model.fit(X, y)
        self.is_trained = True
        
        print(f"Model trained on {len(passwords)} password patterns")
    
    def predict_likelihood(self, password: str) -> float:
        """Predict how likely a password is to be correct"""
        if not self.is_trained:
            return 0.5  # Default
        
        features = np.array([self.extract_features(password)])
        probability = self.model.predict_proba(features)[0][1]
        return probability
    
    def generate_candidate_passwords(self, base_words: List[str], top_n: int = 100) -> List[Tuple[str, float]]:
        """Generate candidate passwords ranked by likelihood"""
        candidates = []
        
        # Generate variations
        suffixes = ["", "123", "!", "1", "12", "2024", "2025"]
        prefixes = ["", "123", "!"]
        
        for word in base_words:
            for prefix in prefixes:
                for suffix in suffixes:
                    candidate = prefix + word + suffix
                    likelihood = self.predict_likelihood(candidate)
                    candidates.append((candidate, likelihood))
        
        # Sort by likelihood and return top N
        candidates.sort(key=lambda x: x[1], reverse=True)
        return candidates[:top_n]
    
    def save_model(self, model_file: str = "password_predictor.pkl"):
        """Save trained model"""
        if self.is_trained:
            joblib.dump(self.model, model_file)
            print(f"Model saved to {model_file}")
    
    def load_model(self, model_file: str = "password_predictor.pkl"):
        """Load trained model"""
        import os
        if os.path.exists(model_file):
            self.model = joblib.load(model_file)
            self.is_trained = True
            print(f"Model loaded from {model_file}")
            return True
        return False

# Example: Train on common passwords
if __name__ == "__main__":
    # Common breached passwords (educational dataset)
    common_passwords = [
        "password", "123456", "password123", "admin", "letmein",
        "welcome", "monkey", "1234567890", "qwerty", "abc123",
        "password1", "12345", "password123!", "admin123", "root"
    ]
    
    predictor = AIPasswordPredictor()
    predictor.train_on_breached_passwords(common_passwords)
    predictor.save_model()
    
    # Test predictions
    test_passwords = ["password123", "cat123", "securepass", "xyz789"]
    print("\nPassword Likelihood Predictions:")
    for pwd in test_passwords:
        likelihood = predictor.predict_likelihood(pwd)
        print(f"  {pwd}: {likelihood:.2%}")
    
    # Generate candidates
    candidates = predictor.generate_candidate_passwords(["cat", "dog"], top_n=10)
    print("\nTop Candidate Passwords:")
    for pwd, score in candidates:
        print(f"  {pwd}: {score:.2%}")

#!/usr/bin/env python3
"""
AI-Enhanced ZIP Password Cracker
Combines AI prediction with optimized cracking
"""

from zip_handler import ZIPFileHandler, create_test_zip
from password_cracker import PasswordCracker
from ai_password_predictor import AIPasswordPredictor
from tqdm import tqdm
import time

class AICracker:
    def __init__(self, zip_path: str):
        self.cracker = PasswordCracker(zip_path)
        self.predictor = AIPasswordPredictor()
        self.found_password = None
    
    def ai_guided_attack(self, base_words: List[str], max_attempts: int = 1000) -> str:
        """Use AI to prioritize password attempts"""
        print("🤖 Starting AI-guided password attack...")
        
        # Generate candidate passwords with AI ranking
        candidates = self.predictor.generate_candidate_passwords(base_words, top_n=max_attempts)
        
        print(f"Testing {len(candidates)} AI-ranked candidates...")
        
        for password, likelihood in tqdm(candidates, desc="AI-guided attack"):
            if self.cracker.handler.test_password(password):
                self.found_password = password
                print(f"\n✓ Password found: {password}")
                print(f"   AI likelihood: {likelihood:.2%}")
                print(f"   Total attempts: {self.cracker.attempts}")
                return password
        
        print(f"\n✗ Password not found in AI candidates")
        return None
    
    def multi_strategy_attack(self, base_words: List[str]) -> str:
        """Try multiple attack strategies"""
        print("🔓 Starting multi-strategy attack...\n")
        
        # Strategy 1: AI-guided attack
        print("Strategy 1: AI-Guided Attack")
        result = self.ai_guided_attack(base_words, max_attempts=500)
        if result:
            return result
        
        # Strategy 2: Dictionary attack
        print("\nStrategy 2: Dictionary Attack")
        wordlist = base_words + [w + "123" for w in base_words] + [w + "!" for w in base_words]
        result = self.cracker.dictionary_attack(wordlist)
        if result:
            return result
        
        # Strategy 3: Hybrid attack
        print("\nStrategy 3: Hybrid Attack")
        result = self.cracker.hybrid_attack(base_words)
        if result:
            return result
        
        print("\n✗ All strategies exhausted")
        return None

# Example usage
if __name__ == "__main__":
    # Initialize AI predictor with common passwords
    from ai_password_predictor import AIPasswordPredictor
    
    common_passwords = [
        "password", "123456", "password123", "admin", "letmein",
        "welcome", "monkey", "qwerty", "abc123", "password1"
    ]
    
    predictor = AIPasswordPredictor()
    predictor.train_on_breached_passwords(common_passwords)
    
    # Create test ZIP
    test_password = "cat123"
    test_zip = create_test_zip(test_password, "test_encrypted.zip")
    print(f"Created test ZIP with password: {test_password}\n")
    
    # Run AI-enhanced attack
    ai_cracker = AICracker(test_zip)
    ai_cracker.predictor = predictor
    
    base_words = ["cat", "dog", "password", "admin", "test"]
    result = ai_cracker.multi_strategy_attack(base_words)
    
    if result:
        print(f"\n✅ Successfully cracked! Password: {result}")
        # Extract files
        ai_cracker.cracker.handler.extract_with_password(result, "extracted")
        print("Files extracted to 'extracted' directory")
    else:
        print("\n❌ Failed to crack password")

#!/usr/bin/env python3
"""
Password Strength Checker and Prevention Methods
Helps create strong passwords that resist cracking
"""

import re
import string
import hashlib
import secrets

class PasswordStrengthChecker:
    @staticmethod
    def check_strength(password: str) -> dict:
        """Check password strength"""
        score = 0
        feedback = []
        
        # Length check
        if len(password) >= 12:
            score += 2
        elif len(password) >= 8:
            score += 1
        else:
            feedback.append("Password too short (minimum 8 characters)")
        
        # Character variety
        has_lower = bool(re.search(r'[a-z]', password))
        has_upper = bool(re.search(r'[A-Z]', password))
        has_digit = bool(re.search(r'\d', password))
        has_special = bool(re.search(r'[!@#$%^&*(),.?":{}|<>]', password))
        
        variety_score = sum([has_lower, has_upper, has_digit, has_special])
        score += variety_score
        
        if not has_lower:
            feedback.append("Add lowercase letters")
        if not has_upper:
            feedback.append("Add uppercase letters")
        if not has_digit:
            feedback.append("Add numbers")
        if not has_special:
            feedback.append("Add special characters")
        
        # Common patterns
        common_patterns = ["123", "abc", "password", "admin", "qwerty"]
        if any(pattern in password.lower() for pattern in common_patterns):
            score -= 2
            feedback.append("Avoid common patterns")
        
        # Entropy calculation
        charset_size = 0
        if has_lower:
            charset_size += 26
        if has_upper:
            charset_size += 26
        if has_digit:
            charset_size += 10
        if has_special:
            charset_size += len(string.punctuation)
        
        entropy = len(password) * (charset_size ** 0.5)
        
        # Strength rating
        if score >= 6 and entropy > 50:
            strength = "Strong"
        elif score >= 4:
            strength = "Medium"
        else:
            strength = "Weak"
        
        return {
            "strength": strength,
            "score": score,
            "entropy": entropy,
            "feedback": feedback,
            "length": len(password)
        }
    
    @staticmethod
    def generate_strong_password(length: int = 16) -> str:
        """Generate a strong random password"""
        charset = string.ascii_letters + string.digits + string.punctuation
        password = ''.join(secrets.choice(charset) for _ in range(length))
        return password
    
    @staticmethod
    def estimate_crack_time(password: str, attempts_per_second: int = 1_000_000_000) -> dict:
        """Estimate time to crack password"""
        charset_size = 0
        if re.search(r'[a-z]', password):
            charset_size += 26
        if re.search(r'[A-Z]', password):
            charset_size += 26
        if re.search(r'\d', password):
            charset_size += 10
        if re.search(r'[!@#$%^&*(),.?":{}|<>]', password):
            charset_size += len(string.punctuation)
        
        total_combinations = charset_size ** len(password)
        seconds = total_combinations / attempts_per_second
        
        # Convert to human-readable time
        if seconds < 60:
            time_str = f"{seconds:.2f} seconds"
        elif seconds < 3600:
            time_str = f"{seconds/60:.2f} minutes"
        elif seconds < 86400:
            time_str = f"{seconds/3600:.2f} hours"
        elif seconds < 31536000:
            time_str = f"{seconds/86400:.2f} days"
        else:
            time_str = f"{seconds/31536000:.2f} years"
        
        return {
            "total_combinations": total_combinations,
            "estimated_time": time_str,
            "seconds": seconds
        }

# Prevention recommendations
def print_prevention_guide():
    """Print prevention methods"""
    print("""
    🔒 PREVENTION METHODS FOR ZIP FILE ENCRYPTION
    
    1. Use Strong Passwords:
       - Minimum 12 characters
       - Mix of uppercase, lowercase, numbers, special characters
       - Avoid dictionary words and common patterns
       - Use password managers
    
    2. Use Strong Encryption:
       - AES-256 encryption (not legacy ZIP encryption)
       - Use tools like 7-Zip with AES encryption
    
    3. Additional Security:
       - Use two-factor authentication when possible
       - Encrypt files before adding to ZIP
       - Use secure file sharing methods
       - Regularly update encryption software
    
    4. Best Practices:
       - Never share passwords via email
       - Use unique passwords for each file
       - Consider using encrypted cloud storage
       - Implement access controls
    """)

if __name__ == "__main__":
    # Test password strength
    test_passwords = ["password123", "Cat123!", "MyStr0ng!P@ssw0rd", "xK9#mP2$vL7@qW4"]
    
    print("Password Strength Analysis:\n")
    for pwd in test_passwords:
        result = PasswordStrengthChecker.check_strength(pwd)
        print(f"Password: {pwd}")
        print(f"  Strength: {result['strength']}")
        print(f"  Score: {result['score']}/8")
        print(f"  Entropy: {result['entropy']:.1f}")
        if result['feedback']:
            print(f"  Feedback: {', '.join(result['feedback'])}")
        
        crack_time = PasswordStrengthChecker.estimate_crack_time(pwd)
        print(f"  Estimated crack time: {crack_time['estimated_time']}")
        print()
    
    # Generate strong password
    strong_pwd = PasswordStrengthChecker.generate_strong_password(16)
    print(f"Generated strong password: {strong_pwd}")
    print_prevention_guide()