Генератор паролей на Python: надежная защита своими руками

python --version

import random
import string

import secrets

import tkinter as tk
from tkinter import ttk, messagebox

def generate_password(length=12, use_letters=True, use_digits=True, use_special=True):
"""
Генерирует случайный пароль с заданными параметрами

Args:
length (int): Длина пароля
use_letters (bool): Использовать буквы
use_digits (bool): Использовать цифры
use_special (bool): Использовать специальные символы

Returns:
str: Сгенерированный пароль
"""
# Формируем набор символов на основе параметров
chars = ""
if use_letters:
chars += string.ascii_letters
if use_digits:
chars += string.digits
if use_special:
chars += string.punctuation

# Проверка: есть ли хоть какие-то символы для использования
if not chars:
raise ValueError("Должен быть выбран хотя бы один тип символов")

# Генерируем пароль
password = ""
for _ in range(length):
password += random.choice(chars)

return password

def generate_secure_password(length=12, use_letters=True, use_digits=True, use_special=True):
"""
Генерирует пароль, гарантируя наличие всех выбранных типов символов
"""
if length < (use_letters + use_digits + use_special):
raise ValueError("Длина пароля должна быть не менее количества выбранных типов символов")

# Создаем базовый пароль
password = generate_password(length, use_letters, use_digits, use_special)

# Проверяем, содержит ли пароль все необходимые типы символов
has_letter = any(c in string.ascii_letters for c in password) if use_letters else True
has_digit = any(c in string.digits for c in password) if use_digits else True
has_special = any(c in string.punctuation for c in password) if use_special else True

# Если какой-то тип отсутствует, генерируем пароль заново
if not (has_letter and has_digit and has_special):
return generate_secure_password(length, use_letters, use_digits, use_special)

return password

import secrets

def generate_cryptographic_password(length=12, use_letters=True, use_digits=True, use_special=True):
"""
Генерирует криптографически стойкий пароль
"""
# Формируем набор символов
chars = ""
if use_letters:
chars += string.ascii_letters
if use_digits:
chars += string.digits
if use_special:
chars += string.punctuation

if not chars:
raise ValueError("Должен быть выбран хотя бы один тип символов")

# Генерируем пароль с использованием secrets
password = ''.join(secrets.choice(chars) for _ in range(length))

# Проверяем наличие всех типов символов
has_letter = any(c in string.ascii_letters for c in password) if use_letters else True
has_digit = any(c in string.digits for c in password) if use_digits else True
has_special = any(c in string.punctuation for c in password) if use_special else True

# Если не все типы присутствуют, генерируем заново
if not (has_letter and has_digit and has_special):
return generate_cryptographic_password(length, use_letters, use_digits, use_special)

return password

def evaluate_password_strength(password):
"""
Оценивает сложность пароля по шкале от 0 до 100
"""
score = 0

# Базовый балл за длину
if len(password) >= 8:
score += 10
if len(password) >= 12:
score += 20
if len(password) >= 16:
score += 20

# Баллы за разнообразие символов
if any(c in string.ascii_lowercase for c in password):
score += 10
if any(c in string.ascii_uppercase for c in password):
score += 10
if any(c in string.digits for c in password):
score += 10
if any(c in string.punctuation for c in password):
score += 20

# Проверка на повторяющиеся символы
if len(set(password)) >= len(password) * 0.8:
score += 10

return score

if __name__ == "__main__":
# Тестируем базовый генератор
print("Стандартный пароль (12 символов):")
print(generate_password())

# Тестируем генератор с проверкой всех типов символов
print("\nБезопасный пароль с гарантией всех типов символов:")
print(generate_secure_password())

# Тестируем криптографический генератор
print("\nКриптографически стойкий пароль:")
print(generate_cryptographic_password())

# Генерируем пароль с конкретными параметрами
print("\nПароль длиной 16 символов без спецсимволов:")
custom_password = generate_cryptographic_password(16, True, True, False)
print(custom_password)

# Оцениваем сложность пароля
strength = evaluate_password_strength(custom_password)
print(f"Сложность пароля: {strength}/100")

import tkinter as tk
from tkinter import ttk, messagebox
import pyperclip # Для копирования в буфер обмена (необходимо установить: pip install pyperclip)
from password_generator import generate_cryptographic_password, evaluate_password_strength

class PasswordGeneratorApp:
def __init__(self, root):
self.root = root
self.root.title("Генератор паролей")
self.root.geometry("500x450")
self.root.resizable(False, False)

# Настройка интерфейса
self.setup_ui()

def setup_ui(self):
# Главная рамка
main_frame = ttk.Frame(self.root, padding=20)
main_frame.pack(fill="both", expand=True)

# Заголовок
ttk.Label(main_frame, text="Генератор надёжных паролей", font=("Helvetica", 16)).pack(pady=10)

# Рамка для настроек
settings_frame = ttk.LabelFrame(main_frame, text="Настройки пароля", padding=10)
settings_frame.pack(fill="x", pady=10)

# Длина пароля
length_frame = ttk.Frame(settings_frame)
length_frame.pack(fill="x", pady=5)
ttk.Label(length_frame, text="Длина пароля:").pack(side="left")

self.length_var = tk.IntVar(value=12)
length_scale = ttk.Scale(length_frame, from_=8, to=32, variable=self.length_var,
orient="horizontal", length=200, command=self.update_length_label)
length_scale.pack(side="left", padx=10)

self.length_label = ttk.Label(length_frame, text="12")
self.length_label.pack(side="left")

# Опции для типов символов
options_frame = ttk.Frame(settings_frame)
options_frame.pack(fill="x", pady=10)

self.use_letters = tk.BooleanVar(value=True)
self.use_digits = tk.BooleanVar(value=True)
self.use_special = tk.BooleanVar(value=True)

ttk.Checkbutton(options_frame, text="Буквы (A-Z, a-z)", variable=self.use_letters).pack(anchor="w")
ttk.Checkbutton(options_frame, text="Цифры (0-9)", variable=self.use_digits).pack(anchor="w")
ttk.Checkbutton(options_frame, text="Специальные символы (!@#$)", variable=self.use_special).pack(anchor="w")

# Рамка для вывода пароля
result_frame = ttk.LabelFrame(main_frame, text="Ваш пароль", padding=10)
result_frame.pack(fill="x", pady=10)

self.password_var = tk.StringVar()
password_entry = ttk.Entry(result_frame, textvariable=self.password_var, font=("Courier", 12), width=32)
password_entry.pack(pady=10, fill="x")

# Кнопки действий
buttons_frame = ttk.Frame(main_frame)
buttons_frame.pack(fill="x", pady=10)

ttk.Button(buttons_frame, text="Сгенерировать", command=self.generate_password).pack(side="left", padx=5)
ttk.Button(buttons_frame, text="Копировать", command=self.copy_to_clipboard).pack(side="left", padx=5)

# Индикатор сложности пароля
strength_frame = ttk.LabelFrame(main_frame, text="Сложность пароля", padding=10)
strength_frame.pack(fill="x", pady=10)

self.strength_var = tk.IntVar()
self.strength_progressbar = ttk.Progressbar(strength_frame, variable=self.strength_var, maximum=100)
self.strength_progressbar.pack(fill="x", pady=5)

self.strength_label = ttk.Label(strength_frame, text="Нет пароля")
self.strength_label.pack(anchor="w")

def update_length_label(self, *args):
self.length_label.config(text=str(self.length_var.get()))

def generate_password(self):
try:
# Проверяем, что хотя бы один тип символов выбран
if not (self.use_letters.get() or self.use_digits.get() or self.use_special.get()):
messagebox.showerror("Ошибка", "Выберите хотя бы один тип символов")
return

# Генерируем пароль
password = generate_cryptographic_password(
self.length_var.get(),
self.use_letters.get(),
self.use_digits.get(),
self.use_special.get()
)

# Обновляем поле с паролем
self.password_var.set(password)

# Оцениваем и отображаем сложность
strength = evaluate_password_strength(password)
self.strength_var.set(strength)

if strength < 40:
strength_text = "Слабый пароль"
elif strength < 70:
strength_text = "Средний пароль"
else:
strength_text = "Сильный пароль"

self.strength_label.config(text=f"{strength_text} ({strength}/100)")

except Exception as e:
messagebox.showerror("Ошибка", str(e))

def copy_to_clipboard(self):
password = self.password_var.get()
if password:
pyperclip.copy(password)
messagebox.showinfo("Успешно", "Пароль скопирован в буфер обмена")
else:
messagebox.showwarning("Предупреждение", "Сначала сгенерируйте пароль")

if __name__ == "__main__":
root = tk.Tk()
app = PasswordGeneratorApp(root)
root.mainloop()

pip install pyperclip

def improved_password_generation(length, use_letters=True, use_digits=True, use_special=True):
"""
Улучшенный алгоритм генерации пароля, гарантирующий наличие всех выбранных типов символов
без использования рекурсии
"""
# Определяем, какие типы символов используются
char_types = []
if use_letters:
char_types.append(string.ascii_lowercase)
char_types.append(string.ascii_uppercase)
if use_digits:
char_types.append(string.digits)
if use_special:
char_types.append(string.punctuation)

if not char_types:
raise ValueError("Должен быть выбран хотя бы один тип символов")

# Создаем список для символов пароля
password_chars = []

# Сначала добавляем по одному символу каждого типа
for char_set in char_types:
password_chars.append(secrets.choice(char_set))

# Создаем общий набор символов для заполнения оставшейся длины
all_chars = ''.join(char_types)

# Добавляем остальные символы
remaining_length = length – len(password_chars)
password_chars.extend(secrets.choice(all_chars) for _ in range(remaining_length))

# Перемешиваем символы для случайного порядка
secrets.SystemRandom().shuffle(password_chars)

# Преобразуем список в строку
return ''.join(password_chars)

def generate_readable_password(length, avoid_similar=True):
"""
Генерирует пароль, исключая похожие символы для лучшей читаемости
"""
# Определяем символы для исключения
similar_chars = "il1Lo0O"

chars = string.ascii_letters + string.digits

if avoid_similar:
# Удаляем похожие символы
for char in similar_chars:
chars = chars.replace(char, '')

# Генерируем пароль
password = ''.join(secrets.choice(chars) for _ in range(length))
return password

def generate_memorable_password(num_words=4, separator="-", capitalize=True):
"""
Создаёт запоминающийся пароль из случайных слов
Требует файл со словами (например, /usr/share/dict/words на Linux)
"""
try:
with open("/usr/share/dict/words") as f:
words = [word.strip() for word in f if 3 <= len(word.strip()) <= 8]
except FileNotFoundError:
# Если файл не найден, используем базовый набор слов
words = ["apple", "banana", "carrot", "diamond", "elephant", "forest", 
"garden", "harbor", "island", "jungle", "kingdom", "lemon", 
"mountain", "network", "orange", "planet", "quantum", "river", 
"system", "turtle", "umbrella", "valley", "winter", "xylophone", 
"yellow", "zebra"]

# Выбираем случайные слова
selected_words = [secrets.choice(words) for _ in range(num_words)]

# Применяем форматирование
if capitalize:
selected_words = [word.capitalize() for word in selected_words]

# Добавляем цифру для усиления
selected_words[-1] = selected_words[-1] + str(secrets.randbelow(100))

# Собираем пароль с разделителем
return separator.join(selected_words)

import math

def calculate_entropy(password):
"""
Рассчитывает энтропию пароля в битах
"""
# Определяем размер алфавита
has_lowercase = any(c in string.ascii_lowercase for c in password)
has_uppercase = any(c in string.ascii_uppercase for c in password)
has_digits = any(c in string.digits for c in password)
has_special = any(c in string.punctuation for c in password)

# Подсчитываем размер символьного пространства
char_space = 0
if has_lowercase: char_space += 26
if has_uppercase: char_space += 26
if has_digits: char_space += 10
if has_special: char_space += 33 # Примерное количество спецсимволов

# Рассчитываем энтропию по формуле: log2(char_space^length)
if char_space == 0:
return 0

entropy = math.log2(char_space) * len(password)
return entropy