Password list generator, auto

password-list-generator-complete-main/LICENSE

@@ -0,0 +1,20 @@
+Copyright 2025 ysnrfd
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to use,
+copy, modify, and distribute the Software, subject to the following conditions:
+
+1. The copyright notice, this permission notice, and all attribution information
+   regarding the original author (ysnrfd) must be preserved in their entirety
+   and must not be removed, altered, or obscured in any copies or derivative works.
+
+2. Any modifications or derivative works must be clearly documented in a "CHANGELOG" or
+   "NOTICE" file included with the Software. This documentation must include a detailed
+   description of the changes made, the date of the modification, and the identity of
+   the modifier.
+
+3. The Software is provided "as is", without warranty of any kind, express or implied.
+   The author shall not be liable for any damages arising from use of the Software.
+
+4. Any attempt to remove or alter the original attribution or copyright information
+   constitutes a violation of this license and may result in legal action.

password-list-generator-complete-main/PLG_ysnrfd.py

@@ -0,0 +1,1769 @@
+import argparse
+import string
+import re
+import math
+import json
+import os
+import time
+import random
+import hashlib
+from datetime import datetime, timedelta
+from collections import Counter, defaultdict
+import nltk
+from nltk.corpus import wordnet as wn
+from nltk.probability import FreqDist
+import requests
+from tqdm import tqdm
+import pandas as pd
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics.pairwise import cosine_similarity
+import Levenshtein
+
+
+"""
+
+Developer: YSNRFD
+Telegram: @ysnrfd
+
+"""
+
+
+nltk.download('wordnet', quiet=True)
+nltk.download('punkt', quiet=True)
+LANGUAGE_DATA = {
+    'en': {
+        'name': 'English',
+        'common_words': ['love', 'password', 'welcome', 'admin', 'sunshine', 'dragon', 'monkey', 'football', 'baseball', 'letmein',
+                        'qwerty', 'trustno1', '123456', '12345678', 'baseball', 'football', '123456789', 'abc123', '1234567', 'monkey',
+                        'iloveyou', 'princess', 'admin123', 'welcome1', 'password1', 'qwerty123', '12345', '123123', '111111', 'abc123'],
+        'special_chars': ['@', '#', '$', '%', '&', '*', '!', '_', '.', '-'],
+        'number_patterns': ['1234', '12345', '123456', '1111', '2023', '2024', '0000', '123123', '7777', '9999', '123', '321', '01', '13', '23', '24', '99', '00'],
+        'cultural_events': ['Christmas', 'Halloween', 'Thanksgiving', 'Easter', 'New Year', 'Independence Day', 'Valentine', 'Super Bowl', 'Memorial Day', 'Labor Day', 'Cinco de Mayo', 'St. Patrick\'s Day', 'Mardi Gras', 'Fourth of July'],
+        'zodiac_signs': ['Aries', 'Taurus', 'Gemini', 'Cancer', 'Leo', 'Virgo', 'Libra', 'Scorpio', 'Sagittarius', 'Capricorn', 'Aquarius', 'Pisces', 'Ophiuchus'],
+        'celebrity_names': ['Beyonce', 'Taylor', 'Adele', 'Brad', 'Angelina', 'Elon', 'Oprah', 'Trump', 'Bieber', 'Ariana', 'Kardashian', 'Perry', 'Rihanna', 'Drake', 'Kanye', 'Kim', 'Zendaya', 'Tom', 'Jennifer', 'Leonardo'],
+        'sports_teams': ['Yankees', 'Cowboys', 'Lakers', 'Giants', 'Patriots', 'Warriors', 'Cubs', 'Eagles', 'Knicks', 'Rangers', 'Red Sox', 'Jets', 'Dolphins', 'Steelers', 'Packers', 'Broncos', 'Bears', 'Seahawks'],
+        'universities': ['Harvard', 'Yale', 'Stanford', 'MIT', 'Princeton', 'Columbia', 'Berkeley', 'UCLA', 'Oxford', 'Cambridge', 'Cornell', 'Duke', 'NYU', 'USC', 'Chicago', 'Penn', 'Brown', 'Dartmouth'],
+        'common_dates': ['0101', '1231', '0704', '1031', '1225', '0214', '0911', '1111', '0505', '0317'],
+        'leet_mappings': {
+            'a': ['@', '4', 'A', 'À', 'Á'],
+            'e': ['3', 'E', '&', '€', 'È', 'É'],
+            'i': ['1', '!', 'I', '|', 'Ì', 'Í'],
+            'o': ['0', 'O', '*', 'Ò', 'Ó'],
+            's': ['$', '5', 'S', 'Š', '§'],
+            't': ['+', '7', 'T', 'Ţ', 'Ť'],
+            'l': ['1', '|', 'L', '£', '₤'],
+            'g': ['9', '6', 'G', 'Ģ', 'Ĝ'],
+            'b': ['8', 'B', 'b', 'ß'],
+            'z': ['2', '7', 'Z', 'Ž']
+        },
+        'keyboard_patterns': [
+            'qwerty', 'asdfgh', 'zxcvbn', '123456', 'qazwsx', '1q2w3e', '123qwe',
+            'zaq12wsx', '1qaz2wsx', 'qwerasdf', '1234qwer', '!@#$%^&*()', '1q2w3e4r',
+            'qwe123', '123asd', 'qaz123', '1qazxsw', '1q2w3e4', 'qazxsw'
+        ],
+        'common_suffixes': ['123', '1234', '12345', '007', '2023', '2024', '!', '@', '#', '$', '%', '&', '*', '_', '.'],
+        'common_prefixes': ['my', 'i', 'the', 'new', 'old', 'super', 'mega', 'ultra', 'best', 'cool']
+    },
+    'de': {
+        'name': 'German',
+        'common_words': ['hallo', 'passwort', 'willkommen', 'admin', 'sonne', 'drache', 'affe', 'fussball', 'baseball', 'einfach',
+                        'qwertz', 'geheim1', '123456', '12345678', 'fussball', '123456789', 'abc123', '1234567', 'affe',
+                        'liebe', 'prinzessin', 'admin123', 'willkommen1', 'passwort1', 'qwertz123', '12345', '123123', '111111', 'abc123'],
+        'special_chars': ['@', '#', '$', '%', '&', '*', '!', '_', '.', '-'],
+        'number_patterns': ['1234', '12345', '123456', '1111', '2023', '2024', '0000', '123123', '7777', '9999', '123', '321', '01', '13', '18', '42', '77', '88'],
+        'cultural_events': ['Weihnachten', 'Halloween', 'Erntedank', 'Ostern', 'Neujahr', 'Tag der Deutschen Einheit', 'Valentinstag', 'Oktoberfest', 'Karneval', 'Silvester', 'Muttertag', 'Vatertag', 'Schützenfest'],
+        'zodiac_signs': ['Widder', 'Stier', 'Zwillinge', 'Krebs', 'Löwe', 'Jungfrau', 'Waage', 'Skorpion', 'Schütze', 'Steinbock', 'Wassermann', 'Fische', 'Schlangenträger'],
+        'celebrity_names': ['Angela', 'Merkel', 'Bundesliga', 'Bayern', 'Dortmund', 'Schumi', 'Schumacher', 'Lindemann', 'Rammstein', 'Klum', 'Helene', 'Fischer', 'Thomas', 'Gottschalk', 'Heidi', 'Klum', 'Böhmermann'],
+        'sports_teams': ['Bayern', 'Dortmund', 'Schalke', 'BVB', 'FCB', 'Werder', 'Hoffenheim', 'RB Leipzig', 'Bayer', 'Leverkusen', 'Hamburg', 'Frankfurt', 'Wolfsburg', 'Stuttgart', 'Union', 'Köln'],
+        'universities': ['LMU', 'TUM', 'Heidelberg', 'Humboldt', 'FU Berlin', 'KIT', 'RWTH', 'Goethe', 'Tübingen', 'Freiburg', 'Jena', 'Konstanz', 'Bonn', 'Halle', 'Marburg', 'Göttingen'],
+        'common_dates': ['0101', '1231', '1003', '3110', '2512', '1402', '0911', '1111', '1508', '0310'],
+        'leet_mappings': {
+            'a': ['@', '4', 'Ä', 'ä', 'Â'],
+            'e': ['3', 'E', '&', '€', 'È', 'É'],
+            'i': ['1', '!', 'I', '|', 'Ì', 'Í'],
+            'o': ['0', 'O', 'Ö', 'ö', 'Ò', 'Ó'],
+            's': ['$', '5', 'S', 'ß', 'Š', '§'],
+            't': ['+', '7', 'T', 'Ţ', 'Ť'],
+            'l': ['1', '|', 'L', '£', '₤'],
+            'g': ['9', '6', 'G', 'Ģ', 'Ĝ'],
+            'b': ['8', 'B', 'b', 'ß'],
+            'u': ['µ', 'ü', 'Ü']
+        },
+        'keyboard_patterns': [
+            'qwertz', 'asdfgh', 'yxcvbn', '123456', 'qaywsx', '1q2w3e', '123qwe',
+            'zaq12wsx', '1qaz2wsx', 'qwerasdf', '1234qwer', '!@#$%^&*()', '1q2w3e4r',
+            'qwe123', '123asd', 'qaz123', '1qazxsw', '1q2w3e4', 'qazxsw', 'qay123'
+        ],
+        'common_suffixes': ['123', '1234', '12345', '007', '2023', '2024', '!', '@', '#', '$', '%', '&', '*', '_', '.'],
+        'common_prefixes': ['mein', 'meine', 'der', 'die', 'das', 'super', 'mega', 'ultra', 'gut', 'cool']
+    },
+    'fa': {
+        'name': 'Persian',
+        'common_words': ['سلام', 'پسورد', 'خوش آمدید', 'مدیر', 'خورشید', 'اژدها', 'میمون', 'فوتبال', 'بیسبال', 'بگذار',
+                        '123456', '12345678', 'فوتبال', '123456789', 'abc123', '1234567', 'میمون',
+                        'عشق', 'شیرینی', 'admin123', 'خوش آمدید1', 'پسورد1', '12345', '123123', '111111', 'abc123'],
+        'special_chars': ['@', '#', '$', '%', '&', '*', '!', '_', '.', '-'],
+        'number_patterns': ['1234', '12345', '123456', '1111', '2023', '2024', '0000', '123123', '7777', '9999', '123', '321', '01', '13', '88', '99', '110', '313', '5', '7', '14', '22'],
+        'cultural_events': ['نوروز', 'تاسوعا', 'عاشورا', 'یلدا', 'عید نوروز', 'عید فطر', 'عید قربان', 'شب یلدا', 'سیزده به در', 'رحلت پیامبر', 'ولادت علی', 'عید سعید', 'عید ده', 'عید دو'],
+        'zodiac_signs': ['حمل', 'ثور', 'جوزا', 'سرطان', 'اسد', 'سنبله', 'میزان', 'عقرب', 'قوس', 'جدی', 'دلو', 'حوت', 'مارپیچ'],
+        'celebrity_names': ['محمد', 'رضا', 'احمد', 'علی', 'حسین', 'فاطمه', 'زهرا', 'شادی', 'پوریا', 'سحر', 'سارا', 'مریم', 'رضا', 'صدر', 'حسین', 'پور', 'خان', 'علوی', 'محمدی', 'حسینی'],
+        'sports_teams': ['استقلال', 'پرسپولیس', 'تراکتور', 'سپاهان', 'فولاد', 'ذوب آهن', 'سایپا', 'ملی', 'ملی ایران', 'سپاهان', 'ذوب', 'آهن', 'تراکتور', 'ذوب', 'سپاهان'],
+        'universities': ['تهران', 'شریف', 'امیرکبیر', 'صنعتی', 'شهید', 'بهشتی', 'فردوسی', 'مشهد', 'اصفهان', 'شیراز', 'عمران', 'مکانیک', 'علوم', 'پزشکی', 'تربیت'],
+        'common_dates': ['0101', '1231', '2103', '1302', '2206', '1402', '0911', '1111', '0104', '0102', '1102', '1301'],
+        'leet_mappings': {
+            'a': ['@', '4', 'آ', 'ا', 'أ'],
+            'i': ['1', '!', 'ی', 'ي', 'ئ'],
+            'o': ['0', '*', 'او', 'ؤ'],
+            's': ['$', '5', 'ث', 'س'],
+            'l': ['1', '|', 'ل', 'لـ'],
+            'g': ['9', '6', 'گ', 'گـ'],
+            'b': ['8', 'ب', 'بـ'],
+            'p': ['9', 'پ', 'پـ'],
+            't': ['7', 'ط', 'ت'],
+            'j': ['7', 'ج', 'چ']
+        },
+        'keyboard_patterns': [
+            'ضثص', 'شیس', 'آکل', '123456', 'ضشی', '1ض2ث3ص',
+            'ضشیثص', '1ض2ش3ی', 'ضثشی', '1234ضث', '!@#$%^&*()',
+            'ضصثق', 'یسش', 'آکل', '12345', 'ضشی', '1ض2ث3ص4',
+            'ضشیثص', '1ض2ش3ی', 'ضثشی', '1234ضث', 'ضثص123'
+        ],
+        'common_suffixes': ['123', '1234', '12345', '007', '2023', '2024', '!', '@', '#', '$', '%', '&', '*', '_', '.'],
+        'common_prefixes': ['من', 'منو', 'عشق', 'دوست', 'دوست دارم', 'مثل', 'خیلی', 'خیلیی', 'عزیزم', 'عزیزمم']
+    },
+    'fr': {
+        'name': 'French',
+        'common_words': ['bonjour', 'motdepasse', 'bienvenue', 'admin', 'soleil', 'dragon', 'singe', 'football', 'baseball', 'simple',
+                        'azerty', 'secret1', '123456', '12345678', 'football', '123456789', 'abc123', '1234567', 'singe',
+                        'amour', 'princesse', 'admin123', 'bienvenue1', 'motdepasse1', 'azerty123', '12345', '123123', '111111', 'abc123'],
+        'special_chars': ['@', '#', '$', '%', '&', '*', '!', '_', '.', '-'],
+        'number_patterns': ['1234', '12345', '123456', '1111', '2023', '2024', '0000', '123123', '7777', '9999', '123', '321', '01', '13', '14', '75', '89', '42', '18'],
+        'cultural_events': ['Noël', 'Halloween', 'Action de Grâce', 'Pâques', 'Nouvel An', 'Fête Nationale', 'Saint-Valentin', 'Tour de France', 'Bastille Day', 'La Fête de la Musique', 'Carnaval', 'Fête du Travail'],
+        'zodiac_signs': ['Bélier', 'Taureau', 'Gémeaux', 'Cancer', 'Lion', 'Vierge', 'Balance', 'Scorpion', 'Sagittaire', 'Capricorne', 'Verseau', 'Poissons', 'Ophiuchus'],
+        'celebrity_names': ['Zidane', 'Del Piero', 'Depardieu', 'Johnny', 'Hallyday', 'Sarkozy', 'Macron', 'Amelie', 'Poulain', 'Audrey', 'Tautou', 'Gad', 'Elkabbach', 'Deneuve'],
+        'sports_teams': ['PSG', 'OM', 'OL', 'Bayern', 'Real', 'Barça', 'Marseille', 'Lyon', 'Paris', 'Monaco', 'Saint-Étienne', 'Nantes', 'Lille', 'Lens'],
+        'universities': ['Sorbonne', 'Polytechnique', 'Sciences Po', 'HEC', 'ENS', 'Dauphine', 'Panthéon', 'Aix-Marseille', 'Lyon 2', 'Toulouse 1', 'Grenoble', 'Strasbourg'],
+        'common_dates': ['0101', '1231', '1407', '1111', '2512', '1402', '0911', '1111', '0104', '0102', '1107', '0803'],
+        'leet_mappings': {
+            'a': ['@', '4', 'À', 'Á', 'Â'],
+            'e': ['3', 'E', '€', 'È', 'É', 'Ê', 'Ë'],
+            'i': ['1', '!', 'I', '|', 'Ì', 'Í'],
+            'o': ['0', 'O', 'Ö', 'Ò', 'Ó'],
+            's': ['$', '5', 'S', 'Š'],
+            't': ['+', '7', 'T', 'Ţ'],
+            'l': ['1', '|', 'L', '£'],
+            'g': ['9', '6', 'G', 'Ĝ'],
+            'b': ['8', 'B', 'b']
+        },
+        'keyboard_patterns': [
+            'azerty', 'qsdfgh', 'wxcvbn', '123456', 'aqwzsx', '1&2é3"', '123&é"',
+            '1234az', 'qsdfaz', '1234qwer', '!@#$%^&*()', '1&2é34"',
+            'qwertz', '12345', '1q2w3e', '123qwe', 'qaz123', '1qazxsw'
+        ],
+        'common_suffixes': ['123', '1234', '12345', '007', '2023', '2024', '!', '@', '#', '$', '%', '&', '*', '_', '.'],
+        'common_prefixes': ['mon', 'ma', 'mes', 'le', 'la', 'les', 'super', 'mega', 'ultra', 'bon', 'bien']
+    },
+    'es': {
+        'name': 'Spanish',
+        'common_words': ['hola', 'contraseña', 'bienvenido', 'admin', 'sol', 'dragón', 'mono', 'fútbol', 'béisbol', 'fácil',
+                        'qwerty', 'secreto1', '123456', '12345678', 'fútbol', '123456789', 'abc123', '1234567', 'mono',
+                        'amor', 'princesa', 'admin123', 'bienvenido1', 'contraseña1', 'qwerty123', '12345', '123123', '111111', 'abc123'],
+        'special_chars': ['@', '#', '$', '%', '&', '*', '!', '_', '.', '-'],
+        'number_patterns': ['1234', '12345', '123456', '1111', '2023', '2024', '0000', '123123', '7777', '9999', '123', '321', '01', '13', '15', '80', '21', '99', '00'],
+        'cultural_events': ['Navidad', 'Halloween', 'Día de Acción de Gracias', 'Pascua', 'Año Nuevo', 'Día de la Independencia', 'San Valentín', 'Feria de Abril', 'San Fermín', 'Día de los Muertos', 'La Tomatina', 'Semana Santa'],
+        'zodiac_signs': ['Aries', 'Tauro', 'Géminis', 'Cáncer', 'Leo', 'Virgo', 'Libra', 'Escorpio', 'Sagitario', 'Capricornio', 'Acuario', 'Piscis', 'Ofiuco'],
+        'celebrity_names': ['Messi', 'Ronaldo', 'Beyoncé', 'Shakira', 'Piqué', 'García', 'Martínez', 'Rodríguez', 'Fernández', 'López', 'González', 'Pérez', 'Sánchez', 'Díaz'],
+        'sports_teams': ['Barça', 'Madrid', 'Atletico', 'Barcelona', 'Real', 'Madrid', 'Sevilla', 'Valencia', 'Atlético', 'Betis', 'Villarreal', 'Athletic', 'Espanyol', 'Málaga'],
+        'universities': ['Complutense', 'Autónoma', 'Politécnica', 'Barcelona', 'Sorbona', 'Salamanca', 'Granada', 'Sevilla', 'Valencia', 'Málaga', 'Santiago', 'Navarra'],
+        'common_dates': ['0101', '1231', '1207', '1508', '2512', '1402', '0911', '1111', '0104', '0102', '2802', '0208'],
+        'leet_mappings': {
+            'a': ['@', '4', 'Á', 'À'],
+            'e': ['3', 'E', '€', 'É', 'È'],
+            'i': ['1', '!', 'I', '|', 'Í', 'Ì'],
+            'o': ['0', 'O', 'Ö', 'Ó', 'Ò'],
+            's': ['$', '5', 'S', 'Š'],
+            't': ['+', '7', 'T'],
+            'l': ['1', '|', 'L', '£'],
+            'g': ['9', '6', 'G', 'Ĝ'],
+            'b': ['8', 'B', 'b']
+        },
+        'keyboard_patterns': [
+            'qwerty', 'asdfgh', 'zxcvbn', '123456', 'qwaszx', '1q2w3e', '123qwe',
+            'zaq12wsx', '1qaz2wsx', 'qwerasdf', '1234qwer', '!@#$%^&*()', '1q2w3e4r',
+            'qwe123', '123asd', 'qaz123', '1qazxsw', '1q2w3e4', 'qazxsw'
+        ],
+        'common_suffixes': ['123', '1234', '12345', '007', '2023', '2024', '!', '@', '#', '$', '%', '&', '*', '_', '.'],
+        'common_prefixes': ['mi', 'mis', 'el', 'la', 'los', 'las', 'super', 'mega', 'ultra', 'buen', 'bien']
+    }
+}
+CURRENT_LANGUAGE = 'en'
+class EthicalSafeguard:
+    def __init__(self):
+        self.usage_log = []
+        self.authorization_key = None
+        self.ethical_agreement = False
+        self.geolocation_verified = False
+        self.purpose_verified = False
+    def verify_ethical_usage(self):
+        print("\n🛡️  ETHICAL USAGE VERIFICATION REQUIRED")
+        print("This tool is strictly for educational and authorized security testing purposes only.")
+        try:
+            response = requests.get('https://ipapi.co/json/', timeout=5)
+            if response.status_code == 200:
+                geo_data = response.json()
+                country = geo_data.get('country', '').lower()
+                print(f"📍 Detected country: {geo_data.get('country_name', 'Unknown')}")
+                restricted_countries = ['cn', 'ru', 'kp', 'iq', 'ir', 'sy']
+                if country in restricted_countries:
+                    print(f"❌ Usage restricted in {geo_data['country_name']} due to local regulations")
+                    return False
+                self.geolocation_verified = True
+        except:
+            print("⚠️  Could not verify geolocation. Proceed with caution.")
+        print("\n📜 ETHICAL AGREEMENT:")
+        print("1. I confirm I have explicit written authorization to test the target system")
+        print("2. I understand that unauthorized access is illegal and unethical")
+        print("3. I will not use this tool for any malicious or unauthorized purpose")
+        print("4. I accept full responsibility for any consequences of my actions")
+        agree = input("\nDo you agree to these terms? (YES/NO): ").strip().upper()
+        if agree != "YES":
+            print("❌ Ethical agreement not accepted. Exiting...")
+            return False
+        self.ethical_agreement = True
+        print("\n🔍 PURPOSE VERIFICATION:")
+        print("Please describe the authorized purpose of this security test:")
+        purpose = input("> ").strip()
+        valid_purposes = [
+            'penetration testing', 'security assessment', 'vulnerability research', 
+            'educational purpose', 'authorized security test', 'red team exercise'
+        ]
+        if not any(p in purpose.lower() for p in valid_purposes):
+            print("❌ Purpose does not match authorized security testing. Exiting...")
+            return False
+        self.purpose_verified = True
+        timestamp = datetime.now().strftime("%Y%m%d%H%M%S")
+        random_str = ''.join(random.choices(string.ascii_uppercase + string.digits, k=8))
+        self.authorization_key = f"AUTH-{timestamp}-{random_str}"
+        self.usage_log.append({
+            'timestamp': datetime.now().isoformat(),
+            'agreement_accepted': True,
+            'purpose': purpose,
+            'authorization_key': self.authorization_key,
+            'geolocation_verified': self.geolocation_verified
+        })
+        print(f"\n✅ Ethical verification successful!")
+        print(f"🔑 Authorization Key: {self.authorization_key}")
+        print("⚠️  This key must be documented in your security testing report")
+        return True
+    def log_usage(self, passwords_generated, target_info):
+        usage_record = {
+            'timestamp': datetime.now().isoformat(),
+            'authorization_key': self.authorization_key,
+            'passwords_generated': passwords_generated,
+            'target_info_summary': {
+                'has_name': bool(target_info.get('first_name')),
+                'has_birthdate': bool(target_info.get('birthdate')),
+                'has_email': bool(target_info.get('email')),
+                'language': target_info.get('language', 'en')
+            },
+            'ethical_verification': {
+                'agreement': self.ethical_agreement,
+                'geolocation': self.geolocation_verified,
+                'purpose': self.purpose_verified
+            }
+        }
+        log_dir = os.path.join(os.path.expanduser("~"), ".security_tool_logs")
+        os.makedirs(log_dir, exist_ok=True)
+        log_file = os.path.join(log_dir, f"usage_log_{datetime.now().strftime('%Y%m%d')}.enc")
+        encrypted_log = hashlib.sha256(json.dumps(usage_record).encode()).hexdigest()
+        with open(log_file, 'a') as f:
+            f.write(encrypted_log + "\n")
+        return usage_record
+class UserBehaviorPredictor:
+    def __init__(self, info):
+        self.user_info = info
+        self.behavior_profile = self._build_behavior_profile()
+    def _build_behavior_profile(self):
+        profile = {
+            'security_awareness': 0.5,
+            'password_complexity_preference': 0.5,
+            'cultural_influence': 'moderate',
+            'emotional_attachment_level': 0.5,
+            'tech_savviness': 0.5
+        }
+        if self.user_info.get('password_change_frequency'):
+            try:
+                freq = int(self.user_info['password_change_frequency'])
+                profile['security_awareness'] = min(1.0, freq / 3)
+            except:
+                pass
+        tech_indicators = 0
+        if self.user_info.get('tech_savviness'):
+            try:
+                profile['tech_savviness'] = min(1.0, int(self.user_info['tech_savviness']) / 10)
+                tech_indicators += 1
+            except:
+                pass
+        if self.user_info.get('occupation') in ['developer', 'engineer', 'security', 'it']:
+            profile['tech_savviness'] = 0.8
+            tech_indicators += 1
+        if self.user_info.get('device_models'):
+            if any('iphone' in d.lower() or 'android' in d.lower() for d in self.user_info['device_models']):
+                profile['tech_savviness'] = max(profile['tech_savviness'], 0.3)
+                tech_indicators += 0.5
+        if tech_indicators > 1 or profile['tech_savviness'] > 0.6:
+            profile['password_complexity_preference'] = 0.7
+        else:
+            profile['password_complexity_preference'] = 0.3
+        nationality = self.user_info.get('nationality', '').lower()
+        if any(c in nationality for c in ['iran', 'persia', 'farsi']):
+            profile['cultural_influence'] = 'high'
+        elif any(c in nationality for c in ['usa', 'uk', 'canada', 'australia']):
+            profile['cultural_influence'] = 'low'
+        emotional_indicators = 0
+        if self.user_info.get('pets'):
+            emotional_indicators += len(self.user_info['pets']) * 0.2
+        if self.user_info.get('children'):
+            emotional_indicators += len(self.user_info['children']) * 0.3
+        if self.user_info.get('spouse'):
+            emotional_indicators += 0.3
+        profile['emotional_attachment_level'] = min(1.0, emotional_indicators)
+        return profile
+    def predict_password_patterns(self):
+        patterns = {
+            'structure': [],
+            'transformations': [],
+            'common_elements': [],
+            'avoided_patterns': []
+        }
+        security_awareness = self.behavior_profile['security_awareness']
+        if security_awareness < 0.3:
+            patterns['structure'] = [
+                '{name}{birth_year}', 
+                '{pet}{number}',
+                '{favorite}{special}{number}',
+                '{name}{birth_day}{birth_month}',
+                '{pet}{birth_year}',
+                '{child}{number}'
+            ]
+            patterns['avoided_patterns'] = ['{complex_mixture}', '{random_caps}']
+        elif security_awareness < 0.6:
+            patterns['structure'] = [
+                '{name}{special}{birth_year}',
+                '{pet}{number}{special}',
+                '{word}{number}{special}',
+                '{name}{birth_year}{special}',
+                '{pet}{birth_year}',
+                '{spouse}{number}',
+                '{child}{special}{number}'
+            ]
+            patterns['transformations'] = ['add_number', 'add_special', 'capitalize', 'simple_leet']
+        elif security_awareness < 0.8:
+            patterns['structure'] = [
+                '{word1}{special}{word2}{number}',
+                '{word}{special}{number}{special}',
+                '{name}{pet}{number}',
+                '{zodiac}{number}',
+                '{cultural_event}{number}'
+            ]
+            patterns['transformations'] = ['leet_speak', 'camel_case', 'random_caps', 'add_special']
+        else:
+            patterns['structure'] = [
+                '{random_mixture}',
+                '{complex_pattern}',
+                '{word1}{word2}{number}{special}',
+                '{cultural_event}{zodiac}{number}'
+            ]
+            patterns['transformations'] = ['complex_leet', 'random_caps', 'spinal_case', 'hex_encoding']
+        
+        tech_savviness = self.behavior_profile['tech_savviness']
+        if tech_savviness > 0.8:
+            patterns['transformations'].extend(['hex_encoding', 'base64_patterns', 'unicode_mixing'])
+            patterns['common_elements'].extend(['tech_terms', 'crypto_terms'])
+        
+        emotional_level = self.behavior_profile['emotional_attachment_level']
+        if emotional_level > 0.8:
+            patterns['structure'].insert(0, '{pet}{child}{special}{number}')
+            patterns['structure'].insert(0, '{spouse}{pet}{number}')
+            patterns['structure'].insert(0, '{child}{birth_year}')
+        
+        cultural_influence = self.behavior_profile['cultural_influence']
+        if cultural_influence == 'high':
+            patterns['common_elements'].extend(['cultural_events', 'zodiac', 'national_holidays'])
+            if self.user_info.get('nationality', '').lower() in ['iran', 'persia', 'farsi']:
+                patterns['structure'].extend(['{cultural_event}{number}', '{zodiac}{number}'])
+        
+        current_year = datetime.now().year
+        if self.user_info.get('birth_year'):
+            birth_year = int(self.user_info['birth_year'])
+            age = current_year - birth_year
+            if 13 <= age <= 25:
+                patterns['common_elements'].append('pop_culture')
+            elif 26 <= age <= 40:
+                patterns['common_elements'].append('family_elements')
+            elif age > 40:
+                patterns['common_elements'].append('nostalgic_elements')
+        
+        return patterns
+    def get_password_generation_weights(self):
+        weights = {
+            'personal_info': 0.7,
+            'dates': 0.8,
+            'pets': 0.9,
+            'children': 0.95,
+            'spouse': 0.92,
+            'interests': 0.6,
+            'cultural': 0.5,
+            'keyboard': 0.3,
+            'common': 0.2,
+            'tech_terms': 0.4,
+            'crypto_terms': 0.3
+        }
+        if self.behavior_profile['emotional_attachment_level'] > 0.7:
+            weights['pets'] = 0.95
+            weights['children'] = 0.95
+            weights['spouse'] = 0.92
+            weights['anniversary'] = 0.93
+        if self.behavior_profile['security_awareness'] < 0.4:
+            weights['dates'] = 0.9
+            weights['personal_info'] = 0.85
+        elif self.behavior_profile['security_awareness'] > 0.7:
+            weights['keyboard'] = 0.6
+            weights['common'] = 0.4
+            weights['tech_terms'] = 0.7
+        if self.behavior_profile['cultural_influence'] == 'high':
+            weights['cultural'] = 0.75
+        return weights
+class PasswordEntropyAnalyzer:
+    def __init__(self, language='en'):
+        self.language = language
+        self.lang_data = LANGUAGE_DATA.get(language, LANGUAGE_DATA['en'])
+        self.common_patterns = [
+            r'(?:password|pass|1234|qwerty|admin|login|welcome|123456|111111|iloveyou)',
+            r'(\d{4})\1', r'(.)\1{2,}', 
+            r'(abc|bcd|cde|def|efg|fgh|ghi|hij|ijk|jkl|klm|lmn|mno|nop|opq|pqr|qrs|rst|stu|uvw|vwx|wxy|xyz)'
+        ]
+        self.dictionary_words = set()
+        self.dictionary_words.update(LANGUAGE_DATA[language]['common_words'])
+        for w in wn.all_lemma_names():
+            if len(w) > 3:
+                self.dictionary_words.add(w.lower())
+        self.dictionary_words.update([
+            'christmas', 'halloween', 'thanksgiving', 'easter', 'newyear', 'valentine',
+            'yankees', 'cowboys', 'lakers', 'giants', 'patriots', 'warriors',
+            'harvard', 'yale', 'stanford', 'mit', 'princeton', 'columbia',
+            'superbowl', 'eagles', 'knicks', 'rangers', 'redsox'
+        ])
+    def calculate_entropy(self, password):
+        if not password:
+            return 0
+        char_space = 0
+        if any(c.islower() for c in password): char_space += 26
+        if any(c.isupper() for c in password): char_space += 26
+        if any(c.isdigit() for c in password): char_space += 10
+        if any(c in string.punctuation for c in password): char_space += len(string.punctuation)
+        freq = Counter(password)
+        entropy = -sum((count / len(password)) * math.log2(count / len(password)) for count in freq.values())
+        for pattern in self.common_patterns:
+            if re.search(pattern, password.lower()):
+                entropy *= 0.2
+        keyboard_walks = self.lang_data['keyboard_patterns']
+        for walk in keyboard_walks:
+            if walk in password.lower():
+                entropy *= 0.3
+        for word in self.dictionary_words:
+            if word in password.lower() and len(word) > 3:
+                entropy *= 0.4
+        complexity_bonus = 1.0
+        if (any(c.islower() for c in password) and any(c.isupper() for c in password)):
+            complexity_bonus += 0.2
+        if any(c.isdigit() for c in password):
+            complexity_bonus += 0.15
+        if any(c in string.punctuation for c in password):
+            complexity_bonus += 0.25
+        if re.search(r'\d{4}', password) and any(c.isalpha() for c in password):
+            complexity_bonus += 0.1
+        entropy *= complexity_bonus
+        length_bonus = min(1.0, len(password) / 16) * 0.4
+        entropy *= (1 + length_bonus)
+        return round(entropy * len(password), 2)
+    def analyze_password_patterns(self, password):
+        analysis = {
+            'length': len(password),
+            'has_upper': any(c.isupper() for c in password),
+            'has_lower': any(c.islower() for c in password),
+            'has_digit': any(c.isdigit() for c in password),
+            'has_special': any(c in string.punctuation for c in password),
+            'digit_count': sum(1 for c in password if c.isdigit()),
+            'special_count': sum(1 for c in password if c in string.punctuation),
+            'repeated_chars': self._detect_repeated_chars(password),
+            'keyboard_patterns': self._detect_keyboard_patterns(password),
+            'common_words': self._detect_common_words(password),
+            'cultural_patterns': self._detect_cultural_patterns(password),
+            'entropy': self.calculate_entropy(password)
+        }
+        return analysis
+    def _detect_repeated_chars(self, password):
+        repeats = []
+        for match in re.finditer(r'(.)\1{2,}', password):
+            repeats.append({
+                'char': match.group(1),
+                'count': len(match.group(0)),
+                'position': match.start()
+            })
+        return repeats
+    def _detect_keyboard_patterns(self, password):
+        patterns = []
+        password_lower = password.lower()
+        keyboard_layouts = {
+            'qwerty': [
+                'qwertyuiop', 'asdfghjkl', 'zxcvbnm',
+                '1234567890', '!@#$%^&*()'
+            ],
+            'qwertz': [
+                'qwertzuiop', 'asdfghjkl', 'yxcvbnm',
+                '1234567890', '!@#$%^&*()'
+            ],
+            'azerty': [
+                'azertyuiop', 'qsdfghjklm', 'wxcvbn',
+                '1234567890', '&é"\'(-è_çà)'
+            ],
+            'dvorak': [
+                'pyfgcrl', 'aoeuidhtns', 'qjkxbmwvz',
+                '1234567890', '!@#$%^&*()'
+            ]
+        }
+        likely_layout = 'qwerty'
+        if 'z' in password_lower and 'w' in password_lower and 'x' in password_lower:
+            likely_layout = 'qwertz'
+        elif 'a' in password_lower and 'z' in password_lower and 'q' in password_lower:
+            likely_layout = 'azerty'
+        elif 'p' in password_lower and 'y' in password_lower and 'f' in password_lower:
+            likely_layout = 'dvorak'
+        layout = keyboard_layouts.get(likely_layout, keyboard_layouts['qwerty'])
+        for row in layout:
+            for i in range(len(row)):
+                for j in range(i+3, min(i+10, len(row)+1)):
+                    segment = row[i:j]
+                    if segment in password_lower:
+                        patterns.append({
+                            'pattern': segment,
+                            'type': f'{likely_layout}_horizontal',
+                            'length': len(segment),
+                            'layout': likely_layout
+                        })
+        vertical_sequences = []
+        for col_idx in range(min(len(row) for row in layout if len(row) > 0)):
+            col_chars = []
+            for row in layout:
+                if col_idx < len(row):
+                    col_chars.append(row[col_idx])
+            col_str = ''.join(col_chars)
+            if len(col_str) >= 3:
+                vertical_sequences.append(col_str)
+        for seq in vertical_sequences:
+            for i in range(len(seq)):
+                for j in range(i+3, min(i+8, len(seq)+1)):
+                    segment = seq[i:j]
+                    if segment in password_lower:
+                        patterns.append({
+                            'pattern': segment,
+                            'type': f'{likely_layout}_vertical',
+                            'length': len(segment),
+                            'layout': likely_layout
+                        })
+        diagonal_sequences = []
+        for start_row in range(len(layout)):
+            for start_col in range(len(layout[start_row])):
+                diag_chars = []
+                row, col = start_row, start_col
+                while row < len(layout) and col < len(layout[row]):
+                    diag_chars.append(layout[row][col])
+                    row += 1
+                    col += 1
+                if len(diag_chars) >= 3:
+                    diagonal_sequences.append(''.join(diag_chars))
+        for start_row in range(len(layout)):
+            for start_col in range(len(layout[start_row])):
+                diag_chars = []
+                row, col = start_row, start_col
+                while row < len(layout) and col >= 0:
+                    if col < len(layout[row]):
+                        diag_chars.append(layout[row][col])
+                    row += 1
+                    col -= 1
+                if len(diag_chars) >= 3:
+                    diagonal_sequences.append(''.join(diag_chars))
+        for seq in diagonal_sequences:
+            for i in range(len(seq)):
+                for j in range(i+3, min(i+8, len(seq)+1)):
+                    segment = seq[i:j]
+                    if segment in password_lower:
+                        patterns.append({
+                            'pattern': segment,
+                            'type': f'{likely_layout}_diagonal',
+                            'length': len(segment),
+                            'layout': likely_layout
+                        })
+        spiral_patterns = [
+            'q2we43', 'qaz2sx3ed', '1qaz2wsx', 'zaq12wsx',
+            'qscde32', 'qwe321', '123edc', 'asdf432',
+            'q1a2z3', 'q12w3e', '1q2w3e4r', '123qwe',
+            '1234qwer', 'qwer4321', '123456', '654321'
+        ]
+        for pattern in spiral_patterns:
+            if pattern in password_lower:
+                patterns.append({
+                    'pattern': pattern,
+                    'type': 'spiral',
+                    'length': len(pattern),
+                    'layout': likely_layout
+                })
+        return patterns
+    def _detect_common_words(self, password):
+        matches = []
+        password_lower = password.lower()
+        for word in self.dictionary_words:
+            if word in password_lower and len(word) > 3:
+                matches.append({
+                    'word': word,
+                    'position': password_lower.find(word),
+                    'length': len(word)
+                })
+        return matches
+    def _detect_cultural_patterns(self, password):
+        patterns = []
+        password_lower = password.lower()
+        for event in self.lang_data['cultural_events']:
+            if event.lower() in password_lower:
+                patterns.append({
+                    'pattern': event,
+                    'type': 'cultural_event',
+                    'relevance': 0.8
+                })
+        for sign in self.lang_data['zodiac_signs']:
+            if sign.lower() in password_lower:
+                patterns.append({
+                    'pattern': sign,
+                    'type': 'zodiac',
+                    'relevance': 0.7
+                })
+        for team in self.lang_data['sports_teams']:
+            if team.lower() in password_lower:
+                patterns.append({
+                    'pattern': team,
+                    'type': 'sports_team',
+                    'relevance': 0.6
+                })
+        for university in self.lang_data['universities']:
+            if university.lower() in password_lower:
+                patterns.append({
+                    'pattern': university,
+                    'type': 'university',
+                    'relevance': 0.5
+                })
+        for pattern in self.lang_data['number_patterns']:
+            if pattern in password:
+                patterns.append({
+                    'pattern': pattern,
+                    'type': 'number_pattern',
+                    'relevance': 0.4
+                })
+        if self.language == 'fa':
+            persian_patterns = {
+                'religious': ['روز', 'عید', 'نماز', 'قرآن', 'حاج', 'سجاد', 'حسین', 'فاطمه', 'زهره', 'عاشورا', 'نوروز', 'یلدا'],
+                'national': ['ایران', 'تهران', 'شهید', 'نظام', 'انقلاب', 'آزادی', 'سپاه', 'بدر', 'قادسیه', 'پارس', 'شیراز']
+            }
+            for category, words in persian_patterns.items():
+                for word in words:
+                    if word.lower() in password_lower:
+                        patterns.append({
+                            'pattern': word,
+                            'type': f'persian_{category}',
+                            'relevance': 0.7 if category == 'religious' else 0.6
+                        })
+        elif self.language == 'de':
+            german_patterns = {
+                'cultural': ['oktoberfest', 'bier', 'wurst', 'bayern', 'berlin', 'deutschland', 'karneval'],
+                'historical': ['mauer', 'berliner', 'euro', 'dm', 'pfennig', 'reich', 'wiedervereinigung']
+            }
+            for category, words in german_patterns.items():
+                for word in words:
+                    if word.lower() in password_lower:
+                        patterns.append({
+                            'pattern': word,
+                            'type': f'german_{category}',
+                            'relevance': 0.6
+                        })
+        elif self.language == 'fr':
+            french_patterns = {
+                'cultural': ['tour', 'eiffel', 'paris', 'baguette', 'fromage', 'vin', 'bastille'],
+                'historical': ['revolution', 'napoleon', 'berlin', 'liberté', 'fraternité', 'egalité']
+            }
+            for category, words in french_patterns.items():
+                for word in words:
+                    if word.lower() in password_lower:
+                        patterns.append({
+                            'pattern': word,
+                            'type': f'french_{category}',
+                            'relevance': 0.6
+                        })
+        elif self.language == 'es':
+            spanish_patterns = {
+                'cultural': ['flamenco', 'paella', 'toro', 'fiesta', 'barça', 'madrid', 'tomatina'],
+                'historical': ['inquisicion', 'colombus', 'espana', 'reconquista', 'cervantes']
+            }
+            for category, words in spanish_patterns.items():
+                for word in words:
+                    if word.lower() in password_lower:
+                        patterns.append({
+                            'pattern': word,
+                            'type': f'spanish_{category}',
+                            'relevance': 0.6
+                        })
+        return patterns
+class ContextualPasswordGenerator:
+    def __init__(self, language='en'):
+        self.language = language
+        self.lang_data = LANGUAGE_DATA.get(language, LANGUAGE_DATA['en'])
+        self.entropy_analyzer = PasswordEntropyAnalyzer(language)
+        self.context_weights = self._initialize_context_weights()
+        self.context_info = {}
+    def _initialize_context_weights(self):
+        return {
+            'personal_info': 0.8,
+            'dates': 0.9,
+            'pets': 0.7,
+            'children': 0.8,
+            'spouse': 0.75,
+            'interests': 0.6,
+            'cultural': 0.5,
+            'keyboard': 0.4,
+            'common': 0.3,
+            'tech_terms': 0.4,
+            'crypto_terms': 0.3
+        }
+    def _calculate_relevance_score(self, info, element, category):
+        score = self.context_weights.get(category, 0.5)
+        psychological_factors = {
+            'emotional_value': 0.0,
+            'temporal_relevance': 0.0,
+            'cognitive_load': 0.0,
+            'length_factor': 0.0
+        }
+        emotional_keywords = {
+            'pet': 0.85, 'child': 0.92, 'spouse': 0.88, 'anniversary': 0.75,
+            'favorite': 0.78, 'love': 0.95, 'heart': 0.82, 'baby': 0.90, 'soulmate': 0.93
+        }
+        if isinstance(element, str):
+            element_lower = element.lower()
+            for keyword, value in emotional_keywords.items():
+                if keyword in element_lower or category == keyword:
+                    psychological_factors['emotional_value'] = max(
+                        psychological_factors['emotional_value'], value
+                    )
+            current_year = datetime.now().year
+            if re.search(r'\d{4}', element):
+                year_match = re.search(r'(\d{4})', element)
+                if year_match:
+                    year = int(year_match.group(1))
+                    if abs(current_year - year) <= 2:
+                        psychological_factors['temporal_relevance'] = 0.7
+                    elif year == int(info.get('birth_year', 0)):
+                        psychological_factors['temporal_relevance'] = 0.9
+            if 3 <= len(element) <= 8:
+                psychological_factors['cognitive_load'] = 0.6
+            elif 9 <= len(element) <= 12:
+                psychological_factors['cognitive_load'] = 0.3
+            else:
+                psychological_factors['cognitive_load'] = 0.1
+            if 8 <= len(element) <= 12:
+                psychological_factors['length_factor'] = 0.8
+            elif 6 <= len(element) <= 14:
+                psychological_factors['length_factor'] = 0.6
+            else:
+                psychological_factors['length_factor'] = 0.2
+        emotional_weight = 0.35
+        temporal_weight = 0.20
+        cognitive_weight = 0.20
+        length_weight = 0.25
+        psychological_score = (
+            psychological_factors['emotional_value'] * emotional_weight +
+            psychological_factors['temporal_relevance'] * temporal_weight +
+            (1 - psychological_factors['cognitive_load']) * cognitive_weight +
+            psychological_factors['length_factor'] * length_weight
+        )
+        final_score = (score * 0.5) + (psychological_score * 0.5)
+        if category in ['pets', 'children', 'spouse', 'favorite_numbers', 'anniversary']:
+            final_score *= 1.3
+        if category in ['common', 'keyboard'] and info.get('password_patterns') and 'complex' in info['password_patterns']:
+            final_score *= 0.6
+        return min(1.0, max(0.2, final_score))
+    def _apply_leet_transformations(self, text):
+        if not text or len(text) < 3:
+            return [text]
+        results = set([text])
+        text_lower = text.lower()
+        target_language = self.language
+        if 'nationality' in self.context_info:
+            nationality_to_lang = {
+                'usa': 'en', 'united states': 'en', 'america': 'en',
+                'uk': 'en', 'united kingdom': 'en', 'britain': 'en',
+                'germany': 'de', 'deutschland': 'de', 'deutsch': 'de',
+                'france': 'fr', 'français': 'fr', 'france': 'fr',
+                'spain': 'es', 'españa': 'es', 'spanish': 'es',
+                'iran': 'fa', 'persian': 'fa', 'farsi': 'fa'
+            }
+            nationality = self.context_info['nationality'].lower()
+            for key, lang in nationality_to_lang.items():
+                if key in nationality:
+                    target_language = lang
+                    break
+        language_specific_leet = {
+            'en': {'a': ['@', '4'], 'e': ['3', '&'], 'i': ['1', '!'], 'o': ['0', '*'], 's': ['$', '5']},
+            'de': {'a': ['@', '4', 'ä'], 'e': ['3', '&'], 'i': ['1', '!'], 'o': ['0', '*'], 's': ['$', '5', 'ß']},
+            'fr': {'a': ['@', '4', 'à', 'â'], 'e': ['3', '&', 'é', 'è', 'ê'], 'c': ['(', '©']},
+            'es': {'a': ['@', '4', 'á'], 'e': ['3', '&', 'é'], 'o': ['0', '*', 'ó']},
+            'fa': {'a': ['@', '4', 'آ', 'ا'], 'i': ['1', '!', 'ی'], 'o': ['0', '*', 'او']}
+        }
+        leet_mappings = language_specific_leet.get(target_language, 
+                                                self.lang_data['leet_mappings'])
+        birth_year = self.context_info.get('birth_year', '')
+        if birth_year and len(birth_year) == 4:
+            year_suffix = birth_year[2:]
+            results.add(text + year_suffix)
+            results.add(year_suffix + text)
+            if len(year_suffix) == 2:
+                results.add(text + year_suffix + '!')
+                results.add(text + year_suffix + '@')
+        email = self.context_info.get('email', '')
+        if '@' in email:
+            domain = email.split('@')[1].split('.')[0]
+            if domain and len(domain) > 2:
+                results.add(text + '@' + domain)
+                results.add(domain + '@' + text)
+        base_transformations = []
+        for i, char in enumerate(text_lower):
+            if char in leet_mappings:
+                position_factor = 0.7 if 1 < i < len(text_lower) - 2 else 0.9
+                if random.random() < position_factor:
+                    for replacement in leet_mappings[char]:
+                        new_text = text_lower[:i] + replacement + text_lower[i+1:]
+                        base_transformations.append(new_text)
+        if len(text) > 5:
+            for _ in range(min(5, len(base_transformations))):
+                if len(base_transformations) > 1:
+                    base = random.choice(base_transformations)
+                    for i, char in enumerate(base):
+                        if char.isalpha() and char in leet_mappings and random.random() < 0.4:
+                            for replacement in leet_mappings[char]:
+                                new_text = base[:i] + replacement + base[i+1:]
+                                base_transformations.append(new_text)
+                                break
+        special_chars = self.lang_data['special_chars']
+        if target_language == 'fa':
+            special_chars += ['_', 'ـ', '•']
+        for char in special_chars[:3]:
+            results.add(text + char)
+            results.add(char + text)
+            if len(text) > 4:
+                results.add(text[:len(text)//2] + char + text[len(text)//2:])
+        cultural_numbers = {
+            'en': ['1', '7', '13', '21', '23', '69', '123', '2023', '2024'],
+            'de': ['7', '13', '18', '42', '77', '88', '123', '2023', '2024'],
+            'fr': ['7', '13', '17', '21', '42', '89', '123', '2023', '2024'],
+            'es': ['7', '10', '13', '21', '99', '123', '2023', '2024'],
+            'fa': ['5', '7', '14', '22', '88', '99', '110', '123', '2023', '2024']
+        }
+        numbers = cultural_numbers.get(target_language, ['1', '7', '13', '21', '99', '123'])
+        for num in numbers:
+            results.add(text + num)
+            results.add(num + text)
+            if len(text) > 4:
+                results.add(text[:3] + num + text[3:])
+        if len(text) > 3:
+            results.add(text.capitalize())
+            results.add(text.upper())
+            results.add(text.lower())
+            if len(text) > 5:
+                camel_case = text[0].lower() + text[1].upper() + text[2:]
+                results.add(camel_case)
+        return list(set(results))[:15]
+    def _generate_weighted_combinations(self, info, count, min_length, max_length):
+        self.context_info = info
+        weighted_elements = []
+        behavioral_categories = {
+            'high_emotional': ['pets', 'children', 'spouse', 'anniversary', 'favorite_things'],
+            'medium_emotional': ['hobbies', 'sports', 'music', 'cars', 'food', 'books'],
+            'low_emotional': ['job_title', 'employer', 'school', 'uni', 'location'],
+            'temporal': ['birth_year', 'grad_year', 'grad_year_uni', 'favorite_numbers', 'current_year'],
+            'cultural': ['cultural_events', 'zodiac', 'national_holidays']
+        }
+        for category, keys in behavioral_categories.items():
+            for key in keys:
+                if key in info:
+                    items = info[key]
+                    if not isinstance(items, list):
+                        items = [items]
+                    for item in items:
+                        if item and isinstance(item, str) and len(item) >= 2:
+                            if category == 'high_emotional':
+                                weight = 0.95
+                            elif category == 'medium_emotional':
+                                weight = 0.75
+                            elif category == 'temporal':
+                                weight = 0.8
+                                if re.search(r'\d{4}', item):
+                                    year = int(re.search(r'\d{4}', item).group())
+                                    current_year = datetime.now().year
+                                    weight = 0.9 - (current_year - year) * 0.05
+                                    weight = max(0.4, weight)
+                            elif category == 'cultural':
+                                weight = 0.65
+                                if 'nationality' in info:
+                                    nat = info['nationality'].lower()
+                                    if (self.language == 'fa' and ('iran' in nat or 'persia' in nat)) or \
+                                       (self.language == 'de' and ('german' in nat or 'germany' in nat)) or \
+                                       (self.language == 'fr' and ('french' in nat or 'france' in nat)) or \
+                                       (self.language == 'es' and ('spanish' in nat or 'spain' in nat)):
+                                        weight = 0.85
+                            else:
+                                weight = 0.5
+                            length_factor = 0.5
+                            if min_length <= len(item) <= max_length:
+                                length_factor = 1.0
+                            elif len(item) < min_length:
+                                length_factor = 0.7
+                            weight *= length_factor
+                            weighted_elements.append((item, category, weight))
+        weighted_elements.sort(key=lambda x: (
+            x[2] * (1.0 if min_length <= len(x[0]) <= max_length else 0.7),
+            -abs(len(x[0]) - (min_length + max_length) / 2)
+        ), reverse=True)
+        passwords = set()
+        for item, category, weight in weighted_elements:
+            if weight > 0.6:
+                cultural_numbers = self._get_cultural_numbers(info)
+                for num in cultural_numbers[:3]:
+                    pwd = f"{item}{num}"
+                    if min_length <= len(pwd) <= max_length:
+                        passwords.add(pwd)
+                    pwd = f"{num}{item}"
+                    if min_length <= len(pwd) <= max_length:
+                        passwords.add(pwd)
+                for char in self.lang_data['special_chars'][:2]:
+                    pwd = f"{item}{char}"
+                    if min_length <= len(pwd) <= max_length:
+                        passwords.add(pwd)
+                    pwd = f"{char}{item}"
+                    if min_length <= len(pwd) <= max_length:
+                        passwords.add(pwd)
+                    if len(item) > 4:
+                        pwd = f"{item[:len(item)//2]}{char}{item[len(item)//2:]}"
+                        if min_length <= len(pwd) <= max_length:
+                            passwords.add(pwd)
+        if len(weighted_elements) >= 2:
+            high_weight_elements = [e for e in weighted_elements if e[2] > 0.75]
+            emotional_items = [e for e in high_weight_elements if e[1] == 'high_emotional']
+            temporal_items = [e for e in weighted_elements if e[1] == 'temporal' and e[2] > 0.5]
+            for emo in emotional_items[:3]:
+                for temp in temporal_items[:2]:
+                    for sep in ['', '_', '@', '#', '!']:
+                        pwd = f"{emo[0]}{sep}{temp[0]}"
+                        if min_length <= len(pwd) <= max_length:
+                            passwords.add(pwd)
+                        pwd = f"{temp[0]}{sep}{emo[0]}"
+                        if min_length <= len(pwd) <= max_length:
+                            passwords.add(pwd)
+            for i in range(min(3, len(emotional_items))):
+                for j in range(min(3, len(emotional_items))):
+                    if i != j:
+                        for sep in ['', '_', '@']:
+                            pwd = f"{emotional_items[i][0]}{sep}{emotional_items[j][0]}"
+                            if min_length <= len(pwd) <= max_length:
+                                passwords.add(pwd)
+        if info.get('tech_savviness'):
+            try:
+                tech_level = int(info['tech_savviness'])
+                if tech_level >= 7:
+                    tech_terms = ['admin', 'root', 'sys', 'dev', 'prod', 'test', 'api', 'db', 'sql', 'http', 'www']
+                    for term in tech_terms:
+                        for num in ['123', '456', '789', '007', '2023', '2024']:
+                            pwd = f"{term}{num}"
+                            if min_length <= len(pwd) <= max_length:
+                                passwords.add(pwd)
+                        for special in self.lang_data['special_chars'][:2]:
+                            pwd = f"{term}{special}{datetime.now().year % 100}"
+                            if min_length <= len(pwd) <= max_length:
+                                passwords.add(pwd)
+                elif tech_level <= 3:
+                    for item, category, weight in weighted_elements:
+                        if weight > 0.5 and min_length <= len(item) <= max_length:
+                            passwords.add(item)
+        common_structures = [
+            "{word}{num}", "{num}{word}", "{word}{special}{num}",
+            "{word1}{word2}", "{word}{num}{special}", "{word}{special}{word}"
+        ]
+        for structure in common_structures:
+            if "{word}" in structure:
+                for item, category, weight in weighted_elements[:5]:
+                    if weight > 0.6:
+                        num = random.choice(self.lang_data['number_patterns'][:3])
+                        special = random.choice(self.lang_data['special_chars'])
+                        pwd = structure.format(word=item, num=num, special=special)
+                        if min_length <= len(pwd) <= max_length:
+                            passwords.add(pwd)
+            elif "{word1}" in structure and len(weighted_elements) >= 2:
+                for i in range(min(3, len(weighted_elements))):
+                    for j in range(min(3, len(weighted_elements))):
+                        if i != j:
+                            item1 = weighted_elements[i][0]
+                            item2 = weighted_elements[j][0]
+                            num = random.choice(self.lang_data['number_patterns'][:2])
+                            special = random.choice(self.lang_data['special_chars'])
+                            pwd = structure.format(word1=item1, word2=item2, num=num, special=special)
+                            if min_length <= len(pwd) <= max_length:
+                                passwords.add(pwd)
+        if info.get('leaked_passwords'):
+            for pwd in info['leaked_passwords']:
+                analysis = self.entropy_analyzer.analyze_password_patterns(pwd)
+                if analysis['has_digit'] and analysis['has_special']:
+                    new_num = random.choice(self.lang_data['number_patterns'][:3])
+                    new_special = random.choice(self.lang_data['special_chars'])
+                    new_pwd = re.sub(r'\d+', new_num, pwd)
+                    new_pwd = re.sub(r'[^\w\s]', new_special, new_pwd)
+                    if min_length <= len(new_pwd) <= max_length:
+                        passwords.add(new_pwd)
+        final_passwords = set()
+        for pwd in passwords:
+            leet_versions = self._apply_leet_transformations(pwd)
+            for leet_pwd in leet_versions:
+                if min_length <= len(leet_pwd) <= max_length:
+                    final_passwords.add(leet_pwd)
+        sorted_passwords = self._rank_passwords_by_probability(list(final_passwords), info, min_length, max_length)
+        return sorted_passwords[:count]
+    def _get_cultural_numbers(self, info):
+        target_language = info.get('language', 'en')
+        nationality = info.get('nationality', '').lower()
+        cultural_numbers = {
+            'en': {
+                'usa': ['1776', '13', '7', '42', '21', '69', '123', '2023', '2024'],
+                'uk': ['1066', '13', '7', '42', '18', '77', '123', '2023', '2024']
+            },
+            'de': {
+                'germany': ['1989', '13', '7', '42', '18', '88', '123', '2023', '2024'],
+                'austria': ['1918', '13', '7', '42', '19', '77', '123', '2023', '2024']
+            },
+            'fa': {
+                'iran': ['1399', '5', '7', '14', '22', '88', '99', '110', '313', '123', '2023', '2024'],
+                'afghanistan': ['1399', '7', '14', '22', '88', '99', '123', '2023', '2024']
+            },
+            'fr': {
+                'france': ['1789', '13', '7', '42', '14', '75', '89', '123', '2023', '2024']
+            },
+            'es': {
+                'spain': ['1492', '7', '10', '13', '21', '99', '123', '2023', '2024']
+            }
+        }
+        if nationality in cultural_numbers.get(target_language, {}):
+            return cultural_numbers[target_language][nationality]
+        default_numbers = {
+            'en': ['1', '7', '13', '21', '23', '69', '123', '2023', '2024'],
+            'de': ['7', '13', '18', '42', '77', '88', '123', '2023', '2024'],
+            'fa': ['5', '7', '14', '22', '88', '99', '110', '123', '2023', '2024'],
+            'fr': ['7', '13', '14', '17', '42', '75', '89', '123', '2023', '2024'],
+            'es': ['7', '10', '13', '21', '99', '123', '2023', '2024']
+        }
+        return default_numbers.get(target_language, ['1', '7', '12', '13', '21', '99', '123', '2023', '2024'])
+    def _rank_passwords_by_probability(self, passwords, info, min_length, max_length):
+        ranked = []
+        for pwd in passwords:
+            score = 0.0
+            length = len(pwd)
+            if min_length <= length <= max_length:
+                score += 0.4
+            elif min_length - 2 <= length <= max_length + 2:
+                score += 0.2
+            else:
+                score -= 0.2
+            analysis = self.entropy_analyzer.analyze_password_patterns(pwd)
+            if analysis['has_upper'] and analysis['has_lower'] and analysis['has_digit']:
+                score += 0.2
+            if analysis['has_special']:
+                score += 0.1
+            high_importance = ['pets', 'children', 'spouse', 'birth_year', 'anniversary']
+            for key in high_importance:
+                if key in info and info[key]:
+                    values = info[key] if isinstance(info[key], list) else [info[key]]
+                    for val in values:
+                        if val and val.lower() in pwd.lower():
+                            score += 0.5
+                            break
+            for event in self.lang_data['cultural_events']:
+                if event.lower() in pwd.lower():
+                    score += 0.2
+            if analysis['repeated_chars']:
+                score *= 0.6
+            if len(analysis['keyboard_patterns']) > 1:
+                score *= 0.5
+            behavior_predictor = UserBehaviorPredictor(info)
+            behavior_profile = behavior_predictor.predict_password_patterns()
+            for structure in behavior_profile['structure']:
+                pattern = structure.replace('{name}', '[a-zA-Z]+')
+                pattern = pattern.replace('{pet}', '[a-zA-Z]+')
+                pattern = pattern.replace('{child}', '[a-zA-Z]+')
+                pattern = pattern.replace('{spouse}', '[a-zA-Z]+')
+                pattern = pattern.replace('{birth_year}', '\d{4}')
+                pattern = pattern.replace('{number}', '\d+')
+                pattern = pattern.replace('{special}', '[!@#$%^&*()_+\-=\[\]{};\'\\:"|,.<>\/?]')
+                if re.match(f"^{pattern}$", pwd):
+                    score += 0.3
+            ranked.append((pwd, score))
+        ranked.sort(key=lambda x: x[1], reverse=True)
+        return [item[0] for item in ranked]
+    def _generate_cultural(self, info, count, min_length, max_length):
+        passwords = set()
+        lang_data = self.lang_data
+        relevant_events = []
+        relevant_events.extend(lang_data['cultural_events'])
+        nationality = info.get('nationality', '').lower()
+        if 'iran' in nationality or 'persian' in nationality:
+            relevant_events.extend(['Nowruz', 'Tasua', 'Ashura', 'Yalda', 'Sizdah Bedar'])
+        elif 'german' in nationality or 'germany' in nationality:
+            relevant_events.extend(['Oktoberfest', 'Weihnachten', 'Karneval', 'Silvester'])
+        elif 'french' in nationality or 'france' in nationality:
+            relevant_events.extend(['Bastille Day', 'Tour de France', 'La Fête de la Musique'])
+        elif 'spanish' in nationality or 'spain' in nationality:
+            relevant_events.extend(['La Tomatina', 'San Fermin', 'Dia de los Muertos'])
+        relevant_events = list(set(relevant_events))
+        for event in relevant_events[:5]:
+            for year_type in ['current_year', 'birth_year', 'common_years']:
+                years = []
+                if year_type == 'current_year':
+                    years = [str(datetime.now().year), str(datetime.now().year)[-2:]]
+                elif year_type == 'birth_year' and info.get('birth_year'):
+                    years = [info['birth_year'], info['birth_year'][-2:]]
+                else:
+                    years = ['2023', '2024', '23', '24', '00', '01', '99']
+                for year in years:
+                    structures = [
+                        '{event}{year}',
+                        '{year}{event}',
+                        '{event}_{year}',
+                        '{event}#{year}',
+                        '{event}@{year}',
+                        '{event}{special}{year}'
+                    ]
+                    for structure in structures:
+                        pwd = structure.format(event=event, year=year, special=random.choice(lang_data['special_chars']))
+                        if min_length <= len(pwd) <= max_length:
+                            passwords.add(pwd)
+            for num_pattern in lang_data['number_patterns'][:3]:
+                pwd = f"{event}{num_pattern}"
+                if min_length <= len(pwd) <= max_length:
+                    passwords.add(pwd)
+                pwd = f"{num_pattern}{event}"
+                if min_length <= len(pwd) <= max_length:
+                    passwords.add(pwd)
+        if info.get('zodiac'):
+            zodiac = info['zodiac']
+            for num_pattern in lang_data['number_patterns'][:2]:
+                pwd = f"{zodiac}{num_pattern}"
+                if min_length <= len(pwd) <= max_length:
+                    passwords.add(pwd)
+                pwd = f"{num_pattern}{zodiac}"
+                if min_length <= len(pwd) <= max_length:
+                    passwords.add(pwd)
+        cultural_numbers = self._get_cultural_numbers(info)
+        for event in relevant_events[:3]:
+            for num in cultural_numbers[:3]:
+                pwd = f"{event}{num}"
+                if min_length <= len(pwd) <= max_length:
+                    passwords.add(pwd)
+        return list(passwords)[:count]
+    def _predict_password_patterns(self, info):
+        behavior_predictor = UserBehaviorPredictor(info)
+        return behavior_predictor.predict_password_patterns()
+    def _generate_behavioral(self, info, count, min_length, max_length):
+        passwords = set()
+        behavior_profile = self._predict_password_patterns(info)
+        for structure in behavior_profile['structure'][:3]:
+            required_elements = []
+            if '{name}' in structure:
+                if info.get('first_name'):
+                    required_elements.append(info['first_name'])
+                elif info.get('nickname'):
+                    required_elements.append(info['nickname'])
+            if '{pet}' in structure and info.get('pets'):
+                required_elements.extend(info['pets'][:3])
+            if '{child}' in structure and info.get('children'):
+                required_elements.extend(info['children'][:2])
+            if '{spouse}' in structure and info.get('spouse'):
+                required_elements.append(info['spouse'])
+            if '{birth_year}' in structure and info.get('birth_year'):
+                required_elements.append(info['birth_year'])
+            if '{birth_date}' in structure and info.get('birth_day') and info.get('birth_month'):
+                required_elements.append(f"{info['birth_day']}{info['birth_month']}")
+            if '{cultural_event}' in structure:
+                required_elements.extend(self.lang_data['cultural_events'][:2])
+            if '{zodiac}' in structure and info.get('zodiac'):
+                required_elements.append(info['zodiac'])
+            if required_elements:
+                for elem in required_elements[:3]:
+                    for num_type in ['favorite_numbers', 'common_numbers', 'birth_year']:
+                        numbers = []
+                        if num_type == 'favorite_numbers' and info.get('favorite_numbers'):
+                            numbers = info['favorite_numbers'][:2]
+                        elif num_type == 'birth_year' and info.get('birth_year'):
+                            numbers = [info['birth_year']]
+                        else:
+                            numbers = self.lang_data['number_patterns'][:3]
+                        for num in numbers:
+                            pwd = structure
+                            if '{name}' in pwd:
+                                pwd = pwd.replace('{name}', elem, 1)
+                            if '{pet}' in pwd:
+                                pwd = pwd.replace('{pet}', elem, 1)
+                            if '{child}' in pwd:
+                                pwd = pwd.replace('{child}', elem, 1)
+                            if '{spouse}' in pwd:
+                                pwd = pwd.replace('{spouse}', elem, 1)
+                            if '{cultural_event}' in pwd:
+                                pwd = pwd.replace('{cultural_event}', elem, 1)
+                            if '{zodiac}' in pwd:
+                                pwd = pwd.replace('{zodiac}', elem, 1)
+                            if '{number}' in pwd:
+                                pwd = pwd.replace('{number}', num, 1)
+                            if '{special}' in pwd:
+                                pwd = pwd.replace('{special}', random.choice(self.lang_data['special_chars']), 1)
+                            if min_length <= len(pwd) <= max_length:
+                                passwords.add(pwd)
+        for pwd in list(passwords):
+            if 'leet_speak' in behavior_profile['transformations']:
+                leet_versions = self._apply_leet_transformations(pwd)
+                for leet_pwd in leet_versions:
+                    if min_length <= len(leet_pwd) <= max_length:
+                        passwords.add(leet_pwd)
+            if 'camel_case' in behavior_profile['transformations']:
+                camel_case = pwd[0].lower() + pwd[1:].capitalize()
+                if min_length <= len(camel_case) <= max_length:
+                    passwords.add(camel_case)
+            if 'random_caps' in behavior_profile['transformations']:
+                random_caps = ''.join(c.upper() if random.random() > 0.7 else c for c in pwd)
+                if min_length <= len(random_caps) <= max_length:
+                    passwords.add(random_caps)
+        if 'cultural_events' in behavior_profile['common_elements']:
+            for event in self.lang_data['cultural_events'][:3]:
+                for num in self.lang_data['number_patterns'][:2]:
+                    pwd = f"{event}{num}"
+                    if min_length <= len(pwd) <= max_length:
+                        passwords.add(pwd)
+                    pwd = f"{num}{event}"
+                    if min_length <= len(pwd) <= max_length:
+                        passwords.add(pwd)
+        if 'pets' in behavior_profile['common_elements'] and info.get('pets'):
+            for pet in info['pets'][:3]:
+                for num in ['01', '02', '03', '123', '2023', '2024']:
+                    pwd = f"{pet}{num}"
+                    if min_length <= len(pwd) <= max_length:
+                        passwords.add(pwd)
+        if 'children' in behavior_profile['common_elements'] and info.get('children'):
+            for child in info['children'][:2]:
+                for year in [info.get('birth_year', '')[-2:], '01', '2023']:
+                    if year:
+                        pwd = f"{child}{year}"
+                        if min_length <= len(pwd) <= max_length:
+                            passwords.add(pwd)
+        return list(passwords)[:count]
+    def _filter_and_rank_passwords(self, passwords, info, count, min_length, max_length):
+        valid_passwords = []
+        for pwd in passwords:
+            is_valid, _ = self._validate_password(pwd, info, min_length=min_length, max_length=max_length)
+            if is_valid:
+                valid_passwords.append(pwd)
+        ranked_passwords = []
+        for pwd in valid_passwords:
+            probability_score = self._calculate_password_probability(pwd, info, min_length, max_length)
+            ranked_passwords.append((pwd, probability_score))
+        ranked_passwords.sort(key=lambda x: x[1], reverse=True)
+        return [pwd for pwd, score in ranked_passwords[:count]]
+    def _calculate_password_probability(self, password, info, min_length, max_length):
+        score = 0.0
+        length = len(password)
+        if min_length <= length <= max_length:
+            score += 0.3
+        elif min_length - 2 <= length <= max_length + 2:
+            score += 0.1
+        else:
+            score -= 0.2
+        high_value_elements = ['pets', 'children', 'spouse', 'birth_year', 'anniversary']
+        for element in high_value_elements:
+            if element in info and info[element]:
+                values = info[element] if isinstance(info[element], list) else [info[element]]
+                for val in values:
+                    if val and val.lower() in password.lower():
+                        score += 0.9
+                        break
+        common_structures = [
+            r'^[a-zA-Z]+\d+$',
+            r'^\d+[a-zA-Z]+$',
+            r'^[a-zA-Z]+[!@#$%^&*()_+\-=\[\]{};\'\\:"|,.<>\/?]\d+$',
+            r'^[a-zA-Z]+\d+[!@#$%^&*()_+\-=\[\]{};\'\\:"|,.<>\/?]$'
+        ]
+        for pattern in common_structures:
+            if re.match(pattern, password):
+                score += 0.3
+                break
+        if (any(c.islower() for c in password) and any(c.isupper() for c in password)):
+            score += 0.1
+        if any(c.isdigit() for c in password):
+            score += 0.1
+        if any(c in string.punctuation for c in password):
+            score += 0.1
+        if re.search(r'(.)\1{2,}', password):
+            score *= 0.5
+        behavior_predictor = UserBehaviorPredictor(info)
+        behavior_profile = behavior_predictor.predict_password_patterns()
+        for structure in behavior_profile['structure']:
+            pattern = structure.replace('{name}', '[a-zA-Z]+')
+            pattern = pattern.replace('{pet}', '[a-zA-Z]+')
+            pattern = pattern.replace('{birth_year}', '\d{4}')
+            pattern = pattern.replace('{number}', '\d+')
+            pattern = pattern.replace('{special}', '[!@#$%^&*()_+\-=\[\]{};\'\\:"|,.<>\/?]')
+            if re.match(f"^{pattern}$", password):
+                score += 0.5
+        return min(1.0, score)
+    def _validate_password(self, password, info, min_length=8, max_length=64, entropy_threshold=45):
+        if not password or len(password) < min_length or len(password) > max_length:
+            return False, 0
+        behavior_predictor = UserBehaviorPredictor(info)
+        behavior_profile = behavior_predictor.get_password_generation_weights()
+        if behavior_profile['security_awareness'] < 0.4:
+            entropy_threshold = 35
+        elif behavior_profile['security_awareness'] > 0.7:
+            entropy_threshold = 55
+        has_upper = any(c in string.ascii_uppercase for c in password)
+        has_lower = any(c in string.ascii_lowercase for c in password)
+        has_digit = any(c in string.digits for c in password)
+        has_special = any(c in string.punctuation for c in password)
+        required_types = 3
+        if behavior_profile['security_awareness'] < 0.4:
+            required_types = 2
+        elif behavior_profile['security_awareness'] > 0.7:
+            required_types = 4
+        if sum([has_upper, has_lower, has_digit, has_special]) < required_types:
+            return False, 0
+        common_patterns = [
+            r'(?:password|pass|1234|qwerty|admin|login|welcome|123456|111111|iloveyou)',
+            r'(\d{4})\1',
+            r'(.)\1{2,}',
+            r'(abc|bcd|cde|def|efg|fgh|ghi|hij|ijk|jkl|klm|lmn|mno|nop|opq|pqr|qrs|rst|stu|uvw|vwx|wxy|xyz)'
+        ]
+        for pattern in common_patterns:
+            if re.search(pattern, password.lower()):
+                is_personal = False
+                personal_elements = []
+                for key in ['pets', 'children', 'spouse', 'birth_year', 'favorite_numbers', 'anniversary']:
+                    if info.get(key):
+                        if isinstance(info[key], str):
+                            personal_elements.append(info[key])
+                        elif isinstance(info[key], list):
+                            personal_elements.extend(info[key])
+                for elem in personal_elements:
+                    if elem and elem.lower() in password.lower():
+                        is_personal = True
+                        break
+                if not is_personal:
+                    return False, 0
+        for word in self.entropy_analyzer.dictionary_words:
+            if len(word) > 4 and word in password.lower():
+                is_personal = False
+                for key, value in info.items():
+                    if isinstance(value, str) and value.lower() == word:
+                        is_personal = True
+                        break
+                    elif isinstance(value, list):
+                        if any(v.lower() == word for v in value if isinstance(v, str)):
+                            is_personal = True
+                            break
+                cultural_data = [
+                    *self.lang_data['cultural_events'],
+                    *self.lang_data['zodiac_signs'],
+                    *self.lang_data['sports_teams'],
+                    *self.lang_data['universities']
+                ]
+                if any(word in item.lower() for item in cultural_data):
+                    is_personal = True
+                if not is_personal:
+                    return False, 0
+        entropy = self.entropy_analyzer.calculate_entropy(password)
+        if entropy < entropy_threshold:
+            return False, 0
+        if behavior_profile['tech_savviness'] > 0.7:
+            tech_terms = ['admin', 'root', 'sys', 'dev', 'prod', 'test', 'api', 'db', 'sql', 'http']
+            has_tech_term = any(term in password.lower() for term in tech_terms)
+            if not has_tech_term:
+                if entropy < entropy_threshold + 10:
+                    return False, 0
+        return True, entropy
+    def generate_with_context(self, info, count=50, min_length=8, max_length=12, strategy='comprehensive'):
+        behavior_predictor = UserBehaviorPredictor(info)
+        behavior_profile = behavior_predictor.predict_password_patterns()
+        behavior_weights = behavior_predictor.get_password_generation_weights()
+        self.context_weights = behavior_weights
+        if behavior_profile['structure'] and strategy == 'comprehensive':
+            if any('random' in s for s in behavior_profile['structure']):
+                strategy = 'behavioral'
+            elif any('emotional' in s for s in behavior_profile['structure']):
+                strategy = 'smart'
+        if strategy == 'comprehensive' or strategy == 'smart':
+            behavioral_passwords = self._generate_behavioral(info, count//2, min_length, max_length)
+            cultural_passwords = self._generate_cultural(info, count//3, min_length, max_length)
+            basic_passwords = self._generate_weighted_combinations(info, count//6, min_length, max_length)
+            all_passwords = behavioral_passwords + cultural_passwords + basic_passwords
+            return self._filter_and_rank_passwords(all_passwords, info, count, min_length, max_length)
+        elif strategy == 'behavioral':
+            return self._generate_behavioral(info, count, min_length, max_length)
+        elif strategy == 'cultural':
+            return self._generate_cultural(info, count, min_length, max_length)
+        else:
+            return self._generate_weighted_combinations(info, count, min_length, max_length)
+def get_extended_user_info():
+    print("\n" + "="*60)
+    print("🔐 ENTER DETAILED TARGET INFORMATION (PRESS ENTER TO SKIP FIELDS)")
+    print("="*60)
+    info = {'language': 'en'}
+    print("\n👤 PERSONAL INFORMATION")
+    info.update({
+        'first_name': input("First Name: "),
+        'middle_name': input("Middle Name: "),
+        'last_name': input("Last Name: "),
+        'nickname': input("Nickname: "),
+        'maiden_name': input("Mother's Maiden Name (type 'non' if unknown): "),
+        'gender': input("Gender: "),
+        'language': 'en',
+        'nationality': input("Nationality: "),
+        'passport': input("Passport Number: "),
+        'national_id': input("National ID Number: "),
+    })
+    print("\n📅 DATES & AGE")
+    info.update({
+        'birthdate': input("Birthdate (YYYY-MM-DD): "),
+        'birth_year': input("Birth Year: "),
+        'birth_month': input("Birth Month: "),
+        'birth_day': input("Birth Day: "),
+        'zodiac': input("Zodiac Sign: "),
+        'age': input("Age: "),
+        'deceased': input("Is the person deceased? (Y/N): ").lower() in ['y', 'yes'],
+        'death_date': input("Date of Death (if applicable): "),
+        'birth_time': input("Birth Time (HH:MM): "),
+    })
+    print("\n📍 LOCATION DETAILS")
+    info.update({
+        'city': input("City: "),
+        'state': input("State/Province: "),
+        'country': input("Country: "),
+        'zipcode': input("ZIP Code: "),
+        'street': input("Street Address: "),
+        'house_num': input("House Number: "),
+        'neighborhood': input("Neighborhood: "),
+        'travel_destinations': input("Frequent Travel Destinations (space separated): ").split(),
+    })
+    print("\n📞 CONTACT INFORMATION")
+    info.update({
+        'phone': input("Primary Phone: "),
+        'mobile': input("Mobile Number: "),
+        'home_phone': input("Home Phone: "),
+        'work_phone': input("Work Phone: "),
+        'email': input("Primary Email: "),
+        'alt_email': input("Alternative Email: "),
+        'social_media': input("Social Media Handles (space separated): ").split(),
+    })
+    print("\n💻 DIGITAL FOOTPRINT")
+    info.update({
+        'username': input("Primary Username: "),
+        'prev_usernames': input("Previous Usernames (space separated): ").split(),
+        'gaming_ids': input("Gaming IDs (space separated): ").split(),
+        'crypto_wallets': input("Crypto Wallet Addresses (space separated): ").split(),
+        'websites': input("Owned Websites (space separated): ").split(),
+        'device_models': input("Device Models (space separated): ").split(),
+        'wifi_ssids': input("Common WiFi SSIDs (space separated): ").split(),
+        'social_media_platforms': input("Social Media Platforms Used (space separated): ").split(),
+        'online_gaming_platforms': input("Gaming Platforms Used (space separated): ").split(),
+    })
+    print("\n🎓 EDUCATION & EMPLOYMENT")
+    info.update({
+        'school': input("High School: "),
+        'uni': input("University: "),
+        'grad_year': input("High School Graduation Year: "),
+        'major': input("University Major: "),
+        'grad_year_uni': input("University Graduation Year: "),
+        'job_title': input("Job Title: "),
+        'employer': input("Employer: "),
+        'employee_id': input("Employee ID: "),
+    })
+    print("\n👨‍👩‍👧‍👦 FAMILY MEMBERS")
+    info.update({
+        'spouse': input("Spouse's Name: "),
+        'spouse_birth': input("Spouse's Birth Year: "),
+        'children': input("Children's Names (space separated): ").split(),
+        'children_births': input("Children's Birth Years (space separated): ").split(),
+        'parents': input("Parents' Names (space separated): ").split(),
+        'in_laws': input("In-Laws' Names (space separated): ").split(),
+        'cousins': input("Close Cousins' Names (space separated): ").split(),
+        'relatives': input("Close Relatives' Names (space separated): ").split(),
+    })
+    print("\n❤️ INTERESTS & PREFERENCES")
+    info.update({
+        'hobbies': input("Hobbies (space separated): ").split(),
+        'sports': input("Sports Teams (space separated): ").split(),
+        'music': input("Favorite Bands/Artists (space separated): ").split(),
+        'movies': input("Favorite Movies (space separated): ").split(),
+        'tv_shows': input("Favorite TV Shows (space separated): ").split(),
+        'books': input("Favorite Books (space separated): ").split(),
+        'colors': input("Favorite Colors (space separated): ").split(),
+        'pets': input("Pet Names (space separated): ").split(),
+        'pet_types': input("Pet Species/Breeds (space separated): ").split(),
+        'cars': input("Car Models (space separated): ").split(),
+        'car_plates': input("Car License Plates (space separated): ").split(),
+        'brands': input("Favorite Brands (space separated): ").split(),
+        'foods': input("Favorite Foods (space separated): ").split(),
+        'restaurants': input("Frequent Restaurants (space separated): ").split(),
+        'authors': input("Favorite Authors (space separated): ").split(),
+        'actors': input("Favorite Actors/Actresses (space separated): ").split(),
+        'genres': input("Favorite Music/Movie Genres (space separated): ").split(),
+    })
+    print("\n🔒 SECURITY INFORMATION")
+    info.update({
+        'common_passwords': input("Known Common Passwords (space separated): ").split(),
+        'leaked_passwords': input("Previously Leaked Passwords (space separated): ").split(),
+        'data_breaches': input("Involved Data Breaches (space separated): ").split(),
+        'security_questions': input("Security Questions Used (space separated): ").split(),
+        'security_answers': input("Security Question Answers (space separated): ").split(),
+        'password_patterns': input("Common Password Patterns (space separated): ").split(),
+        'special_chars': input("Common Special Characters (space separated): ").split(),
+        'number_patterns': input("Common Number Patterns (space separated): ").split(),
+        'favorite_numbers': input("Favorite/Lucky Numbers (space separated): ").split(),
+    })
+    print("\n🧠 BEHAVIORAL PATTERNS")
+    info.update({
+        'leet_transforms': input("Common Leet Transformations (e.g., '4=a', '3=e') (space separated): ").split(),
+        'keyboard_walks': input("Common Keyboard Walks (space separated): ").split(),
+        'catchphrases': input("Frequently Used Catchphrases (space separated): ").split(),
+        'quotes': input("Favorite Quotes (space separated): ").split(),
+        'online_behaviors': input("Notable Online Behaviors (space separated): ").split(),
+    })
+    print("\n🔍 ADVANCED PROFILING")
+    info.update({
+        'political_views': input("Political Views (space separated): ").split(),
+        'religious_views': input("Religious Views (space separated): ").split(),
+        'ethnicity': input("Ethnicity: "),
+        'education_level': input("Education Level: "),
+        'income_range': input("Income Range: "),
+        'relationship_status': input("Relationship Status: "),
+        'occupation': input("Occupation: "),
+        'industry': input("Industry: "),
+        'tech_savviness': input("Tech Savviness (1-10): "),
+        'password_change_frequency': input("Password Change Frequency (monthly): "),
+    })
+    return info
+def save_passwords(passwords, info, filename="advanced_passwords.txt", min_length=8, max_length=12):
+    if not passwords:
+        print("❌ No valid passwords generated")
+        return
+    entropy_analyzer = PasswordEntropyAnalyzer(info.get('language', 'en'))
+    entropy_scores = [entropy_analyzer.calculate_entropy(p) for p in passwords]
+    avg_entropy = sum(entropy_scores) / len(entropy_scores)
+    password_analysis = []
+    for pwd in passwords:
+        analysis = entropy_analyzer.analyze_password_patterns(pwd)
+        password_analysis.append({
+            'password': pwd,
+            'length': analysis['length'],
+            'entropy': analysis['entropy'],
+            'complexity_score': min(10, round(analysis['entropy']/10)),
+            'pattern_types': []
+        })
+        if analysis['repeated_chars']:
+            password_analysis[-1]['pattern_types'].append('repeated_chars')
+        if analysis['keyboard_patterns']:
+            password_analysis[-1]['pattern_types'].append('keyboard_walk')
+        if analysis['common_words']:
+            password_analysis[-1]['pattern_types'].append('dictionary_word')
+        if analysis['cultural_patterns']:
+            password_analysis[-1]['pattern_types'].append('cultural_pattern')
+    password_analysis.sort(key=lambda x: x['entropy'], reverse=True)
+    output_dir = os.path.dirname(os.path.abspath(filename))
+    if output_dir and not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+    with open(filename, "w", encoding="utf-8") as f:
+        f.write("# ================================================\n")
+        f.write("# Ethically Generated Password List\n")
+        f.write("# ================================================\n")
+        f.write("# Generated with advanced algorithmic pattern analysis\n")
+        f.write("# For authorized security testing and educational purposes only\n")
+        f.write("# ================================================\n")
+        f.write(f"# Date: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
+        f.write(f"# Language: {LANGUAGE_DATA.get(info.get('language', 'en'), LANGUAGE_DATA['en'])['name']}\n")
+        f.write(f"# Length Constraints: {min_length}-{max_length} characters\n")
+        f.write(f"# Total Passwords: {len(passwords)}\n")
+        f.write(f"# Average Entropy: {avg_entropy:.2f}\n")
+        f.write(f"# Security Level: {'High' if avg_entropy > 60 else 'Medium' if avg_entropy > 45 else 'Low'}\n")
+        f.write("# ================================================\n")
+        f.write("# Target Profile Summary:\n")
+        f.write(f"# - Name: {info.get('first_name', '')} {info.get('last_name', '')}\n")
+        f.write(f"# - Location: {info.get('city', '')}, {info.get('country', '')}\n")
+        f.write(f"# - Age: {info.get('age', 'Unknown')}\n")
+        f.write("# ================================================\n")
+        f.write("# Password Analysis:\n")
+        f.write("# High Entropy (60+): Strong password patterns\n")
+        f.write("# Medium Entropy (45-60): Moderate security\n")
+        f.write("# Low Entropy (<45): Weak patterns, use with caution\n")
+        f.write("# ================================================\n")
+        f.write("# Passwords:\n")
+        for i, analysis in enumerate(password_analysis, 1):
+            pwd = analysis['password']
+            entropy = analysis['entropy']
+            complexity = analysis['complexity_score']
+            patterns = ", ".join(analysis['pattern_types']) if analysis['pattern_types'] else "complex_pattern"
+            f.write(f"{i:3}. {pwd}\n")
+            f.write(f"     🔍 Entropy: {entropy:.2f} | Length: {len(pwd)} | Complexity: {complexity}/10\n")
+            f.write(f"     📌 Pattern Type: {patterns}\n")
+            f.write(f"     💡 Security Rating: {'⭐' * complexity}{'☆' * (10-complexity)}\n")
+    print(f"\n✅ Saved {len(passwords)} advanced passwords to {filename}")
+    print(f"📊 Average entropy: {avg_entropy:.2f}")
+    print(f"📏 Length range: {min_length}-{max_length} characters")
+    print(f"📈 Security level: {'High' if avg_entropy > 60 else 'Medium' if avg_entropy > 45 else 'Low'}")
+    stats_file = filename.replace('.txt', '_stats.json')
+    stats = {
+        'metadata': {
+            'timestamp': datetime.now().isoformat(),
+            'language': info.get('language', 'en'),
+            'length_constraints': {
+                'min': min_length,
+                'max': max_length
+            },
+            'target_summary': {
+                'has_name': bool(info.get('first_name') and info.get('last_name')),
+                'has_birthdate': bool(info.get('birthdate')),
+                'has_email': bool(info.get('email')),
+                'country': info.get('country', 'Unknown')
+            },
+            'password_count': len(passwords),
+            'average_entropy': avg_entropy,
+            'security_level': 'High' if avg_entropy > 60 else 'Medium' if avg_entropy > 45 else 'Low'
+        },
+        'password_analysis': password_analysis
+    }
+    with open(stats_file, 'w', encoding='utf-8') as f:
+        json.dump(stats, f, ensure_ascii=False, indent=2)
+    print(f"📊 Detailed statistics saved to {stats_file}")
+def parse_arguments():
+    parser = argparse.ArgumentParser(
+        description="""
+        🔐 Advanced Password List Generator - Smart Algorithmic Edition
+        Generates highly personalized password guesses based on detailed user profiles.
+        Designed for ethical security testing and educational use only.
+        """,
+        formatter_class=argparse.RawTextHelpFormatter,
+        epilog="""
+        Example Usage:
+          python advanced_password_generator.py -c 100 --min_p 8 --max_p 12 -o passwords.txt --strategy smart
+          python advanced_password_generator.py -h
+        """
+    )
+    parser.add_argument(
+        '-c', '--count',
+        type=int,
+        default=50,
+        help="Number of passwords to generate (default: 50)"
+    )
+    parser.add_argument(
+        '--min_p',
+        type=int,
+        default=8,
+        help="Minimum length of generated passwords (default: 8)"
+    )
+    parser.add_argument(
+        '--max_p',
+        type=int,
+        default=12,
+        help="Maximum length of generated passwords (default: 12)"
+    )
+    parser.add_argument(
+        '-o', '--output',
+        type=str,
+        default='passwords.txt',
+        help="Output file name for generated passwords (default: passwords.txt)"
+    )
+    parser.add_argument(
+        '--seed',
+        type=int,
+        default=42,
+        help="Seed value for reproducibility (default: 42)"
+    )
+    parser.add_argument(
+        '--strategy',
+        type=str,
+        default='smart',
+        choices=['basic', 'cultural', 'behavioral', 'comprehensive', 'smart'],
+        help="Password generation strategy:\n"
+             "  basic         : Simple combinations of user info\n"
+             "  cultural      : Focus on cultural and language patterns\n"
+             "  behavioral    : Focus on typing behavior and habits\n"
+             "  comprehensive : Balanced combination of approaches\n"
+             "  smart         : Intelligent weighted combinations (default)"
+    )
+    parser.add_argument(
+        '--ethical-verify',
+        action='store_true',
+        default=True,
+        help="Enable ethical usage verification (default: True)"
+    )
+    parser.add_argument(
+        '--no-ethical-verify',
+        dest='ethical_verify',
+        action='store_false',
+        help="Disable ethical usage verification (not recommended)"
+    )
+    return parser.parse_args()
+def main():
+    print(r"""
+    🔐 Advanced Password List Generator v5.1 (Smart Algorithmic Edition)
+    🌐 Intelligent Algorithms • Ethical Safeguards • Comprehensive Profiling
+    ⚠️  For authorized security testing ONLY with explicit permission
+    """)
+    ethical_guard = EthicalSafeguard()
+    args = parse_arguments()
+    random.seed(args.seed)
+    if args.ethical_verify and not ethical_guard.verify_ethical_usage():
+        print("❌ Ethical verification failed. Exiting...")
+        return
+    info = get_extended_user_info()
+    print(f"\n🔄 Generating passwords using '{args.strategy}' strategy...")
+    generator = ContextualPasswordGenerator(
+        language=info.get('language', 'en')
+    )
+    passwords = generator.generate_with_context(
+        info, 
+        count=args.count, 
+        min_length=args.min_p,
+        max_length=args.max_p,
+        strategy=args.strategy
+    )
+    if args.ethical_verify:
+        ethical_guard.log_usage(len(passwords), info)
+    save_passwords(passwords, info, args.output, args.min_p, args.max_p)
+    print("\n" + "="*60)
+    print(" PASSWORD GENERATION COMPLETE - SECURITY RECOMMENDATIONS")
+    print("="*60)
+    print("1. This password list is for authorized security testing ONLY")
+    print("2. Always obtain explicit written permission before testing")
+    print("3. Securely delete these passwords after your authorized test")
+    print("4. Document all activities for your security report")
+    print("5. Never use these passwords for unauthorized access")
+    print("="*60)
+    print("🔒 Remember: With great power comes great responsibility")
+    print("="*60)
+if __name__ == "__main__":
+    main()

password-list-generator-complete-main/README.md

@@ -0,0 +1,175 @@
+# password-list-generator-complete
+pass list generator tool for **Ethical Hacking**  
+**under development**
+
+
+# 🔐 PLG_ysnrfd – Advanced Context-Aware Password Intelligence & Security Analyzer
+
+[![Python](https://img.shields.io/badge/python-3.8%2B-blue.svg)](https://www.python.org/)
+[![Security Tool](https://img.shields.io/badge/Security-Analyzer-critical.svg)]()
+
+---
+
+## 🚀 Overview
+
+**PLG_ysnrfd** is a powerful tool for **password security analysis** and **context-aware password generation**.  
+It leverages advanced algorithms for entropy calculation, pattern recognition, user behavior modeling, and cultural context to produce **strong, personalized passwords** and evaluate the strength of existing ones.
+
+This project is designed to improve cybersecurity awareness and is intended **only for authorized security testing and educational purposes**.
+
+---
+
+## ✨ Features
+
+- **Comprehensive Password Analysis**  
+  Detects dictionary words, keyboard patterns, repeated characters, cultural references, and common password structures.
+
+- **Entropy Calculation**  
+  Calculates the password entropy based on Shannon’s formula and penalizes weak or predictable patterns.
+
+- **Smart Password Generation**  
+  Creates personalized passwords using user information (e.g., names, pets, dates, cultural events) with advanced transformations (leet-speak, camelCase, hex encoding, etc.).
+
+- **Multi-Language Support**  
+  Supports **English, German, Persian, French, and Spanish** with language-specific wordlists and keyboard layouts.
+
+- **Ethical Safeguard System**  
+  Built-in interactive verification to ensure usage is legal and ethical (authorized penetration testing).
+
+- **Behavioral Prediction**  
+  Uses a `UserBehaviorPredictor` class to understand the security awareness, emotional bias, and cultural context of the user.
+
+- **Encrypted Logging**  
+  Secure logging of usage data with SHA-256 hashing.
+
+- **Leaked Password Transformation**  
+  Learns from compromised passwords and generates improved, stronger variants.
+
+---
+
+## 📦 Installation
+
+**1. Clone the repository**
+
+```bash
+git clone https://github.com/ysnrfd/password-list-generator-complete.git
+cd password-list-generator-complete
+```
+
+**2. Install dependencies**
+
+```bash
+pip install -r requirements.txt
+```
+
+**3. Required Python Libraries**
+
+nltk (WordNet, Punkt tokenizer)
+
+pandas
+
+scikit-learn
+
+requests
+
+tqdm
+
+python-Levenshtein
+
+**Note: For NLTK, you may need to download WordNet and Punkt data:**
+
+```python
+import nltk
+nltk.download('wordnet')
+nltk.download('punkt')
+```
+
+## 🔧 Usage
+
+**1. Run the tool directly**
+
+**Windows:**
+```python
+python PLG_ysnrfd.py
+```
+**Linux**:
+```python
+python3 PLG_ysnrfd.py
+```
+
+**2. Analyze the strength of a password**
+
+```python
+from PLG_ysnrfd import PasswordEntropyAnalyzer
+
+analyzer = PasswordEntropyAnalyzer(language='en')
+result = analyzer.analyze_password_patterns("MyP@ssw0rd2024")
+print(result)
+```
+
+**3. Generate context-aware passwords**
+
+```python
+from PLG_ysnrfd import ContextualPasswordGenerator
+
+user_info = {
+    'first_name': 'Alice',
+    'birth_year': '1995',
+    'pets': ['Luna'],
+    'nationality': 'USA',
+    'language': 'en'
+}
+
+generator = ContextualPasswordGenerator(language='en')
+passwords = generator._generate_weighted_combinations(user_info, count=10, min_length=8, max_length=16)
+print(passwords)
+```
+
+## ⚠️ Ethical Disclaimer
+
+This tool is strictly for educational and authorized penetration testing.
+Before usage, the program requires you to accept the Ethical Usage Agreement.
+Unauthorized use of this tool is illegal and unethical.
+Always ensure you have explicit written consent before testing any system.
+
+## 📂 Project Structure
+
+```structure
+password-list-generator-complete/
+│── PLG_ysnrfd.py
+│── requirements.txt
+│── README.md
+```
+
+## 🧠 Algorithms
+
+- **Entropy Calculation**  
+  Uses Shannon entropy, keyboard pattern detection, and character frequency analysis to assess password complexity.
+
+- **User Behavior Modeling**  
+  Predicts password habits based on cultural background, age, pets, children, and emotional factors.
+
+- **Context-Aware Password Generation**  
+  Combines personal data, cultural events, and randomized transformations to produce strong, unique passwords.
+
+## 📊 Roadmap
+
+- Integration with leaked password databases (HaveIBeenPwned API)
+
+- More language packs (Italian, Russian, Arabic)
+
+- Plugin-based architecture for custom rules
+
+## 📝 License
+
+This project is released under the **ysnrfd LICENSE.**
+See the LICENSE file for details.
+
+## 👤 Author
+
+**Developer: YSNRFD**  
+**Telegram: @ysnrfd**
+
+## 🌟 Support the Project
+
+**If you find this project useful, please give it a ⭐ on GitHub!**

password-list-generator-complete-main/requirements.txt

@@ -0,0 +1,7 @@
+argparse
+nltk>=3.8
+requests>=2.31
+tqdm>=4.66
+pandas>=2.0
+scikit-learn>=1.3
+python-Levenshtein>=0.21